Less busywork for nested Mac run loops

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),
+      run_nesting_level_(0),
       delegate_(NULL),
       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
@@ skipping 82 matching lines @@
   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 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_);
 }
 
 // Must be called on the run loop thread.
 void MessagePumpCFRunLoopBase::ScheduleDelayedWork(
@@ skipping 191 matching lines @@
 void MessagePumpCFRunLoopBase::EnterExitObserver(CFRunLoopObserverRef observer,
                                                  CFRunLoopActivity activity,
                                                  void* info) {
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 
   switch (activity) {
     case kCFRunLoopEntry:
       ++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.
       --self->nesting_level_;
-      if (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, signal the nesting-deferred work source to ensure that such
+        // 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.
 void MessagePumpCFRunLoopBase::EnterExitRunLoop(CFRunLoopActivity activity) {
 }
 
 MessagePumpCFRunLoop::MessagePumpCFRunLoop()
-    : innermost_quittable_(0),
-      quit_pending_(false) {
+    : 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) {
-  // nesting_level_ will be incremented in EnterExitRunLoop, so set
-  // innermost_quittable_ accordingly.
-  int last_innermost_quittable = innermost_quittable_;
-  innermost_quittable_ = nesting_level_ + 1;
-
   // This is completely identical to calling CFRunLoopRun(), except autorelease
   // pool management is introduced.
   int result;
   do {
     ScopedNSAutoreleasePool autorelease_pool;
     result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, DBL_MAX, false);
   } while (result != kCFRunLoopRunStopped && result != kCFRunLoopRunFinished);
-
-  // Restore the previous state of the object.
-  innermost_quittable_ = last_innermost_quittable;
 }
 
 // Must be called on the run loop thread.
 void MessagePumpCFRunLoop::Quit() {
   // Stop the innermost run loop managed by this MessagePumpCFRunLoop object.
-  if (nesting_level_ == innermost_quittable_) {
+  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 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.
     quit_pending_ = true;
   }
 }
 
 // Called by MessagePumpCFRunLoopBase::EnterExitObserver.
 void MessagePumpCFRunLoop::EnterExitRunLoop(CFRunLoopActivity activity) {
   if (activity == kCFRunLoopExit &&
-      nesting_level_ == innermost_quittable_ &&
+      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;
   }
 }
 
@@ skipping 83 matching lines @@
 // static
 MessagePump* MessagePumpMac::Create() {
   if ([NSThread isMainThread]) {
     return new MessagePumpNSApplication;
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base