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.

 #include "base/message_pump_mac.h"

 #import <AppKit/AppKit.h>

 #import <Foundation/Foundation.h>

 #include <IOKit/IOMessage.h>

 #include <IOKit/pwr_mgt/IOPMLib.h>

 #include <limits>

 #import "base/chrome_application_mac.h"

 #include "base/logging.h"

 #include "base/time.h"

 namespace {

 void NoOp(void* info) {

 }

 const CFTimeInterval kCFTimeIntervalMax =

     std::numeric_limits<CFTimeInterval>::max();

 }  // namespace

 namespace base {

 // A scoper for autorelease pools created from message pump run loops.

 // Avoids dirtying up the ScopedNSAutoreleasePool interface for the rare

 // case where an autorelease pool needs to be passed in.

 class MessagePumpScopedAutoreleasePool {

  public:

   explicit MessagePumpScopedAutoreleasePool(MessagePumpCFRunLoopBase* pump) :

       pool_(pump->CreateAutoreleasePool()) {

   }

    ~MessagePumpScopedAutoreleasePool() {

     [pool_ drain];

   }

  private:

   NSAutoreleasePool* pool_;

   DISALLOW_COPY_AND_ASSIGN(MessagePumpScopedAutoreleasePool);

 };

 // Must be called on the run loop thread.

 MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase()

     : delegate_(NULL),

       delayed_work_fire_time_(kCFTimeIntervalMax),

       nesting_level_(0),

       run_nesting_level_(0),

       deepest_nesting_level_(0),

       delegateless_work_(false),

       delegateless_delayed_work_(false),

       delegateless_idle_work_(false) {

   run_loop_ = CFRunLoopGetCurrent();

   CFRetain(run_loop_);

   // Set a repeating timer with a preposterous firing time and interval.  The

   // timer will effectively never fire as-is.  The firing time will be adjusted

   // as needed when ScheduleDelayedWork is called.

   CFRunLoopTimerContext timer_context = CFRunLoopTimerContext();

   timer_context.info = this;

   delayed_work_timer_ = CFRunLoopTimerCreate(NULL,                // allocator

                                              kCFTimeIntervalMax,  // fire time

                                              kCFTimeIntervalMax,  // interval

                                              0,                   // flags

                                              0,                   // priority

                                              RunDelayedWorkTimer,

                                              &timer_context);

   CFRunLoopAddTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);

   CFRunLoopSourceContext source_context = CFRunLoopSourceContext();

   source_context.info = this;

   source_context.perform = RunWorkSource;

   work_source_ = CFRunLoopSourceCreate(NULL,  // allocator

                                        1,     // priority

                                        &source_context);

   CFRunLoopAddSource(run_loop_, work_source_, kCFRunLoopCommonModes);

   source_context.perform = RunDelayedWorkSource;

   delayed_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator

                                                2,     // priority

                                                &source_context);

   CFRunLoopAddSource(run_loop_, delayed_work_source_, kCFRunLoopCommonModes);

   source_context.perform = RunIdleWorkSource;

   idle_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator

                                             3,     // priority

                                             &source_context);

   CFRunLoopAddSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);

   source_context.perform = RunNestingDeferredWorkSource;

   nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator

                                                         0,     // priority

                                                         &source_context);

   CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,

                      kCFRunLoopCommonModes);

   CFRunLoopObserverContext observer_context = CFRunLoopObserverContext();

   observer_context.info = this;

   pre_wait_observer_ = CFRunLoopObserverCreate(NULL,  // allocator

                                                kCFRunLoopBeforeWaiting,

                                                true,  // repeat

                                                0,     // priority

                                                PreWaitObserver,

                                                &observer_context);

   CFRunLoopAddObserver(run_loop_, pre_wait_observer_, kCFRunLoopCommonModes);

   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator

                                                  kCFRunLoopBeforeSources,

                                                  true,  // repeat

                                                  0,     // priority

                                                  PreSourceObserver,

                                                  &observer_context);

   CFRunLoopAddObserver(run_loop_, pre_source_observer_, kCFRunLoopCommonModes);

   enter_exit_observer_ = CFRunLoopObserverCreate(NULL,  // allocator

                                                  kCFRunLoopEntry |

                                                      kCFRunLoopExit,

                                                  true,  // repeat

                                                  0,     // priority

                                                  EnterExitObserver,

                                                  &observer_context);

   CFRunLoopAddObserver(run_loop_, enter_exit_observer_, kCFRunLoopCommonModes);

   root_power_domain_ = IORegisterForSystemPower(this,

                                                 &power_notification_port_,

                                                 PowerStateNotification,

                                                 &power_notification_object_);

   if (root_power_domain_ != MACH_PORT_NULL) {

     CFRunLoopAddSource(

         run_loop_,

         IONotificationPortGetRunLoopSource(power_notification_port_),

         kCFRunLoopCommonModes);

   }

 }

 // Ideally called on the run loop thread.  If other run loops were running

 // lower on the run loop thread's stack when this object was created, the

 // same number of run loops must be running when this object is destroyed.

 MessagePumpCFRunLoopBase::~MessagePumpCFRunLoopBase() {

   if (root_power_domain_ != MACH_PORT_NULL) {

     CFRunLoopRemoveSource(

         run_loop_,

         IONotificationPortGetRunLoopSource(power_notification_port_),

         kCFRunLoopCommonModes);

     IODeregisterForSystemPower(&power_notification_object_);

     IOServiceClose(root_power_domain_);

     IONotificationPortDestroy(power_notification_port_);

   }

   CFRunLoopRemoveObserver(run_loop_, enter_exit_observer_,

                           kCFRunLoopCommonModes);

   CFRelease(enter_exit_observer_);

   CFRunLoopRemoveObserver(run_loop_, pre_source_observer_,

                           kCFRunLoopCommonModes);

   CFRelease(pre_source_observer_);

   CFRunLoopRemoveObserver(run_loop_, pre_wait_observer_,

                           kCFRunLoopCommonModes);

   CFRelease(pre_wait_observer_);

   CFRunLoopRemoveSource(run_loop_, nesting_deferred_work_source_,

                         kCFRunLoopCommonModes);

   CFRelease(nesting_deferred_work_source_);

   CFRunLoopRemoveSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);

   CFRelease(idle_work_source_);

   CFRunLoopRemoveSource(run_loop_, delayed_work_source_, kCFRunLoopCommonModes);

   CFRelease(delayed_work_source_);

   CFRunLoopRemoveSource(run_loop_, work_source_, kCFRunLoopCommonModes);

   CFRelease(work_source_);

   CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);

   CFRelease(delayed_work_timer_);

   CFRelease(run_loop_);

 }

 // Must be called on the run loop thread.

 void MessagePumpCFRunLoopBase::Run(Delegate* delegate) {

   // nesting_level_ will be incremented in EnterExitRunLoop, so set

   // run_nesting_level_ accordingly.

   int last_run_nesting_level = run_nesting_level_;

   run_nesting_level_ = nesting_level_ + 1;

   Delegate* last_delegate = delegate_;

   delegate_ = delegate;

   if (delegate) {

     // If any work showed up but could not be dispatched for want of a

     // delegate, set it up for dispatch again now that a delegate is

     // available.

     if (delegateless_work_) {

       CFRunLoopSourceSignal(work_source_);

       delegateless_work_ = false;

     }

     if (delegateless_delayed_work_) {

       CFRunLoopSourceSignal(delayed_work_source_);

       delegateless_delayed_work_ = false;

     }

     if (delegateless_idle_work_) {

       CFRunLoopSourceSignal(idle_work_source_);

       delegateless_idle_work_ = false;

     }

   }

   DoRun(delegate);

   // Restore the previous state of the object.

   delegate_ = last_delegate;

   run_nesting_level_ = last_run_nesting_level;

 }

 // May be called on any thread.

 void MessagePumpCFRunLoopBase::ScheduleWork() {

   CFRunLoopSourceSignal(work_source_);

   CFRunLoopWakeUp(run_loop_);

 }

 // Must be called on the run loop thread.

 void MessagePumpCFRunLoopBase::ScheduleDelayedWork(

     const TimeTicks& delayed_work_time) {

   TimeDelta delta = delayed_work_time - TimeTicks::Now();

   delayed_work_fire_time_ = CFAbsoluteTimeGetCurrent() + delta.InSecondsF();

   CFRunLoopTimerSetNextFireDate(delayed_work_timer_, delayed_work_fire_time_);

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::RunDelayedWorkTimer(CFRunLoopTimerRef timer,

                                                    void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   // The timer won't fire again until it's reset.

   self->delayed_work_fire_time_ = kCFTimeIntervalMax;

   // CFRunLoopTimers fire outside of the priority scheme for CFRunLoopSources.

   // In order to establish the proper priority where delegate_->DoDelayedWork

   // can only be called if delegate_->DoWork returns false, the timer used

   // to schedule delayed work must signal a CFRunLoopSource set at a lower

   // priority than the one used for delegate_->DoWork.

   CFRunLoopSourceSignal(self->delayed_work_source_);

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::RunWorkSource(void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   self->RunWork();

 }

 // Called by MessagePumpCFRunLoopBase::RunWorkSource.

 bool MessagePumpCFRunLoopBase::RunWork() {

   if (!delegate_) {

     // This point can be reached with a NULL delegate_ if Run is not on the

     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back

     // here when a delegate is available.

     delegateless_work_ = true;

     return false;

   }

   // The NSApplication-based run loop only drains the autorelease pool at each

   // UI event (NSEvent).  The autorelease pool is not drained for each

   // CFRunLoopSource target that's run.  Use a local pool for any autoreleased

   // objects if the app is not currently handling a UI event to ensure they're

   // released promptly even in the absence of UI events.

   MessagePumpScopedAutoreleasePool autorelease_pool(this);

   // Call DoWork once, and if something was done, arrange to come back here

   // again as long as the loop is still running.

   bool did_work = delegate_->DoWork();

   if (did_work) {

     CFRunLoopSourceSignal(work_source_);

   }

   return did_work;

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::RunDelayedWorkSource(void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   self->RunDelayedWork();

 }

 // Called by MessagePumpCFRunLoopBase::RunDelayedWorkSource.

 bool MessagePumpCFRunLoopBase::RunDelayedWork() {

   if (!delegate_) {

     // This point can be reached with a NULL delegate_ if Run is not on the

     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back

     // here when a delegate is available.

     delegateless_delayed_work_ = true;

     return false;

   }

   // The NSApplication-based run loop only drains the autorelease pool at each

   // UI event (NSEvent).  The autorelease pool is not drained for each

   // CFRunLoopSource target that's run.  Use a local pool for any autoreleased

   // objects if the app is not currently handling a UI event to ensure they're

   // released promptly even in the absence of UI events.

   MessagePumpScopedAutoreleasePool autorelease_pool(this);

   TimeTicks next_time;

   delegate_->DoDelayedWork(&next_time);

   bool more_work = !next_time.is_null();

   if (more_work) {

     TimeDelta delay = next_time - TimeTicks::Now();

     if (delay > TimeDelta()) {

       // There's more delayed work to be done in the future.

       ScheduleDelayedWork(next_time);

     } else {

       // There's more delayed work to be done, and its time is in the past.

       // Arrange to come back here directly as long as the loop is still

       // running.

       CFRunLoopSourceSignal(delayed_work_source_);

     }

   }

   return more_work;

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::RunIdleWorkSource(void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   self->RunIdleWork();

 }

 // Called by MessagePumpCFRunLoopBase::RunIdleWorkSource.

 bool MessagePumpCFRunLoopBase::RunIdleWork() {

   if (!delegate_) {

     // This point can be reached with a NULL delegate_ if Run is not on the

     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back

     // here when a delegate is available.

     delegateless_idle_work_ = true;

     return false;

   }

   // The NSApplication-based run loop only drains the autorelease pool at each

   // UI event (NSEvent).  The autorelease pool is not drained for each

   // CFRunLoopSource target that's run.  Use a local pool for any autoreleased

   // objects if the app is not currently handling a UI event to ensure they're

   // released promptly even in the absence of UI events.

   MessagePumpScopedAutoreleasePool autorelease_pool(this);

   // Call DoIdleWork once, and if something was done, arrange to come back here

   // again as long as the loop is still running.

   bool did_work = delegate_->DoIdleWork();

   if (did_work) {

     CFRunLoopSourceSignal(idle_work_source_);

   }

   return did_work;

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource(void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   self->RunNestingDeferredWork();

 }

 // Called by MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource.

 bool MessagePumpCFRunLoopBase::RunNestingDeferredWork() {

   if (!delegate_) {

     // This point can be reached with a NULL delegate_ if Run is not on the

     // stack but foreign code is spinning the CFRunLoop.  There's no sense in

     // attempting to do any work or signalling the work sources because

     // without a delegate, work is not possible.

     return false;

   }

   // Immediately try work in priority order.

   if (!RunWork()) {

     if (!RunDelayedWork()) {

       if (!RunIdleWork()) {

         return false;

       }

     } else {

       // There was no work, and delayed work was done.  Arrange for the loop

       // to try non-nestable idle work on a subsequent pass.

       CFRunLoopSourceSignal(idle_work_source_);

     }

   } else {

     // Work was done.  Arrange for the loop to try non-nestable delayed and

     // idle work on a subsequent pass.

     CFRunLoopSourceSignal(delayed_work_source_);

     CFRunLoopSourceSignal(idle_work_source_);

   }

   return true;

 }

 // Called before the run loop goes to sleep or exits, or processes sources.

 void MessagePumpCFRunLoopBase::MaybeScheduleNestingDeferredWork() {

   // deepest_nesting_level_ is set as run loops are entered.  If the deepest

   // level encountered is deeper than the current level, a nested loop

   // (relative to the current level) ran since the last time nesting-deferred

   // work was scheduled.  When that situation is encountered, schedule

   // nesting-deferred work in case any work was deferred because nested work

   // was disallowed.

   if (deepest_nesting_level_ > nesting_level_) {

     deepest_nesting_level_ = nesting_level_;

     CFRunLoopSourceSignal(nesting_deferred_work_source_);

   }

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::PreWaitObserver(CFRunLoopObserverRef observer,

                                                CFRunLoopActivity activity,

                                                void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   // Attempt to do some idle work before going to sleep.

   self->RunIdleWork();

   // The run loop is about to go to sleep.  If any of the work done since it

   // started or woke up resulted in a nested run loop running,

   // nesting-deferred work may have accumulated.  Schedule it for processing

   // if appropriate.

   self->MaybeScheduleNestingDeferredWork();

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::PreSourceObserver(CFRunLoopObserverRef observer,

                                                  CFRunLoopActivity activity,

                                                  void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   // The run loop has reached the top of the loop and is about to begin

   // processing sources.  If the last iteration of the loop at this nesting

   // level did not sleep or exit, nesting-deferred work may have accumulated

   // if a nested loop ran.  Schedule nesting-deferred work for processing if

   // appropriate.

   self->MaybeScheduleNestingDeferredWork();

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::EnterExitObserver(CFRunLoopObserverRef observer,

                                                  CFRunLoopActivity activity,

                                                  void* info) {

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   switch (activity) {

     case kCFRunLoopEntry:

       ++self->nesting_level_;

       if (self->nesting_level_ > self->deepest_nesting_level_) {

         self->deepest_nesting_level_ = self->nesting_level_;

       }

       break;

     case kCFRunLoopExit:

       // Not all run loops go to sleep.  If a run loop is stopped before it

       // goes to sleep due to a CFRunLoopStop call, or if the timeout passed

       // to CFRunLoopRunInMode expires, the run loop may proceed directly from

       // handling sources to exiting without any sleep.  This most commonly

       // occurs when CFRunLoopRunInMode is passed a timeout of 0, causing it

       // to make a single pass through the loop and exit without sleep.  Some

       // native loops use CFRunLoop in this way.  Because PreWaitObserver will

       // not be called in these case, MaybeScheduleNestingDeferredWork needs

       // to be called here, as the run loop exits.

       //

       // MaybeScheduleNestingDeferredWork consults self->nesting_level_

       // to determine whether to schedule nesting-deferred work.  It expects

       // the nesting level to be set to the depth of the loop that is going

       // to sleep or exiting.  It must be called before decrementing the

       // value so that the value still corresponds to the level of the exiting

       // loop.

       self->MaybeScheduleNestingDeferredWork();

       --self->nesting_level_;

       break;

     default:

       break;

   }

   self->EnterExitRunLoop(activity);

 }

 // Called from the run loop.

 // static

 void MessagePumpCFRunLoopBase::PowerStateNotification(void* info,

                                                       io_service_t service,

                                                       uint32_t message_type,

                                                       void* message_argument) {

   // CFRunLoopTimer (NSTimer) is scheduled in terms of CFAbsoluteTime, which

   // measures the number of seconds since 2001-01-01 00:00:00.0 Z.  It is

   // implemented in terms of kernel ticks, as in mach_absolute_time.  While an

   // offset and scale factor can be applied to convert between the two time

   // bases at any time after boot, the kernel clock stops while the system is

   // asleep, altering the offset.  (The offset will also change when the

   // real-time clock is adjusted.)  CFRunLoopTimers are not readjusted to take

   // this into account when the system wakes up, so any timers that were

   // pending while the system was asleep will be delayed by the sleep

   // duration.

   //

   // The MessagePump interface assumes that scheduled delayed work will be

   // performed at the time ScheduleDelayedWork was asked to perform it.  The

   // delay caused by the CFRunLoopTimer not firing at the appropriate time

   // results in a stall of queued delayed work when the system wakes up.

   // With this limitation, scheduled work would not be performed until

   // (system wake time + scheduled work time - system sleep time), while it

   // would be expected to be performed at (scheduled work time).

   //

   // To work around this problem, when the system wakes up from sleep, if a

   // delayed work timer is pending, it is rescheduled to fire at the original

   // time that it was scheduled to fire.

   //

   // This mechanism is not resilient if the real-time clock does not maintain

   // stable time while the system is sleeping, but it matches the behavior of

   // the various other MessagePump implementations, and MessageLoop seems to

   // be limited in the same way.

   //

   // References

   //  - Chris Kane, "NSTimer and deep sleep," cocoa-dev@lists.apple.com,

   //    http://lists.apple.com/archives/Cocoa-dev/2002/May/msg01547.html

   //  - Apple Technical Q&A QA1340, "Registering and unregistering for sleep

   //    and wake notifications,"

   //    http://developer.apple.com/mac/library/qa/qa2004/qa1340.html

   //  - Core Foundation source code, CF-550/CFRunLoop.c and CF-550/CFDate.c,

   //    http://www.opensource.apple.com/

   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);

   switch (message_type) {

     case kIOMessageSystemWillPowerOn:

       if (self->delayed_work_fire_time_ != kCFTimeIntervalMax) {

         CFRunLoopTimerSetNextFireDate(self->delayed_work_timer_,

                                       self->delayed_work_fire_time_);

       }

       break;

     case kIOMessageSystemWillSleep:

     case kIOMessageCanSystemSleep:

       // The system will wait for 30 seconds before entering sleep if neither

       // IOAllowPowerChange nor IOCancelPowerChange are called.  That would be

       // pretty antisocial.

       IOAllowPowerChange(self->root_power_domain_,

                          reinterpret_cast<long>(message_argument));

       break;

     default:

       break;

   }

 }

 // Called by MessagePumpCFRunLoopBase::EnterExitRunLoop.  The default

 // implementation is a no-op.

 void MessagePumpCFRunLoopBase::EnterExitRunLoop(CFRunLoopActivity activity) {

 }

 // Base version returns a standard NSAutoreleasePool.

 NSAutoreleasePool* MessagePumpCFRunLoopBase::CreateAutoreleasePool() {

   return [[NSAutoreleasePool alloc] init];

 }

 MessagePumpCFRunLoop::MessagePumpCFRunLoop()

     : quit_pending_(false) {

 }

 // Called by MessagePumpCFRunLoopBase::DoRun.  If other CFRunLoopRun loops were

 // running lower on the run loop thread's stack when this object was created,

 // the same number of CFRunLoopRun loops must be running for the outermost call

 // to Run.  Run/DoRun are reentrant after that point.

 void MessagePumpCFRunLoop::DoRun(Delegate* delegate) {

   // This is completely identical to calling CFRunLoopRun(), except autorelease

   // pool management is introduced.

   int result;

   do {

     MessagePumpScopedAutoreleasePool autorelease_pool(this);

     result = CFRunLoopRunInMode(kCFRunLoopDefaultMode,

                                 kCFTimeIntervalMax,

                                 false);

   } while (result != kCFRunLoopRunStopped && result != kCFRunLoopRunFinished);

 }

 // Must be called on the run loop thread.

 void MessagePumpCFRunLoop::Quit() {

   // Stop the innermost run loop managed by this MessagePumpCFRunLoop object.

   if (nesting_level() == run_nesting_level()) {

     // This object is running the innermost loop, just stop it.

     CFRunLoopStop(run_loop());

   } else {

     // There's another loop running inside the loop managed by this object.

     // In other words, someone else called CFRunLoopRunInMode on the same

     // thread, deeper on the stack than the deepest Run call.  Don't preempt

     // other run loops, just mark this object to quit the innermost Run as

     // soon as the other inner loops not managed by Run are done.

     quit_pending_ = true;

   }

 }

 // Called by MessagePumpCFRunLoopBase::EnterExitObserver.

 void MessagePumpCFRunLoop::EnterExitRunLoop(CFRunLoopActivity activity) {

   if (activity == kCFRunLoopExit &&

       nesting_level() == run_nesting_level() &&

       quit_pending_) {

     // Quit was called while loops other than those managed by this object

     // were running further inside a run loop managed by this object.  Now

     // that all unmanaged inner run loops are gone, stop the loop running

     // just inside Run.

     CFRunLoopStop(run_loop());

     quit_pending_ = false;

   }

 }

 MessagePumpNSRunLoop::MessagePumpNSRunLoop()

     : keep_running_(true) {

   CFRunLoopSourceContext source_context = CFRunLoopSourceContext();

   source_context.perform = NoOp;

   quit_source_ = CFRunLoopSourceCreate(NULL,  // allocator

                                        0,     // priority

                                        &source_context);

   CFRunLoopAddSource(run_loop(), quit_source_, kCFRunLoopCommonModes);

 }

 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {

   CFRunLoopRemoveSource(run_loop(), quit_source_, kCFRunLoopCommonModes);

   CFRelease(quit_source_);

 }

 void MessagePumpNSRunLoop::DoRun(Delegate* delegate) {

   while (keep_running_) {

     // NSRunLoop manages autorelease pools itself.

     [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode

                              beforeDate:[NSDate distantFuture]];

   }

   keep_running_ = true;

 }

 void MessagePumpNSRunLoop::Quit() {

   keep_running_ = false;

   CFRunLoopSourceSignal(quit_source_);

   CFRunLoopWakeUp(run_loop());

 }

 MessagePumpNSApplication::MessagePumpNSApplication()

     : keep_running_(true),

       running_own_loop_(false) {

 }

 void MessagePumpNSApplication::DoRun(Delegate* delegate) {

   bool last_running_own_loop_ = running_own_loop_;

   // TODO(dmaclach): Get rid of this gratuitous sharedApplication.

   // Tests should be setting up their applications on their own.

   [CrApplication sharedApplication];

   if (![NSApp isRunning]) {

     running_own_loop_ = false;

     // NSApplication manages autorelease pools itself when run this way.

     [NSApp run];

   } else {

     running_own_loop_ = true;

     NSDate* distant_future = [NSDate distantFuture];

     while (keep_running_) {

       MessagePumpScopedAutoreleasePool autorelease_pool(this);

       NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask

                                           untilDate:distant_future

                                              inMode:NSDefaultRunLoopMode

                                             dequeue:YES];

       if (event) {

         [NSApp sendEvent:event];

       }

     }

     keep_running_ = true;

   }

   running_own_loop_ = last_running_own_loop_;

 }

 void MessagePumpNSApplication::Quit() {

   if (!running_own_loop_) {

     [NSApp stop:nil];

   } else {

     keep_running_ = false;

   }

   // Send a fake event to wake the loop up.

   [NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined

                                       location:NSMakePoint(0, 0)

                                  modifierFlags:0

                                      timestamp:0

                                   windowNumber:0

                                        context:NULL

                                        subtype:0

                                          data1:0

                                          data2:0]

            atStart:NO];

 }

 // Prevents an autorelease pool from being created if the app is in the midst of

 // handling a UI event because various parts of AppKit depend on objects that

 // are created while handling a UI event to be autoreleased in the event loop.

 // An example of this is NSWindowController. When a window with a window

 // controller is closed it goes through a stack like this:

 // (Several stack frames elided for clarity)

 //

 // #0 [NSWindowController autorelease]

 // #1 DoAClose

 // #2 MessagePumpCFRunLoopBase::DoWork()

 // #3 [NSRunLoop run]

 // #4 [NSButton performClick:]

 // #5 [NSWindow sendEvent:]

 // #6 [NSApp sendEvent:]

 // #7 [NSApp run]

 //

 // -performClick: spins a nested run loop. If the pool created in DoWork was a

 // standard NSAutoreleasePool, it would release the objects that were

 // autoreleased into it once DoWork released it. This would cause the window

 // controller, which autoreleased itself in frame #0, to release itself, and

 // possibly free itself. Unfortunately this window controller controls the

 // window in frame #5. When the stack is unwound to frame #5, the window would

 // no longer exists and crashes may occur. Apple gets around this by never

 // releasing the pool it creates in frame #4, and letting frame #7 clean it up

 // when it cleans up the pool that wraps frame #7. When an autorelease pool is

 // released it releases all other pools that were created after it on the

 // autorelease pool stack.

 //

 // CrApplication is responsible for setting handlingSendEvent to true just

 // before it sends the event throught the event handling mechanism, and

 // returning it to its previous value once the event has been sent.

 NSAutoreleasePool* MessagePumpNSApplication::CreateAutoreleasePool() {

   NSAutoreleasePool* pool = nil;

   DCHECK([NSApp isKindOfClass:[CrApplication class]]);

   if (![static_cast<CrApplication*>(NSApp) isHandlingSendEvent]) {

     pool = MessagePumpCFRunLoopBase::CreateAutoreleasePool();

   }

   return pool;

 }

 // static

 MessagePump* MessagePumpMac::Create() {

   if ([NSThread isMainThread]) {

     return new MessagePumpNSApplication;

   }

   return new MessagePumpNSRunLoop;

 }

 }  // namespace base