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>
@@ skipping 50 matching lines @@
   });
 
   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() {
     [pool_ drain];
@@ skipping 36 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);
+    CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer_, kCFRunLoopCommonModes);
+    CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer_,
+                      kMessageLoopExclusiveRunLoopMode);
   }
 
   // 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 186 matching lines @@
   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);
+  CFRunLoopAddTimer(run_loop_, delayed_work_timer_,

[Mark Mentovai, 2014/06/12 16:17:13]

There’s enough duplication now that I think we should have wrappers for
CFRunLoop{Add,Remove}{Timer,Source,Observer}(). Here in this code, you would
just call the wrappers. The wrappers would call the real function twice, once
for each run loop mode that we’re interested in.

[ccameron, 2014/06/12 17:10:40]

Yeah, I was on the bubble about which way to go -- I've changed them over to
CFRunLoop*To/FromAllModes

+                    kMessageLoopExclusiveRunLoopMode);
 
   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);
+  CFRunLoopAddSource(run_loop_, work_source_,
+                     kMessageLoopExclusiveRunLoopMode);
 
   source_context.perform = RunIdleWorkSource;
   idle_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                             2,     // priority
                                             &source_context);
   CFRunLoopAddSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
+  CFRunLoopAddSource(
+      run_loop_, idle_work_source_, kCFRunLoopCommonModes);
 
   source_context.perform = RunNestingDeferredWorkSource;
   nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                                         0,     // priority
                                                         &source_context);
   CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,
                      kCFRunLoopCommonModes);
+  CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,
+                     kMessageLoopExclusiveRunLoopMode);
 
   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);
+  CFRunLoopAddObserver(run_loop_, pre_wait_observer_,
+                       kMessageLoopExclusiveRunLoopMode);
 
   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopBeforeSources,
                                                  true,  // repeat
                                                  0,     // priority
                                                  PreSourceObserver,
                                                  &observer_context);
   CFRunLoopAddObserver(run_loop_, pre_source_observer_, kCFRunLoopCommonModes);
+  CFRunLoopAddObserver(run_loop_, pre_source_observer_,
+                       kMessageLoopExclusiveRunLoopMode);
 
   enter_exit_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopEntry |
                                                      kCFRunLoopExit,
                                                  true,  // repeat
                                                  0,     // priority
                                                  EnterExitObserver,
                                                  &observer_context);
   CFRunLoopAddObserver(run_loop_, enter_exit_observer_, kCFRunLoopCommonModes);
+  CFRunLoopAddObserver(run_loop_, enter_exit_observer_,
+                       kMessageLoopExclusiveRunLoopMode);
 }
 
 // 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);
+  CFRunLoopRemoveObserver(run_loop_, enter_exit_observer_,
+                          kMessageLoopExclusiveRunLoopMode);
   CFRelease(enter_exit_observer_);
 
   CFRunLoopRemoveObserver(run_loop_, pre_source_observer_,
                           kCFRunLoopCommonModes);
+  CFRunLoopRemoveObserver(run_loop_, pre_source_observer_,
+                          kMessageLoopExclusiveRunLoopMode);
   CFRelease(pre_source_observer_);
 
   CFRunLoopRemoveObserver(run_loop_, pre_wait_observer_,
                           kCFRunLoopCommonModes);
+  CFRunLoopRemoveObserver(run_loop_, pre_wait_observer_,
+                          kMessageLoopExclusiveRunLoopMode);
   CFRelease(pre_wait_observer_);
 
   CFRunLoopRemoveSource(run_loop_, nesting_deferred_work_source_,
                         kCFRunLoopCommonModes);
+  CFRunLoopRemoveSource(run_loop_, nesting_deferred_work_source_,
+                        kMessageLoopExclusiveRunLoopMode);
   CFRelease(nesting_deferred_work_source_);
 
   CFRunLoopRemoveSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSource(run_loop_, idle_work_source_,
+                        kMessageLoopExclusiveRunLoopMode);
   CFRelease(idle_work_source_);
 
   CFRunLoopRemoveSource(run_loop_, work_source_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSource(run_loop_, work_source_,
+                        kMessageLoopExclusiveRunLoopMode);
   CFRelease(work_source_);
 
   CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_,
+                       kMessageLoopExclusiveRunLoopMode);
   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 369 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);
+  CFRunLoopAddSource(run_loop(), quit_source_,
+                     kMessageLoopExclusiveRunLoopMode);
 }
 
 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
   CFRunLoopRemoveSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
+  CFRunLoopRemoveSource(run_loop(), quit_source_,
+                        kMessageLoopExclusiveRunLoopMode);
   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