delegateless pump

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)
+      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
   // as needed when ScheduleDelayedWork is called.
   CFRunLoopTimerContext timer_context = CFRunLoopTimerContext();
   timer_context.info = this;
   delayed_work_timer_ = CFRunLoopTimerCreate(NULL,     // allocator
@@ skipping 81 matching lines @@
   CFRelease(delayed_work_timer_);
 
   CFRelease(run_loop_);
 }
 
 // Must be called on the run loop thread.
 void MessagePumpCFRunLoopBase::Run(Delegate* delegate) {
   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);
 
   delegate_ = last_delegate;
 }
 
 // May be called on any thread.
 void MessagePumpCFRunLoopBase::ScheduleWork() {
   CFRunLoopSourceSignal(work_source_);
   CFRunLoopWakeUp(run_loop_);
 }
@@ skipping 38 matching lines @@
 // 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.
-
-    // TODO(???): we get here while looping in our temporary 1st run
-    // dialog.  If we simply return false, we choke rather brutally
-    // (we no longer do work ever again).  For now, we simply
-    // re-signal ourself so we come around again.  The problem only
-    // happens in a branded build if
-    // ~/Library/Preferences/com.google.Chrome.plist does not exist.
-    CFRunLoopSourceSignal(work_source_);
-
+    // 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.
   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.
+    // 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.
   ScopedNSAutoreleasePool autorelease_pool;
 
   Time next_time;
   delegate_->DoDelayedWork(&next_time);
@@ skipping 19 matching lines @@
 // 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.
+    // 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.
   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.
@@ skipping 230 matching lines @@
 // static
 MessagePump* MessagePumpMac::Create() {
   if ([NSThread isMainThread]) {
     return new MessagePumpNSApplication;
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base