Filter run loop modes in message_pump_mac.mm

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"
 
 #import <Foundation/Foundation.h>
 
 #include <limits>
 
@@ skipping 26 matching lines @@
     // Mode that only sees Chrome work sources.
     kMessageLoopExclusiveRunLoopMode,
 
     // Process work when NSMenus are fading out.
     CFSTR("com.apple.hitoolbox.windows.windowfadingmode"),
 
     // Process work when AppKit is highlighting an item on the main menubar.
     CFSTR("NSUnhighlightMenuRunLoopMode"),
 };
 
-void CFRunLoopAddSourceToAllModes(CFRunLoopRef rl, CFRunLoopSourceRef source) {
-  for (const CFStringRef& mode : kAllModes)
-    CFRunLoopAddSource(rl, source, mode);
-}
-
-void CFRunLoopRemoveSourceFromAllModes(CFRunLoopRef rl,
-                                       CFRunLoopSourceRef source) {
-  for (const CFStringRef& mode : kAllModes)
-    CFRunLoopRemoveSource(rl, source, mode);
-}
-
-void CFRunLoopAddTimerToAllModes(CFRunLoopRef rl, CFRunLoopTimerRef timer) {
-  for (const CFStringRef& mode : kAllModes)
-    CFRunLoopAddTimer(rl, timer, mode);
-}
-
-void CFRunLoopRemoveTimerFromAllModes(CFRunLoopRef rl,
-                                      CFRunLoopTimerRef timer) {
-  for (const CFStringRef& mode : kAllModes)
-    CFRunLoopRemoveTimer(rl, timer, mode);
-}
-
-void CFRunLoopAddObserverToAllModes(CFRunLoopRef rl,
-                                    CFRunLoopObserverRef observer) {
-  for (const CFStringRef& mode : kAllModes)
-    CFRunLoopAddObserver(rl, observer, mode);
-}
-
-void CFRunLoopRemoveObserverFromAllModes(CFRunLoopRef rl,
-                                         CFRunLoopObserverRef observer) {
-  for (const CFStringRef& mode : kAllModes)
-    CFRunLoopRemoveObserver(rl, observer, mode);
-}
+// Mask that determines which modes in |kAllModes| to use.
+enum { kCommonModeMask = 0x1, kAllModesMask = ~0 };
 
 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.
@@ skipping 99 matching lines @@
     bool valid) {
 #if !defined(OS_IOS)
   static bool can_invalidate_timers = CanInvalidateCFRunLoopTimers();
   if (can_invalidate_timers) {
     __ChromeCFRunLoopTimerSetValid(timer, valid);
   }
 #endif  // !defined(OS_IOS)
 }
 
 // Must be called on the run loop thread.
-MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase()
-    : delegate_(NULL),
+MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase(int mode_mask)
+    : mode_mask_(mode_mask),
+      delegate_(NULL),
       delayed_work_fire_time_(kCFTimeIntervalMax),
       timer_slack_(base::TIMER_SLACK_NONE),
       nesting_level_(0),
       run_nesting_level_(0),
       deepest_nesting_level_(0),
       delegateless_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
                                              kCFTimeIntervalMax,  // fire time
                                              kCFTimeIntervalMax,  // interval
                                              0,                   // flags
                                              0,                   // priority
                                              RunDelayedWorkTimer,
                                              &timer_context);
-  CFRunLoopAddTimerToAllModes(run_loop_, delayed_work_timer_);
+  InvokeForAllModes(&CFRunLoopAddTimer, delayed_work_timer_);
 
   CFRunLoopSourceContext source_context = CFRunLoopSourceContext();
   source_context.info = this;
   source_context.perform = RunWorkSource;
   work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                        1,     // priority
                                        &source_context);
-  CFRunLoopAddSourceToAllModes(run_loop_, work_source_);
+  InvokeForAllModes(&CFRunLoopAddSource, work_source_);
 
   source_context.perform = RunIdleWorkSource;
   idle_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                             2,     // priority
                                             &source_context);
-  CFRunLoopAddSourceToAllModes(run_loop_, idle_work_source_);
+  InvokeForAllModes(&CFRunLoopAddSource, idle_work_source_);
 
   source_context.perform = RunNestingDeferredWorkSource;
   nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                                         0,     // priority
                                                         &source_context);
-  CFRunLoopAddSourceToAllModes(run_loop_, nesting_deferred_work_source_);
+  InvokeForAllModes(&CFRunLoopAddSource, nesting_deferred_work_source_);
 
   CFRunLoopObserverContext observer_context = CFRunLoopObserverContext();
   observer_context.info = this;
   pre_wait_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                kCFRunLoopBeforeWaiting,
                                                true,  // repeat
                                                0,     // priority
                                                PreWaitObserver,
                                                &observer_context);
-  CFRunLoopAddObserverToAllModes(run_loop_, pre_wait_observer_);
+  InvokeForAllModes(&CFRunLoopAddObserver, pre_wait_observer_);
 
   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopBeforeSources,
                                                  true,  // repeat
                                                  0,     // priority
                                                  PreSourceObserver,
                                                  &observer_context);
-  CFRunLoopAddObserverToAllModes(run_loop_, pre_source_observer_);
+  InvokeForAllModes(&CFRunLoopAddObserver, pre_source_observer_);
 
   enter_exit_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopEntry |
                                                      kCFRunLoopExit,
                                                  true,  // repeat
                                                  0,     // priority
                                                  EnterExitObserver,
                                                  &observer_context);
-  CFRunLoopAddObserverToAllModes(run_loop_, enter_exit_observer_);
+  InvokeForAllModes(&CFRunLoopAddObserver, 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() {
-  CFRunLoopRemoveObserverFromAllModes(run_loop_, enter_exit_observer_);
-  CFRelease(enter_exit_observer_);
-
-  CFRunLoopRemoveObserverFromAllModes(run_loop_, pre_source_observer_);
-  CFRelease(pre_source_observer_);
-
-  CFRunLoopRemoveObserverFromAllModes(run_loop_, pre_wait_observer_);
-  CFRelease(pre_wait_observer_);
-
-  CFRunLoopRemoveSourceFromAllModes(run_loop_, nesting_deferred_work_source_);
-  CFRelease(nesting_deferred_work_source_);
-
-  CFRunLoopRemoveSourceFromAllModes(run_loop_, idle_work_source_);
-  CFRelease(idle_work_source_);
-
-  CFRunLoopRemoveSourceFromAllModes(run_loop_, work_source_);
-  CFRelease(work_source_);
-
-  CFRunLoopRemoveTimerFromAllModes(run_loop_, delayed_work_timer_);
+  for (const CFRunLoopObserverRef& observer :
+       {enter_exit_observer_, pre_source_observer_, pre_wait_observer_}) {
+    InvokeForAllModes(&CFRunLoopRemoveObserver, observer);
+    CFRelease(observer);
+  }
+  for (const CFRunLoopSourceRef& source :
+       {nesting_deferred_work_source_, idle_work_source_, work_source_}) {
+    InvokeForAllModes(&CFRunLoopRemoveSource, source);
+    CFRelease(source);
+  }
+  InvokeForAllModes(&CFRunLoopRemoveTimer, 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_;
   run_nesting_level_ = nesting_level_ + 1;
 
@@ skipping 52 matching lines @@
     CFRunLoopTimerSetTolerance(delayed_work_timer_, delta.InSecondsF() * 0.5);
   } else {
     CFRunLoopTimerSetTolerance(delayed_work_timer_, 0);
   }
 }
 
 void MessagePumpCFRunLoopBase::SetTimerSlack(TimerSlack timer_slack) {
   timer_slack_ = timer_slack;
 }
 
+template <typename Argument>
+void MessagePumpCFRunLoopBase::InvokeForAllModes(void method(CFRunLoopRef,
+                                                             Argument,
+                                                             CFStringRef),
+                                                 Argument argument) {
+  for (size_t i = 0; i < arraysize(kAllModes); ++i) {
+    if (mode_mask_ & (0x1 << i))
+      method(run_loop_, argument, kAllModes[i]);
+  }
+}
+
 // Called from the run loop.
 // static
 void MessagePumpCFRunLoopBase::RunDelayedWorkTimer(CFRunLoopTimerRef timer,
                                                    void* info) {
   MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
 
   // The timer won't fire again until it's reset.
   self->delayed_work_fire_time_ = kCFTimeIntervalMax;
 
   // The message pump's timer needs to fire at changing and unpredictable
@@ skipping 258 matching lines @@
 // implementation is a no-op.
 void MessagePumpCFRunLoopBase::EnterExitRunLoop(CFRunLoopActivity activity) {
 }
 
 // Base version returns a standard NSAutoreleasePool.
 AutoreleasePoolType* MessagePumpCFRunLoopBase::CreateAutoreleasePool() {
   return [[NSAutoreleasePool alloc] init];
 }
 
 MessagePumpCFRunLoop::MessagePumpCFRunLoop()
-    : quit_pending_(false) {
-}
+    : MessagePumpCFRunLoopBase(kCommonModeMask), quit_pending_(false) {}
 
 MessagePumpCFRunLoop::~MessagePumpCFRunLoop() {}
 
 // 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) {
   // This is completely identical to calling CFRunLoopRun(), except autorelease
   // pool management is introduced.
@@ skipping 30 matching lines @@
     // 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;
   }
 }
 
 MessagePumpNSRunLoop::MessagePumpNSRunLoop()
-    : keep_running_(true) {
+    : MessagePumpCFRunLoopBase(kCommonModeMask), keep_running_(true) {
   CFRunLoopSourceContext source_context = CFRunLoopSourceContext();
   source_context.perform = NoOp;
   quit_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                        0,     // priority
                                        &source_context);
-  CFRunLoopAddSourceToAllModes(run_loop(), quit_source_);
+  InvokeForAllModes(&CFRunLoopAddSource, quit_source_);
 }
 
 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
-  CFRunLoopRemoveSourceFromAllModes(run_loop(), quit_source_);
+  InvokeForAllModes(&CFRunLoopRemoveSource, 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]];
   }
 
   keep_running_ = true;
 }
 
 void MessagePumpNSRunLoop::Quit() {
   keep_running_ = false;
   CFRunLoopSourceSignal(quit_source_);
   CFRunLoopWakeUp(run_loop());
 }
 
 #if defined(OS_IOS)
 MessagePumpUIApplication::MessagePumpUIApplication()
-    : run_loop_(NULL) {
-}
+    : MessagePumpCFRunLoopBase(kCommonModeMask), run_loop_(NULL) {}
 
 MessagePumpUIApplication::~MessagePumpUIApplication() {}
 
 void MessagePumpUIApplication::DoRun(Delegate* delegate) {
   NOTREACHED();
 }
 
 void MessagePumpUIApplication::Quit() {
   NOTREACHED();
 }
 
 void MessagePumpUIApplication::Attach(Delegate* delegate) {
   DCHECK(!run_loop_);
   run_loop_ = new RunLoop();
   CHECK(run_loop_->BeforeRun());
   SetDelegate(delegate);
 }
 
 #else
 
 MessagePumpNSApplication::MessagePumpNSApplication()
-    : keep_running_(true),
-      running_own_loop_(false) {
-}
+    : MessagePumpCFRunLoopBase(kAllModesMask),
+      keep_running_(true),
+      running_own_loop_(false) {}
 
 MessagePumpNSApplication::~MessagePumpNSApplication() {}
 
 void MessagePumpNSApplication::DoRun(Delegate* delegate) {
   bool last_running_own_loop_ = running_own_loop_;
 
   // NSApp must be initialized by calling:
   // [{some class which implements CrAppProtocol} sharedApplication]
   // Most likely candidates are CrApplication or BrowserCrApplication.
   // These can be initialized from C++ code by calling
@@ skipping 125 matching lines @@
     [NSApplication sharedApplication];
     g_not_using_cr_app = true;
     return new MessagePumpNSApplication;
 #endif
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base