The Tor Browser / file revision

 // 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 <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);

   // 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);

   // 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);

 };

 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);

 };

 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_