Change the strategy used to attempt nesting-deferred work to account equally...

base/message_pump_mac.mm

 // 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 <float.h>
 
 #include "base/scoped_nsautorelease_pool.h"
 #include "base/time.h"
 
 namespace {
 
 void NoOp(void* info) {
 }
 
 }  // namespace
 
 namespace base {
 
 // Must be called on the run loop thread.
 MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase()
-    : nesting_level_(0),
+    : delegate_(NULL),
+      nesting_level_(0),
       run_nesting_level_(0),
-      delegate_(NULL),
+      deepest_nesting_level_(0),
       delegateless_work_(false),
       delegateless_delayed_work_(false),
-      delegateless_idle_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
                                              DBL_MAX,  // fire time
@@ skipping 85 matching lines @@
 // 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 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;
+  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);
 
-  // If this was an inner Run invocation, arrange to run nesting-deferred work
-  // when the stack has unwound to an outer invocation.
-  if (nesting_level_)
-    CFRunLoopSourceSignal(nesting_deferred_work_source_);
-
   // 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_);
 }
@@ skipping 44 matching lines @@
 // 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;
   }
 
-  // If we're on the main event loop, the NSApp runloop won't clean up the
-  // autorelease pool until there is a UI event, so use a local one for any
-  // autoreleased objects to ensure they go away sooner.
+  // 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 to ensure they're released promptly even in the absence of UI
+  // events.
   ScopedNSAutoreleasePool autorelease_pool;
 
   // 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;
   }
 
-  // If we're on the main event loop, the NSApp runloop won't clean up the
-  // autorelease pool until there is a UI event, so use a local one for any
-  // autoreleased objects to ensure they go away sooner.
+  // 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 to ensure they're released promptly even in the absence of UI
+  // events.
   ScopedNSAutoreleasePool autorelease_pool;
 
   Time next_time;
   delegate_->DoDelayedWork(&next_time);
 
   bool more_work = !next_time.is_null();
   if (more_work) {
     TimeDelta delay = next_time - Time::Now();
     if (delay > TimeDelta()) {
       // There's more delayed work to be done in the future.
@@ skipping 19 matching lines @@
 // 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;
   }
 
-  // If we're on the main event loop, the NSApp runloop won't clean up the
-  // autorelease pool until there is a UI event, so use a local one for any
-  // autoreleased objects to ensure they go away sooner.
+  // 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 to ensure they're released promptly even in the absence of UI
+  // events.
   ScopedNSAutoreleasePool autorelease_pool;
 
   // 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;
@@ skipping 30 matching lines @@
   } 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.
+void MessagePumpCFRunLoopBase::MaybeScheduleNestingDeferredWork() {
+  // deepest_nesting_level_ is set as run loops are entered.  If the deepest
+  // level encountered is deeper than the current level (about to sleep or
+  // exit), 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::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:
-      // After decrementing self->nesting_level_, it will be one less than
-      // self->run_nesting_level_ if the loop that is now exiting was directly
-      // started by a DoRun call.
+      // 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_;
-
-      if (self->nesting_level_ >= self->run_nesting_level_ &&
-          self->nesting_level_) {
-        // It's possible that some work was not performed because it was
-        // inappropriate to do within a nested loop.  When leaving any inner
-        // loop not directly supervised by a DoRun call, such as nested native
-        // loops, signal the nesting-deferred work source to ensure that such
-        // work be afforded an opportunity to be processed if appropriate.
-        // This is not done for loops being run directly by Run/DoRun because
-        // it can be done directly as Run exits.
-        CFRunLoopSourceSignal(self->nesting_deferred_work_source_);
-      }
       break;
     default:
       break;
   }
 
   self->EnterExitRunLoop(activity);
 }
 
 // Called by MessagePumpCFRunLoopBase::EnterExitRunLoop.  The default
 // implementation is a no-op.
@@ skipping 14 matching lines @@
   int result;
   do {
     ScopedNSAutoreleasePool autorelease_pool;
     result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, DBL_MAX, 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_) {
+  if (nesting_level() == run_nesting_level()) {
     // This object is running the innermost loop, just stop it.
-    CFRunLoopStop(run_loop_);
+    CFRunLoopStop(run_loop());
   } else {
     // There's another loop running inside the loop managed by this object.
-    // In other words, someone else called CFRunLoopRun on the same thread,
-    // higher on the stack than our highest Run call.  Don't preempt other
-    // run loops, just mark the object to quit our innermost run loop as soon
-    // as the other inner loops we don't manage are done.
+    // 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_ &&
+      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_);
+    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);
+  CFRunLoopAddSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
 }
 
 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
-  CFRunLoopRemoveSource(run_loop_, quit_source_, kCFRunLoopCommonModes);
+  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_);
+  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_;
 
@@ skipping 44 matching lines @@
 // static
 MessagePump* MessagePumpMac::Create() {
   if ([NSThread isMainThread]) {
     return new MessagePumpNSApplication;
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base