base/message_pump_mac.mm

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #import "base/message_pump_mac.h"
   6
   7 #import <Foundation/Foundation.h>
   8
   9 #include <limits>
  10
  11 #include "base/logging.h"
  12 #include "base/run_loop.h"
  13 #include "base/time.h"
  14
  15 #if !defined(OS_IOS)
  16 #import <AppKit/AppKit.h>
  17 #endif  // !defined(OS_IOS)
  18
  19 namespace {
  20
  21 void NoOp(void* info) {
  22 }
  23
  24 const CFTimeInterval kCFTimeIntervalMax =
  25     std::numeric_limits<CFTimeInterval>::max();
  26
  27 // Set to true if MessagePumpMac::Create() is called before NSApp is
  28 // initialized.  Only accessed from the main thread.
  29 bool not_using_crapp = false;
  30
  31 }  // namespace
  32
  33 namespace base {
  34
  35 // A scoper for autorelease pools created from message pump run loops.
  36 // Avoids dirtying up the ScopedNSAutoreleasePool interface for the rare
  37 // case where an autorelease pool needs to be passed in.
  38 class MessagePumpScopedAutoreleasePool {
  39  public:
  40   explicit MessagePumpScopedAutoreleasePool(MessagePumpCFRunLoopBase* pump) :
  41       pool_(pump->CreateAutoreleasePool()) {
  42   }
  43    ~MessagePumpScopedAutoreleasePool() {
  44     [pool_ drain];
  45   }
  46
  47  private:
  48   NSAutoreleasePool* pool_;
  49   DISALLOW_COPY_AND_ASSIGN(MessagePumpScopedAutoreleasePool);
  50 };
  51
  52 // Must be called on the run loop thread.
  53 MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase()
  54     : delegate_(NULL),
  55       delayed_work_fire_time_(kCFTimeIntervalMax),
  56       nesting_level_(0),
  57       run_nesting_level_(0),
  58       deepest_nesting_level_(0),
  59       delegateless_work_(false),
  60       delegateless_idle_work_(false) {
  61   run_loop_ = CFRunLoopGetCurrent();
  62   CFRetain(run_loop_);
  63
  64   // Set a repeating timer with a preposterous firing time and interval.  The
  65   // timer will effectively never fire as-is.  The firing time will be adjusted
  66   // as needed when ScheduleDelayedWork is called.
  67   CFRunLoopTimerContext timer_context = CFRunLoopTimerContext();
  68   timer_context.info = this;
  69   delayed_work_timer_ = CFRunLoopTimerCreate(NULL,                // allocator
  70                                              kCFTimeIntervalMax,  // fire time
  71                                              kCFTimeIntervalMax,  // interval
  72                                              0,                   // flags
  73                                              0,                   // priority
  74                                              RunDelayedWorkTimer,
  75                                              &timer_context);
  76   CFRunLoopAddTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
  77
  78   CFRunLoopSourceContext source_context = CFRunLoopSourceContext();
  79   source_context.info = this;
  80   source_context.perform = RunWorkSource;
  81   work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
  82                                        1,     // priority
  83                                        &source_context);
  84   CFRunLoopAddSource(run_loop_, work_source_, kCFRunLoopCommonModes);
  85
  86   source_context.perform = RunIdleWorkSource;
  87   idle_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
  88                                             2,     // priority
  89                                             &source_context);
  90   CFRunLoopAddSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
  91
  92   source_context.perform = RunNestingDeferredWorkSource;
  93   nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
  94                                                         0,     // priority
  95                                                         &source_context);
  96   CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,
  97                      kCFRunLoopCommonModes);
  98
  99   CFRunLoopObserverContext observer_context = CFRunLoopObserverContext();
 100   observer_context.info = this;
 101   pre_wait_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
 102                                                kCFRunLoopBeforeWaiting,
 103                                                true,  // repeat
 104                                                0,     // priority
 105                                                PreWaitObserver,
 106                                                &observer_context);
 107   CFRunLoopAddObserver(run_loop_, pre_wait_observer_, kCFRunLoopCommonModes);
 108
 109   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
 110                                                  kCFRunLoopBeforeSources,
 111                                                  true,  // repeat
 112                                                  0,     // priority
 113                                                  PreSourceObserver,
 114                                                  &observer_context);
 115   CFRunLoopAddObserver(run_loop_, pre_source_observer_, kCFRunLoopCommonModes);
 116
 117   enter_exit_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
 118                                                  kCFRunLoopEntry |
 119                                                      kCFRunLoopExit,
 120                                                  true,  // repeat
 121                                                  0,     // priority
 122                                                  EnterExitObserver,
 123                                                  &observer_context);
 124   CFRunLoopAddObserver(run_loop_, enter_exit_observer_, kCFRunLoopCommonModes);
 125 }
 126
 127 // Ideally called on the run loop thread.  If other run loops were running
 128 // lower on the run loop thread's stack when this object was created, the
 129 // same number of run loops must be running when this object is destroyed.
 130 MessagePumpCFRunLoopBase::~MessagePumpCFRunLoopBase() {
 131   CFRunLoopRemoveObserver(run_loop_, enter_exit_observer_,
 132                           kCFRunLoopCommonModes);
 133   CFRelease(enter_exit_observer_);
 134
 135   CFRunLoopRemoveObserver(run_loop_, pre_source_observer_,
 136                           kCFRunLoopCommonModes);
 137   CFRelease(pre_source_observer_);
 138
 139   CFRunLoopRemoveObserver(run_loop_, pre_wait_observer_,
 140                           kCFRunLoopCommonModes);
 141   CFRelease(pre_wait_observer_);
 142
 143   CFRunLoopRemoveSource(run_loop_, nesting_deferred_work_source_,
 144                         kCFRunLoopCommonModes);
 145   CFRelease(nesting_deferred_work_source_);
 146
 147   CFRunLoopRemoveSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
 148   CFRelease(idle_work_source_);
 149
 150   CFRunLoopRemoveSource(run_loop_, work_source_, kCFRunLoopCommonModes);
 151   CFRelease(work_source_);
 152
 153   CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
 154   CFRelease(delayed_work_timer_);
 155
 156   CFRelease(run_loop_);
 157 }
 158
 159 // Must be called on the run loop thread.
 160 void MessagePumpCFRunLoopBase::Run(Delegate* delegate) {
 161   // nesting_level_ will be incremented in EnterExitRunLoop, so set
 162   // run_nesting_level_ accordingly.
 163   int last_run_nesting_level = run_nesting_level_;
 164   run_nesting_level_ = nesting_level_ + 1;
 165
 166   Delegate* last_delegate = delegate_;
 167   SetDelegate(delegate);
 168
 169   DoRun(delegate);
 170
 171   // Restore the previous state of the object.
 172   SetDelegate(last_delegate);
 173   run_nesting_level_ = last_run_nesting_level;
 174 }
 175
 176 void MessagePumpCFRunLoopBase::SetDelegate(Delegate* delegate) {
 177   delegate_ = delegate;
 178
 179   if (delegate) {
 180     // If any work showed up but could not be dispatched for want of a
 181     // delegate, set it up for dispatch again now that a delegate is
 182     // available.
 183     if (delegateless_work_) {
 184       CFRunLoopSourceSignal(work_source_);
 185       delegateless_work_ = false;
 186     }
 187     if (delegateless_idle_work_) {
 188       CFRunLoopSourceSignal(idle_work_source_);
 189       delegateless_idle_work_ = false;
 190     }
 191   }
 192 }
 193
 194 // May be called on any thread.
 195 void MessagePumpCFRunLoopBase::ScheduleWork() {
 196   CFRunLoopSourceSignal(work_source_);
 197   CFRunLoopWakeUp(run_loop_);
 198 }
 199
 200 // Must be called on the run loop thread.
 201 void MessagePumpCFRunLoopBase::ScheduleDelayedWork(
 202     const TimeTicks& delayed_work_time) {
 203   TimeDelta delta = delayed_work_time - TimeTicks::Now();
 204   delayed_work_fire_time_ = CFAbsoluteTimeGetCurrent() + delta.InSecondsF();
 205   CFRunLoopTimerSetNextFireDate(delayed_work_timer_, delayed_work_fire_time_);
 206 }
 207
 208 // Called from the run loop.
 209 // static
 210 void MessagePumpCFRunLoopBase::RunDelayedWorkTimer(CFRunLoopTimerRef timer,
 211                                                    void* info) {
 212   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 213
 214   // The timer won't fire again until it's reset.
 215   self->delayed_work_fire_time_ = kCFTimeIntervalMax;
 216
 217   // CFRunLoopTimers fire outside of the priority scheme for CFRunLoopSources.
 218   // In order to establish the proper priority in which work and delayed work
 219   // are processed one for one, the timer used to schedule delayed work must
 220   // signal a CFRunLoopSource used to dispatch both work and delayed work.
 221   CFRunLoopSourceSignal(self->work_source_);
 222 }
 223
 224 // Called from the run loop.
 225 // static
 226 void MessagePumpCFRunLoopBase::RunWorkSource(void* info) {
 227   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 228   self->RunWork();
 229 }
 230
 231 // Called by MessagePumpCFRunLoopBase::RunWorkSource.
 232 bool MessagePumpCFRunLoopBase::RunWork() {
 233   if (!delegate_) {
 234     // This point can be reached with a NULL delegate_ if Run is not on the
 235     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back
 236     // here when a delegate is available.
 237     delegateless_work_ = true;
 238     return false;
 239   }
 240
 241   // The NSApplication-based run loop only drains the autorelease pool at each
 242   // UI event (NSEvent).  The autorelease pool is not drained for each
 243   // CFRunLoopSource target that's run.  Use a local pool for any autoreleased
 244   // objects if the app is not currently handling a UI event to ensure they're
 245   // released promptly even in the absence of UI events.
 246   MessagePumpScopedAutoreleasePool autorelease_pool(this);
 247
 248   // Call DoWork and DoDelayedWork once, and if something was done, arrange to
 249   // come back here again as long as the loop is still running.
 250   bool did_work = delegate_->DoWork();
 251   bool resignal_work_source = did_work;
 252
 253   TimeTicks next_time;
 254   delegate_->DoDelayedWork(&next_time);
 255   if (!did_work) {
 256     // Determine whether there's more delayed work, and if so, if it needs to
 257     // be done at some point in the future or if it's already time to do it.
 258     // Only do these checks if did_work is false. If did_work is true, this
 259     // function, and therefore any additional delayed work, will get another
 260     // chance to run before the loop goes to sleep.
 261     bool more_delayed_work = !next_time.is_null();
 262     if (more_delayed_work) {
 263       TimeDelta delay = next_time - TimeTicks::Now();
 264       if (delay > TimeDelta()) {
 265         // There's more delayed work to be done in the future.
 266         ScheduleDelayedWork(next_time);
 267       } else {
 268         // There's more delayed work to be done, and its time is in the past.
 269         // Arrange to come back here directly as long as the loop is still
 270         // running.
 271         resignal_work_source = true;
 272       }
 273     }
 274   }
 275
 276   if (resignal_work_source) {
 277     CFRunLoopSourceSignal(work_source_);
 278   }
 279
 280   return resignal_work_source;
 281 }
 282
 283 // Called from the run loop.
 284 // static
 285 void MessagePumpCFRunLoopBase::RunIdleWorkSource(void* info) {
 286   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 287   self->RunIdleWork();
 288 }
 289
 290 // Called by MessagePumpCFRunLoopBase::RunIdleWorkSource.
 291 bool MessagePumpCFRunLoopBase::RunIdleWork() {
 292   if (!delegate_) {
 293     // This point can be reached with a NULL delegate_ if Run is not on the
 294     // stack but foreign code is spinning the CFRunLoop.  Arrange to come back
 295     // here when a delegate is available.
 296     delegateless_idle_work_ = true;
 297     return false;
 298   }
 299
 300   // The NSApplication-based run loop only drains the autorelease pool at each
 301   // UI event (NSEvent).  The autorelease pool is not drained for each
 302   // CFRunLoopSource target that's run.  Use a local pool for any autoreleased
 303   // objects if the app is not currently handling a UI event to ensure they're
 304   // released promptly even in the absence of UI events.
 305   MessagePumpScopedAutoreleasePool autorelease_pool(this);
 306
 307   // Call DoIdleWork once, and if something was done, arrange to come back here
 308   // again as long as the loop is still running.
 309   bool did_work = delegate_->DoIdleWork();
 310   if (did_work) {
 311     CFRunLoopSourceSignal(idle_work_source_);
 312   }
 313
 314   return did_work;
 315 }
 316
 317 // Called from the run loop.
 318 // static
 319 void MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource(void* info) {
 320   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 321   self->RunNestingDeferredWork();
 322 }
 323
 324 // Called by MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource.
 325 bool MessagePumpCFRunLoopBase::RunNestingDeferredWork() {
 326   if (!delegate_) {
 327     // This point can be reached with a NULL delegate_ if Run is not on the
 328     // stack but foreign code is spinning the CFRunLoop.  There's no sense in
 329     // attempting to do any work or signalling the work sources because
 330     // without a delegate, work is not possible.
 331     return false;
 332   }
 333
 334   // Immediately try work in priority order.
 335   if (!RunWork()) {
 336     if (!RunIdleWork()) {
 337       return false;
 338     }
 339   } else {
 340     // Work was done.  Arrange for the loop to try non-nestable idle work on
 341     // a subsequent pass.
 342     CFRunLoopSourceSignal(idle_work_source_);
 343   }
 344
 345   return true;
 346 }
 347
 348 // Called before the run loop goes to sleep or exits, or processes sources.
 349 void MessagePumpCFRunLoopBase::MaybeScheduleNestingDeferredWork() {
 350   // deepest_nesting_level_ is set as run loops are entered.  If the deepest
 351   // level encountered is deeper than the current level, a nested loop
 352   // (relative to the current level) ran since the last time nesting-deferred
 353   // work was scheduled.  When that situation is encountered, schedule
 354   // nesting-deferred work in case any work was deferred because nested work
 355   // was disallowed.
 356   if (deepest_nesting_level_ > nesting_level_) {
 357     deepest_nesting_level_ = nesting_level_;
 358     CFRunLoopSourceSignal(nesting_deferred_work_source_);
 359   }
 360 }
 361
 362 // Called from the run loop.
 363 // static
 364 void MessagePumpCFRunLoopBase::PreWaitObserver(CFRunLoopObserverRef observer,
 365                                                CFRunLoopActivity activity,
 366                                                void* info) {
 367   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 368
 369   // Attempt to do some idle work before going to sleep.
 370   self->RunIdleWork();
 371
 372   // The run loop is about to go to sleep.  If any of the work done since it
 373   // started or woke up resulted in a nested run loop running,
 374   // nesting-deferred work may have accumulated.  Schedule it for processing
 375   // if appropriate.
 376   self->MaybeScheduleNestingDeferredWork();
 377 }
 378
 379 // Called from the run loop.
 380 // static
 381 void MessagePumpCFRunLoopBase::PreSourceObserver(CFRunLoopObserverRef observer,
 382                                                  CFRunLoopActivity activity,
 383                                                  void* info) {
 384   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 385
 386   // The run loop has reached the top of the loop and is about to begin
 387   // processing sources.  If the last iteration of the loop at this nesting
 388   // level did not sleep or exit, nesting-deferred work may have accumulated
 389   // if a nested loop ran.  Schedule nesting-deferred work for processing if
 390   // appropriate.
 391   self->MaybeScheduleNestingDeferredWork();
 392 }
 393
 394 // Called from the run loop.
 395 // static
 396 void MessagePumpCFRunLoopBase::EnterExitObserver(CFRunLoopObserverRef observer,
 397                                                  CFRunLoopActivity activity,
 398                                                  void* info) {
 399   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 400
 401   switch (activity) {
 402     case kCFRunLoopEntry:
 403       ++self->nesting_level_;
 404       if (self->nesting_level_ > self->deepest_nesting_level_) {
 405         self->deepest_nesting_level_ = self->nesting_level_;
 406       }
 407       break;
 408
 409     case kCFRunLoopExit:
 410       // Not all run loops go to sleep.  If a run loop is stopped before it
 411       // goes to sleep due to a CFRunLoopStop call, or if the timeout passed
 412       // to CFRunLoopRunInMode expires, the run loop may proceed directly from
 413       // handling sources to exiting without any sleep.  This most commonly
 414       // occurs when CFRunLoopRunInMode is passed a timeout of 0, causing it
 415       // to make a single pass through the loop and exit without sleep.  Some
 416       // native loops use CFRunLoop in this way.  Because PreWaitObserver will
 417       // not be called in these case, MaybeScheduleNestingDeferredWork needs
 418       // to be called here, as the run loop exits.
 419       //
 420       // MaybeScheduleNestingDeferredWork consults self->nesting_level_
 421       // to determine whether to schedule nesting-deferred work.  It expects
 422       // the nesting level to be set to the depth of the loop that is going
 423       // to sleep or exiting.  It must be called before decrementing the
 424       // value so that the value still corresponds to the level of the exiting
 425       // loop.
 426       self->MaybeScheduleNestingDeferredWork();
 427       --self->nesting_level_;
 428       break;
 429
 430     default:
 431       break;
 432   }
 433
 434   self->EnterExitRunLoop(activity);
 435 }
 436
 437 // Called by MessagePumpCFRunLoopBase::EnterExitRunLoop.  The default
 438 // implementation is a no-op.
 439 void MessagePumpCFRunLoopBase::EnterExitRunLoop(CFRunLoopActivity activity) {
 440 }
 441
 442 // Base version returns a standard NSAutoreleasePool.
 443 NSAutoreleasePool* MessagePumpCFRunLoopBase::CreateAutoreleasePool() {
 444   return [[NSAutoreleasePool alloc] init];
 445 }
 446
 447 MessagePumpCFRunLoop::MessagePumpCFRunLoop()
 448     : quit_pending_(false) {
 449 }
 450
 451 MessagePumpCFRunLoop::~MessagePumpCFRunLoop() {}
 452
 453 // Called by MessagePumpCFRunLoopBase::DoRun.  If other CFRunLoopRun loops were
 454 // running lower on the run loop thread's stack when this object was created,
 455 // the same number of CFRunLoopRun loops must be running for the outermost call
 456 // to Run.  Run/DoRun are reentrant after that point.
 457 void MessagePumpCFRunLoop::DoRun(Delegate* delegate) {
 458   // This is completely identical to calling CFRunLoopRun(), except autorelease
 459   // pool management is introduced.
 460   int result;
 461   do {
 462     MessagePumpScopedAutoreleasePool autorelease_pool(this);
 463     result = CFRunLoopRunInMode(kCFRunLoopDefaultMode,
 464                                 kCFTimeIntervalMax,
 465                                 false);
 466   } while (result != kCFRunLoopRunStopped && result != kCFRunLoopRunFinished);
 467 }
 468
 469 // Must be called on the run loop thread.
 470 void MessagePumpCFRunLoop::Quit() {
 471   // Stop the innermost run loop managed by this MessagePumpCFRunLoop object.
 472   if (nesting_level() == run_nesting_level()) {
 473     // This object is running the innermost loop, just stop it.
 474     CFRunLoopStop(run_loop());
 475   } else {
 476     // There's another loop running inside the loop managed by this object.
 477     // In other words, someone else called CFRunLoopRunInMode on the same
 478     // thread, deeper on the stack than the deepest Run call.  Don't preempt
 479     // other run loops, just mark this object to quit the innermost Run as
 480     // soon as the other inner loops not managed by Run are done.
 481     quit_pending_ = true;
 482   }
 483 }
 484
 485 // Called by MessagePumpCFRunLoopBase::EnterExitObserver.
 486 void MessagePumpCFRunLoop::EnterExitRunLoop(CFRunLoopActivity activity) {
 487   if (activity == kCFRunLoopExit &&
 488       nesting_level() == run_nesting_level() &&
 489       quit_pending_) {
 490     // Quit was called while loops other than those managed by this object
 491     // were running further inside a run loop managed by this object.  Now
 492     // that all unmanaged inner run loops are gone, stop the loop running
 493     // just inside Run.
 494     CFRunLoopStop(run_loop());
 495     quit_pending_ = false;
 496   }
 497 }
 498
 499 MessagePumpNSRunLoop::MessagePumpNSRunLoop()
 500     : keep_running_(true) {
 501   CFRunLoopSourceContext source_context = CFRunLoopSourceContext();
 502   source_context.perform = NoOp;
 503   quit_source_ = CFRunLoopSourceCreate(NULL,  // allocator
 504                                        0,     // priority
 505                                        &source_context);
 506   CFRunLoopAddSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
 507 }
 508
 509 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
 510   CFRunLoopRemoveSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
 511   CFRelease(quit_source_);
 512 }
 513
 514 void MessagePumpNSRunLoop::DoRun(Delegate* delegate) {
 515   while (keep_running_) {
 516     // NSRunLoop manages autorelease pools itself.
 517     [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
 518                              beforeDate:[NSDate distantFuture]];
 519   }
 520
 521   keep_running_ = true;
 522 }
 523
 524 void MessagePumpNSRunLoop::Quit() {
 525   keep_running_ = false;
 526   CFRunLoopSourceSignal(quit_source_);
 527   CFRunLoopWakeUp(run_loop());
 528 }
 529
 530 #if defined(OS_IOS)
 531 MessagePumpUIApplication::MessagePumpUIApplication()
 532     : run_loop_(NULL) {
 533 }
 534
 535 MessagePumpUIApplication::~MessagePumpUIApplication() {}
 536
 537 void MessagePumpUIApplication::DoRun(Delegate* delegate) {
 538   NOTREACHED();
 539 }
 540
 541 void MessagePumpUIApplication::Quit() {
 542   NOTREACHED();
 543 }
 544
 545 void MessagePumpUIApplication::Attach(Delegate* delegate) {
 546   DCHECK(!run_loop_);
 547   run_loop_ = new base::RunLoop();
 548   CHECK(run_loop_->BeforeRun());
 549   SetDelegate(delegate);
 550 }
 551
 552 #else
 553
 554 MessagePumpNSApplication::MessagePumpNSApplication()
 555     : keep_running_(true),
 556       running_own_loop_(false) {
 557 }
 558
 559 MessagePumpNSApplication::~MessagePumpNSApplication() {}
 560
 561 void MessagePumpNSApplication::DoRun(Delegate* delegate) {
 562   bool last_running_own_loop_ = running_own_loop_;
 563
 564   // NSApp must be initialized by calling:
 565   // [{some class which implements CrAppProtocol} sharedApplication]
 566   // Most likely candidates are CrApplication or BrowserCrApplication.
 567   // These can be initialized from C++ code by calling
 568   // RegisterCrApp() or RegisterBrowserCrApp().
 569   CHECK(NSApp);
 570
 571   if (![NSApp isRunning]) {
 572     running_own_loop_ = false;
 573     // NSApplication manages autorelease pools itself when run this way.
 574     [NSApp run];
 575   } else {
 576     running_own_loop_ = true;
 577     NSDate* distant_future = [NSDate distantFuture];
 578     while (keep_running_) {
 579       MessagePumpScopedAutoreleasePool autorelease_pool(this);
 580       NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
 581                                           untilDate:distant_future
 582                                              inMode:NSDefaultRunLoopMode
 583                                             dequeue:YES];
 584       if (event) {
 585         [NSApp sendEvent:event];
 586       }
 587     }
 588     keep_running_ = true;
 589   }
 590
 591   running_own_loop_ = last_running_own_loop_;
 592 }
 593
 594 void MessagePumpNSApplication::Quit() {
 595   if (!running_own_loop_) {
 596     [[NSApplication sharedApplication] stop:nil];
 597   } else {
 598     keep_running_ = false;
 599   }
 600
 601   // Send a fake event to wake the loop up.
 602   [NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined
 603                                       location:NSMakePoint(0, 0)
 604                                  modifierFlags:0
 605                                      timestamp:0
 606                                   windowNumber:0
 607                                        context:NULL
 608                                        subtype:0
 609                                          data1:0
 610                                          data2:0]
 611            atStart:NO];
 612 }
 613
 614 MessagePumpCrApplication::MessagePumpCrApplication() {
 615 }
 616
 617 // Prevents an autorelease pool from being created if the app is in the midst of
 618 // handling a UI event because various parts of AppKit depend on objects that
 619 // are created while handling a UI event to be autoreleased in the event loop.
 620 // An example of this is NSWindowController. When a window with a window
 621 // controller is closed it goes through a stack like this:
 622 // (Several stack frames elided for clarity)
 623 //
 624 // #0 [NSWindowController autorelease]
 625 // #1 DoAClose
 626 // #2 MessagePumpCFRunLoopBase::DoWork()
 627 // #3 [NSRunLoop run]
 628 // #4 [NSButton performClick:]
 629 // #5 [NSWindow sendEvent:]
 630 // #6 [NSApp sendEvent:]
 631 // #7 [NSApp run]
 632 //
 633 // -performClick: spins a nested run loop. If the pool created in DoWork was a
 634 // standard NSAutoreleasePool, it would release the objects that were
 635 // autoreleased into it once DoWork released it. This would cause the window
 636 // controller, which autoreleased itself in frame #0, to release itself, and
 637 // possibly free itself. Unfortunately this window controller controls the
 638 // window in frame #5. When the stack is unwound to frame #5, the window would
 639 // no longer exists and crashes may occur. Apple gets around this by never
 640 // releasing the pool it creates in frame #4, and letting frame #7 clean it up
 641 // when it cleans up the pool that wraps frame #7. When an autorelease pool is
 642 // released it releases all other pools that were created after it on the
 643 // autorelease pool stack.
 644 //
 645 // CrApplication is responsible for setting handlingSendEvent to true just
 646 // before it sends the event through the event handling mechanism, and
 647 // returning it to its previous value once the event has been sent.
 648 NSAutoreleasePool* MessagePumpCrApplication::CreateAutoreleasePool() {
 649   if (MessagePumpMac::IsHandlingSendEvent())
 650     return nil;
 651   return MessagePumpNSApplication::CreateAutoreleasePool();
 652 }
 653
 654 // static
 655 bool MessagePumpMac::UsingCrApp() {
 656   DCHECK([NSThread isMainThread]);
 657
 658   // If NSApp is still not initialized, then the subclass used cannot
 659   // be determined.
 660   DCHECK(NSApp);
 661
 662   // The pump was created using MessagePumpNSApplication.
 663   if (not_using_crapp)
 664     return false;
 665
 666   return [NSApp conformsToProtocol:@protocol(CrAppProtocol)];
 667 }
 668
 669 // static
 670 bool MessagePumpMac::IsHandlingSendEvent() {
 671   DCHECK([NSApp conformsToProtocol:@protocol(CrAppProtocol)]);
 672   NSObject<CrAppProtocol>* app = static_cast<NSObject<CrAppProtocol>*>(NSApp);
 673   return [app isHandlingSendEvent];
 674 }
 675 #endif  // !defined(OS_IOS)
 676
 677 // static
 678 MessagePump* MessagePumpMac::Create() {
 679   if ([NSThread isMainThread]) {
 680 #if defined(OS_IOS)
 681     return new MessagePumpUIApplication;
 682 #else
 683     if ([NSApp conformsToProtocol:@protocol(CrAppProtocol)])
 684       return new MessagePumpCrApplication;
 685
 686     // The main-thread MessagePump implementations REQUIRE an NSApp.
 687     // Executables which have specific requirements for their
 688     // NSApplication subclass should initialize appropriately before
 689     // creating an event loop.
 690     [NSApplication sharedApplication];
 691     not_using_crapp = true;
 692     return new MessagePumpNSApplication;
 693 #endif
 694   }
 695
 696   return new MessagePumpNSRunLoop;
 697 }
 698
 699 }  // namespace base