Add a CFRunLoop mode for message loop tasks

base/message_loop/message_pump_mac.mm

 // Copyright (c) 2012 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.
 
 #import "base/message_loop/message_pump_mac.h"
 
 #include <dlfcn.h>
 #import <Foundation/Foundation.h>
 
 #include <limits>
 #include <stack>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/metrics/histogram.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 
 #if !defined(OS_IOS)
 #import <AppKit/AppKit.h>
 #endif  // !defined(OS_IOS)
 
+namespace base {
+
 namespace {
 
+void CFRunLoopAddSourceToAllModes(CFRunLoopRef rl, CFRunLoopSourceRef source) {
+  CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+  CFRunLoopAddSource(rl, source, kMessageLoopExclusiveRunLoopMode);
+}
+
+void CFRunLoopRemoveSourceFromAllModes(CFRunLoopRef rl,
+                                       CFRunLoopSourceRef source) {
+  CFRunLoopRemoveSource(rl, source, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSource(rl, source, kMessageLoopExclusiveRunLoopMode);
+}
+
+void CFRunLoopAddTimerToAllModes(CFRunLoopRef rl, CFRunLoopTimerRef timer) {
+  CFRunLoopAddTimer(rl, timer, kCFRunLoopCommonModes);
+  CFRunLoopAddTimer(rl, timer, kMessageLoopExclusiveRunLoopMode);
+}
+
+void CFRunLoopRemoveTimerFromAllModes(CFRunLoopRef rl,
+                                      CFRunLoopTimerRef timer) {
+  CFRunLoopRemoveTimer(rl, timer, kCFRunLoopCommonModes);
+  CFRunLoopRemoveTimer(rl, timer, kMessageLoopExclusiveRunLoopMode);
+}
+
+void CFRunLoopAddObserverToAllModes(CFRunLoopRef rl,
+                                    CFRunLoopObserverRef observer) {
+  CFRunLoopAddObserver(rl, observer, kCFRunLoopCommonModes);
+  CFRunLoopAddObserver(rl, observer, kMessageLoopExclusiveRunLoopMode);
+}
+
+void CFRunLoopRemoveObserverFromAllModes(CFRunLoopRef rl,
+                                         CFRunLoopObserverRef observer) {
+  CFRunLoopRemoveObserver(rl, observer, kCFRunLoopCommonModes);
+  CFRunLoopRemoveObserver(rl, observer, kMessageLoopExclusiveRunLoopMode);
+}
+
 void NoOp(void* info) {
 }
 
 const CFTimeInterval kCFTimeIntervalMax =
     std::numeric_limits<CFTimeInterval>::max();
 
 #if !defined(OS_IOS)
 // Set to true if MessagePumpMac::Create() is called before NSApp is
 // initialized.  Only accessed from the main thread.
 bool g_not_using_cr_app = false;
@@ skipping 21 matching lines @@
 
       dlclose(library_handle);
   });
 
   if (settimertolerance_function_ptr)
     settimertolerance_function_ptr(timer, tolerance);
 }
 
 }  // namespace
 
-namespace base {
+// static
+const CFStringRef kMessageLoopExclusiveRunLoopMode =
+    CFSTR("kMessageLoopExclusiveRunLoopMode");
 
 // 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() {
@@ skipping 37 matching lines @@
 
     CFRunLoopTimerContext timer_context = { .info = this };
     timer_.reset(CFRunLoopTimerCreate(
         NULL,  // allocator
         (Time::Now() + sampling_interval_).ToCFAbsoluteTime(),
         sampling_interval_.InSecondsF(),
         0,  // flags
         0,  // order
         &MessagePumpInstrumentation::TimerFired,
         &timer_context));
-    CFRunLoopAddTimer(CFRunLoopGetCurrent(),
-                      timer_,
-                      kCFRunLoopCommonModes);
+    CFRunLoopAddTimerToAllModes(CFRunLoopGetCurrent(), timer_);
   }
 
   // Used to track kCFRunLoopEntry.
   void LoopEntered() {
     loop_run_times_.push(TimeTicks::Now());
   }
 
   // Used to track kCFRunLoopExit.
   void LoopExited() {
     TimeDelta duration = TimeTicks::Now() - loop_run_times_.top();
@@ skipping 185 matching lines @@
   // 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);
+  CFRunLoopAddTimerToAllModes(run_loop_, delayed_work_timer_);
 
   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);
+  CFRunLoopAddSourceToAllModes(run_loop_, work_source_);
 
   source_context.perform = RunIdleWorkSource;
   idle_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                             2,     // priority
                                             &source_context);
-  CFRunLoopAddSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
+  CFRunLoopAddSourceToAllModes(run_loop_, idle_work_source_);
 
   source_context.perform = RunNestingDeferredWorkSource;
   nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                                         0,     // priority
                                                         &source_context);
-  CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,
-                     kCFRunLoopCommonModes);
+  CFRunLoopAddSourceToAllModes(run_loop_, nesting_deferred_work_source_);
 
   CFRunLoopObserverContext observer_context = CFRunLoopObserverContext();
   observer_context.info = this;
   pre_wait_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                kCFRunLoopBeforeWaiting |
                                                   kCFRunLoopAfterWaiting,
                                                true,  // repeat
                                                0,     // priority
                                                StartOrEndWaitObserver,
                                                &observer_context);
-  CFRunLoopAddObserver(run_loop_, pre_wait_observer_, kCFRunLoopCommonModes);
+  CFRunLoopAddObserverToAllModes(run_loop_, pre_wait_observer_);
 
   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopBeforeSources,
                                                  true,  // repeat
                                                  0,     // priority
                                                  PreSourceObserver,
                                                  &observer_context);
-  CFRunLoopAddObserver(run_loop_, pre_source_observer_, kCFRunLoopCommonModes);
+  CFRunLoopAddObserverToAllModes(run_loop_, pre_source_observer_);
 
   enter_exit_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopEntry |
                                                      kCFRunLoopExit,
                                                  true,  // repeat
                                                  0,     // priority
                                                  EnterExitObserver,
                                                  &observer_context);
-  CFRunLoopAddObserver(run_loop_, enter_exit_observer_, kCFRunLoopCommonModes);
+  CFRunLoopAddObserverToAllModes(run_loop_, enter_exit_observer_);
 }
 
 // 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() {
-  CFRunLoopRemoveObserver(run_loop_, enter_exit_observer_,
-                          kCFRunLoopCommonModes);
+  CFRunLoopRemoveObserverFromAllModes(run_loop_, enter_exit_observer_);
   CFRelease(enter_exit_observer_);
 
-  CFRunLoopRemoveObserver(run_loop_, pre_source_observer_,
-                          kCFRunLoopCommonModes);
+  CFRunLoopRemoveObserverFromAllModes(run_loop_, pre_source_observer_);
   CFRelease(pre_source_observer_);
 
-  CFRunLoopRemoveObserver(run_loop_, pre_wait_observer_,
-                          kCFRunLoopCommonModes);
+  CFRunLoopRemoveObserverFromAllModes(run_loop_, pre_wait_observer_);
   CFRelease(pre_wait_observer_);
 
-  CFRunLoopRemoveSource(run_loop_, nesting_deferred_work_source_,
-                        kCFRunLoopCommonModes);
+  CFRunLoopRemoveSourceFromAllModes(run_loop_, nesting_deferred_work_source_);
   CFRelease(nesting_deferred_work_source_);
 
-  CFRunLoopRemoveSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSourceFromAllModes(run_loop_, idle_work_source_);
   CFRelease(idle_work_source_);
 
-  CFRunLoopRemoveSource(run_loop_, work_source_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSourceFromAllModes(run_loop_, work_source_);
   CFRelease(work_source_);
 
-  CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveTimerFromAllModes(run_loop_, delayed_work_timer_);
   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_;
@@ skipping 368 matching lines @@
   }
 }
 
 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);
+  CFRunLoopAddSourceToAllModes(run_loop(), quit_source_);
 }
 
 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
-  CFRunLoopRemoveSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSourceFromAllModes(run_loop(), quit_source_);
   CFRelease(quit_source_);
 }
 
 void MessagePumpNSRunLoop::DoRun(Delegate* delegate) {
   while (keep_running_) {
     // NSRunLoop manages autorelease pools itself.
     [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
                              beforeDate:[NSDate distantFuture]];
   }
 
@@ skipping 176 matching lines @@
     [NSApplication sharedApplication];
     g_not_using_cr_app = true;
     return new MessagePumpNSApplication;
 #endif
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base