message_pump_mac.h

mozilla-central/ipc/chromium/src/base/message_pump_mac.h (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: IPC

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

// Copyright (c) 2008 The Chromium Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

// The basis for all native run loops on the Mac is the CFRunLoop.  It can be

// used directly, it can be used as the driving force behind the similar

// Foundation NSRunLoop, and it can be used to implement higher-level event

// loops such as the NSApplication event loop.

//

// This file introduces a basic CFRunLoop-based implementation of the

// MessagePump interface called CFRunLoopBase.  CFRunLoopBase contains all

// of the machinery necessary to dispatch events to a delegate, but does not

// implement the specific run loop.  Concrete subclasses must provide their

// own DoRun and Quit implementations.

//

// A concrete subclass that just runs a CFRunLoop loop is provided in

// MessagePumpCFRunLoop.  For an NSRunLoop, the similar MessagePumpNSRunLoop

// is provided.

//

// For the application's event loop, an implementation based on AppKit's

// NSApplication event system is provided in MessagePumpNSApplication.

//

// Typically, MessagePumpNSApplication only makes sense on a Cocoa

// application's main thread.  If a CFRunLoop-based message pump is needed on

// any other thread, one of the other concrete subclasses is preferrable.

// MessagePumpMac::Create is defined, which returns a new NSApplication-based

// or NSRunLoop-based MessagePump subclass depending on which thread it is

// called on.

#ifndef BASE_MESSAGE_PUMP_MAC_H_

#define BASE_MESSAGE_PUMP_MAC_H_

#include "base/message_pump.h"

#include "base/basictypes.h"

#include <CoreFoundation/CoreFoundation.h>

#include <IOKit/IOKitLib.h>

#if defined(__OBJC__)

@class NSAutoreleasePool;

#else   // defined(__OBJC__)

class NSAutoreleasePool;

#endif  // defined(__OBJC__)

namespace base {

class TimeTicks;

class MessagePumpCFRunLoopBase : public MessagePump {

  // Needs access to CreateAutoreleasePool.

  friend class MessagePumpScopedAutoreleasePool;

 public:

  MessagePumpCFRunLoopBase();

  virtual ~MessagePumpCFRunLoopBase();

  // Subclasses should implement the work they need to do in MessagePump::Run

  // in the DoRun method.  MessagePumpCFRunLoopBase::Run calls DoRun directly.

  // This arrangement is used because MessagePumpCFRunLoopBase needs to set

  // up and tear down things before and after the "meat" of DoRun.

  virtual void Run(Delegate* delegate);

  virtual void DoRun(Delegate* delegate) = 0;

  virtual void ScheduleWork();

  virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time);

 protected:

  // Accessors for private data members to be used by subclasses.

  CFRunLoopRef run_loop() const { return run_loop_; }

  int nesting_level() const { return nesting_level_; }

  int run_nesting_level() const { return run_nesting_level_; }

  // Return an autorelease pool to wrap around any work being performed.

  // In some cases, CreateAutoreleasePool may return nil intentionally to

  // preventing an autorelease pool from being created, allowing any

  // objects autoreleased by work to fall into the current autorelease pool.

  virtual NSAutoreleasePool* CreateAutoreleasePool();

 private:

  // Timer callback scheduled by ScheduleDelayedWork.  This does not do any

  // work, but it signals delayed_work_source_ so that delayed work can be

  // performed within the appropriate priority constraints.

  static void RunDelayedWorkTimer(CFRunLoopTimerRef timer, void* info);

  // Perform highest-priority work.  This is associated with work_source_

  // signalled by ScheduleWork.  The static method calls the instance method;

  // the instance method returns true if work was done.

  static void RunWorkSource(void* info);

  bool RunWork();

  // Perform delayed-priority work.  This is associated with

  // delayed_work_source_ signalled by RunDelayedWorkTimer, and is responsible

  // for calling ScheduleDelayedWork again if appropriate.  The static method

  // calls the instance method; the instance method returns true if more

  // delayed work is available.

  static void RunDelayedWorkSource(void* info);

  bool RunDelayedWork();

  // Perform idle-priority work.  This is normally called by PreWaitObserver,

  // but is also associated with idle_work_source_.  When this function

  // actually does perform idle work, it will resignal that source.  The

  // static method calls the instance method; the instance method returns

  // true if idle work was done.

  static void RunIdleWorkSource(void* info);

  bool RunIdleWork();

  // Perform work that may have been deferred because it was not runnable

  // within a nested run loop.  This is associated with

  // nesting_deferred_work_source_ and is signalled by

  // MaybeScheduleNestingDeferredWork when returning from a nested loop,

  // so that an outer loop will be able to perform the necessary tasks if it

  // permits nestable tasks.

  static void RunNestingDeferredWorkSource(void* info);

  bool RunNestingDeferredWork();

  // Schedules possible nesting-deferred work to be processed before the run

  // loop goes to sleep, exits, or begins processing sources at the top of its

  // loop.  If this function detects that a nested loop had run since the

  // previous attempt to schedule nesting-deferred work, it will schedule a

  // call to RunNestingDeferredWorkSource.

  void MaybeScheduleNestingDeferredWork();

  // Observer callback responsible for performing idle-priority work, before

  // the run loop goes to sleep.  Associated with idle_work_observer_.

  static void PreWaitObserver(CFRunLoopObserverRef observer,

                              CFRunLoopActivity activity, void* info);

  // Observer callback called before the run loop processes any sources.

  // Associated with pre_source_observer_.

  static void PreSourceObserver(CFRunLoopObserverRef observer,

                                CFRunLoopActivity activity, void* info);

  // Observer callback called when the run loop starts and stops, at the

  // beginning and end of calls to CFRunLoopRun.  This is used to maintain

  // nesting_level_.  Associated with enter_exit_observer_.

  static void EnterExitObserver(CFRunLoopObserverRef observer,

                                CFRunLoopActivity activity, void* info);

  // Called by EnterExitObserver after performing maintenance on nesting_level_.

  // This allows subclasses an opportunity to perform additional processing on

  // the basis of run loops starting and stopping.

  virtual void EnterExitRunLoop(CFRunLoopActivity activity);

#if !defined(XP_IOS)

  // IOKit power state change notification callback, called when the system

  // enters and leaves the sleep state.

  static void PowerStateNotification(void* info, io_service_t service,

                                     uint32_t message_type,

                                     void* message_argument);

#endif

  // The thread's run loop.

  CFRunLoopRef run_loop_;

  // The timer, sources, and observers are described above alongside their

  // callbacks.

  CFRunLoopTimerRef delayed_work_timer_;

  CFRunLoopSourceRef work_source_;

  CFRunLoopSourceRef delayed_work_source_;

  CFRunLoopSourceRef idle_work_source_;

  CFRunLoopSourceRef nesting_deferred_work_source_;

  CFRunLoopObserverRef pre_wait_observer_;

  CFRunLoopObserverRef pre_source_observer_;

  CFRunLoopObserverRef enter_exit_observer_;

  // Objects used for power state notification.  See PowerStateNotification.

  io_connect_t root_power_domain_;

  IONotificationPortRef power_notification_port_;

  io_object_t power_notification_object_;

  // (weak) Delegate passed as an argument to the innermost Run call.

  Delegate* delegate_;

  // The time that delayed_work_timer_ is scheduled to fire.  This is tracked

  // independently of CFRunLoopTimerGetNextFireDate(delayed_work_timer_)

  // to be able to reset the timer properly after waking from system sleep.

  // See PowerStateNotification.

  CFAbsoluteTime delayed_work_fire_time_;

  // The recursion depth of the currently-executing CFRunLoopRun loop on the

  // run loop's thread.  0 if no run loops are running inside of whatever scope

  // the object was created in.

  int nesting_level_;

  // The recursion depth (calculated in the same way as nesting_level_) of the

  // innermost executing CFRunLoopRun loop started by a call to Run.

  int run_nesting_level_;

  // The deepest (numerically highest) recursion depth encountered since the

  // most recent attempt to run nesting-deferred work.

  int deepest_nesting_level_;

  // "Delegateless" work flags are set when work is ready to be performed but

  // must wait until a delegate is available to process it.  This can happen

  // when a MessagePumpCFRunLoopBase is instantiated and work arrives without

  // any call to Run on the stack.  The Run method will check for delegateless

  // work on entry and redispatch it as needed once a delegate is available.

  bool delegateless_work_;

  bool delegateless_delayed_work_;

  bool delegateless_idle_work_;

  DISALLOW_COPY_AND_ASSIGN(MessagePumpCFRunLoopBase);

};

class MessagePumpCFRunLoop : public MessagePumpCFRunLoopBase {

 public:

  MessagePumpCFRunLoop();

  virtual void DoRun(Delegate* delegate);

  virtual void Quit();

 private:

  virtual void EnterExitRunLoop(CFRunLoopActivity activity);

  // True if Quit is called to stop the innermost MessagePump

  // (innermost_quittable_) but some other CFRunLoopRun loop (nesting_level_)

  // is running inside the MessagePump's innermost Run call.

  bool quit_pending_;

  DISALLOW_COPY_AND_ASSIGN(MessagePumpCFRunLoop);

};

class MessagePumpNSRunLoop : public MessagePumpCFRunLoopBase {

 public:

  MessagePumpNSRunLoop();

  virtual ~MessagePumpNSRunLoop();

  virtual void DoRun(Delegate* delegate);

  virtual void Quit();

 private:

  // A source that doesn't do anything but provide something signalable

  // attached to the run loop.  This source will be signalled when Quit

  // is called, to cause the loop to wake up so that it can stop.

  CFRunLoopSourceRef quit_source_;

  // False after Quit is called.

  bool keep_running_;

  DISALLOW_COPY_AND_ASSIGN(MessagePumpNSRunLoop);

};

#if defined(XP_IOS)

// This is a fake message pump.  It attaches sources to the main thread's

// CFRunLoop, so PostTask() will work, but it is unable to drive the loop

// directly, so calling Run() or Quit() are errors.

class MessagePumpUIApplication : public MessagePumpCFRunLoopBase {

 public:

  MessagePumpUIApplication() {}

  void DoRun(Delegate* delegate) override;

  void Quit() override;

 private:

  DISALLOW_COPY_AND_ASSIGN(MessagePumpUIApplication);

};

#else

class MessagePumpNSApplication : public MessagePumpCFRunLoopBase {

 public:

  MessagePumpNSApplication();

  virtual void DoRun(Delegate* delegate);

  virtual void Quit();

 protected:

  // Returns nil if NSApp is currently in the middle of calling -sendEvent.

  virtual NSAutoreleasePool* CreateAutoreleasePool();

 private:

  // False after Quit is called.

  bool keep_running_;

  // True if DoRun is managing its own run loop as opposed to letting

  // -[NSApplication run] handle it.  The outermost run loop in the application

  // is managed by -[NSApplication run], inner run loops are handled by a loop

  // in DoRun.

  bool running_own_loop_;

  DISALLOW_COPY_AND_ASSIGN(MessagePumpNSApplication);

};

#endif

class MessagePumpMac {

 public:

  // Returns a new instance of MessagePumpNSApplication if called on the main

  // thread.  Otherwise, returns a new instance of MessagePumpNSRunLoop.

  static MessagePump* Create();

 private:

  DISALLOW_IMPLICIT_CONSTRUCTORS(MessagePumpMac);

};

}  // namespace base

#endif  // BASE_MESSAGE_PUMP_MAC_H_