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 57 matching lines @@
   }
    ~MessagePumpScopedAutoreleasePool() {
     [pool_ drain];
   }
 
  private:
   NSAutoreleasePool* pool_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpScopedAutoreleasePool);
 };
 
-#if !defined(OS_IOS)
-// This function uses private API to modify a test timer's valid state and
-// uses public API to confirm that the private API changed the correct bit.
-// static
-bool MessagePumpCFRunLoopBase::CanInvalidateCFRunLoopTimers() {
-  CFRunLoopTimerContext timer_context = CFRunLoopTimerContext();
-  timer_context.info = nullptr;
-  ScopedCFTypeRef<CFRunLoopTimerRef> test_timer(
-      CFRunLoopTimerCreate(NULL,                // allocator
-                           kCFTimeIntervalMax,  // fire time
-                           kCFTimeIntervalMax,  // interval
-                           0,                   // flags
-                           0,                   // priority
-                           nullptr, &timer_context));
-  // Should be valid from the start.
-  if (!CFRunLoopTimerIsValid(test_timer)) {
-    return false;
-  }
-  // Confirm that the private API can mark the timer invalid.
-  __ChromeCFRunLoopTimerSetValid(test_timer, false);
-  if (CFRunLoopTimerIsValid(test_timer)) {
-    return false;
-  }
-  // Confirm that the private API can mark the timer valid.
-  __ChromeCFRunLoopTimerSetValid(test_timer, true);
-  return CFRunLoopTimerIsValid(test_timer);
+// 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_;
+  SetDelegate(delegate);
+
+  DoRun(delegate);
+
+  // Restore the previous state of the object.
+  SetDelegate(last_delegate);
+  run_nesting_level_ = last_run_nesting_level;
 }
-#endif  // !defined(OS_IOS)
 
-// static
-void MessagePumpCFRunLoopBase::ChromeCFRunLoopTimerSetValid(
-    CFRunLoopTimerRef timer,
-    bool valid) {
-#if !defined(OS_IOS)
-  static bool can_invalidate_timers = CanInvalidateCFRunLoopTimers();
-  if (can_invalidate_timers) {
-    __ChromeCFRunLoopTimerSetValid(timer, valid);
-  }
-#endif  // !defined(OS_IOS)
+// May be called on any thread.
+void MessagePumpCFRunLoopBase::ScheduleWork() {
+  CFRunLoopSourceSignal(work_source_);
+  CFRunLoopWakeUp(run_loop_);
 }
 
 // Must be called on the run loop thread.
-MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase()
-    : delegate_(NULL),
+void MessagePumpCFRunLoopBase::ScheduleDelayedWork(
+    const TimeTicks& delayed_work_time) {
+  TimeDelta delta = delayed_work_time - TimeTicks::Now();
+  delayed_work_fire_time_ = CFAbsoluteTimeGetCurrent() + delta.InSecondsF();
+
+  // Flip the timer's validation bit just before setting the new fire time. Do
+  // this now because CFRunLoopTimerSetNextFireDate() likely checks the validity
+  // of a timer before proceeding to set its fire date. Making the timer valid
+  // now won't have any side effects (such as a premature firing of the timer)
+  // because we're only flipping a bit.
+  //
+  // Please see the comment in RunDelayedWorkTimer() for more info on the whys
+  // of invalidation.
+  ChromeCFRunLoopTimerSetValid(delayed_work_timer_, true);
+
+  CFRunLoopTimerSetNextFireDate(delayed_work_timer_, delayed_work_fire_time_);
+  if (timer_slack_ == TIMER_SLACK_MAXIMUM) {
+    CFRunLoopTimerSetTolerance(delayed_work_timer_, delta.InSecondsF() * 0.5);
+  } else {
+    CFRunLoopTimerSetTolerance(delayed_work_timer_, 0);
+  }
+}
+
+void MessagePumpCFRunLoopBase::SetTimerSlack(TimerSlack timer_slack) {
+  timer_slack_ = timer_slack;
+}
+
+// Must be called on the run loop thread.
+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_);
+  InvokeForEnabledModes(&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_);
+  InvokeForEnabledModes(&CFRunLoopAddSource, work_source_);
 
   source_context.perform = RunIdleWorkSource;
   idle_work_source_ = CFRunLoopSourceCreate(NULL,  // allocator
                                             2,     // priority
                                             &source_context);
-  CFRunLoopAddSourceToAllModes(run_loop_, idle_work_source_);
+  InvokeForEnabledModes(&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_);
+  InvokeForEnabledModes(&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_);
+  InvokeForEnabledModes(&CFRunLoopAddObserver, pre_wait_observer_);
 
   pre_source_observer_ = CFRunLoopObserverCreate(NULL,  // allocator
                                                  kCFRunLoopBeforeSources,
                                                  true,  // repeat
                                                  0,     // priority
                                                  PreSourceObserver,
                                                  &observer_context);
-  CFRunLoopAddObserverToAllModes(run_loop_, pre_source_observer_);
+  InvokeForEnabledModes(&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_);
+  InvokeForEnabledModes(&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_}) {
+    InvokeForEnabledModes(&CFRunLoopRemoveObserver, observer);
+    CFRelease(observer);
+  }
+  for (const CFRunLoopSourceRef& source :
+       {nesting_deferred_work_source_, idle_work_source_, work_source_}) {
+    InvokeForEnabledModes(&CFRunLoopRemoveSource, source);
+    CFRelease(source);
+  }
+  InvokeForEnabledModes(&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;
-
-  Delegate* last_delegate = delegate_;
-  SetDelegate(delegate);
-
-  DoRun(delegate);
-
-  // Restore the previous state of the object.
-  SetDelegate(last_delegate);
-  run_nesting_level_ = last_run_nesting_level;
-}
-
 void MessagePumpCFRunLoopBase::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 
   if (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_idle_work_) {
       CFRunLoopSourceSignal(idle_work_source_);
       delegateless_idle_work_ = false;
     }
   }
 }
 
-// May be called on any thread.
-void MessagePumpCFRunLoopBase::ScheduleWork() {
-  CFRunLoopSourceSignal(work_source_);
-  CFRunLoopWakeUp(run_loop_);
+// Base version returns a standard NSAutoreleasePool.
+AutoreleasePoolType* MessagePumpCFRunLoopBase::CreateAutoreleasePool() {
+  return [[NSAutoreleasePool alloc] init];
 }
 
-// Must be called on the run loop thread.
-void MessagePumpCFRunLoopBase::ScheduleDelayedWork(
-    const TimeTicks& delayed_work_time) {
-  TimeDelta delta = delayed_work_time - TimeTicks::Now();
-  delayed_work_fire_time_ = CFAbsoluteTimeGetCurrent() + delta.InSecondsF();
-
-  // Flip the timer's validation bit just before setting the new fire time. Do
-  // this now because CFRunLoopTimerSetNextFireDate() likely checks the validity
-  // of a timer before proceeding to set its fire date. Making the timer valid
-  // now won't have any side effects (such as a premature firing of the timer)
-  // because we're only flipping a bit.
-  //
-  // Please see the comment in RunDelayedWorkTimer() for more info on the whys
-  // of invalidation.
-  ChromeCFRunLoopTimerSetValid(delayed_work_timer_, true);
-
-  CFRunLoopTimerSetNextFireDate(delayed_work_timer_, delayed_work_fire_time_);
-  if (timer_slack_ == TIMER_SLACK_MAXIMUM) {
-    CFRunLoopTimerSetTolerance(delayed_work_timer_, delta.InSecondsF() * 0.5);
-  } else {
-    CFRunLoopTimerSetTolerance(delayed_work_timer_, 0);
+template <typename Argument>
+void MessagePumpCFRunLoopBase::InvokeForEnabledModes(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]);
   }
 }
 
-void MessagePumpCFRunLoopBase::SetTimerSlack(TimerSlack timer_slack) {
-  timer_slack_ = timer_slack;
+#if !defined(OS_IOS)
+// This function uses private API to modify a test timer's valid state and
+// uses public API to confirm that the private API changed the correct bit.
+// static
+bool MessagePumpCFRunLoopBase::CanInvalidateCFRunLoopTimers() {
+  CFRunLoopTimerContext timer_context = CFRunLoopTimerContext();
+  timer_context.info = nullptr;
+  ScopedCFTypeRef<CFRunLoopTimerRef> test_timer(
+      CFRunLoopTimerCreate(NULL,                // allocator
+                           kCFTimeIntervalMax,  // fire time
+                           kCFTimeIntervalMax,  // interval
+                           0,                   // flags
+                           0,                   // priority
+                           nullptr, &timer_context));
+  // Should be valid from the start.
+  if (!CFRunLoopTimerIsValid(test_timer)) {
+    return false;
+  }
+  // Confirm that the private API can mark the timer invalid.
+  __ChromeCFRunLoopTimerSetValid(test_timer, false);
+  if (CFRunLoopTimerIsValid(test_timer)) {
+    return false;
+  }
+  // Confirm that the private API can mark the timer valid.
+  __ChromeCFRunLoopTimerSetValid(test_timer, true);
+  return CFRunLoopTimerIsValid(test_timer);
+}
+#endif  // !defined(OS_IOS)
+
+// static
+void MessagePumpCFRunLoopBase::ChromeCFRunLoopTimerSetValid(
+    CFRunLoopTimerRef timer,
+    bool valid) {
+#if !defined(OS_IOS)
+  static bool can_invalidate_timers = CanInvalidateCFRunLoopTimers();
+  if (can_invalidate_timers) {
+    __ChromeCFRunLoopTimerSetValid(timer, valid);
+  }
+#endif  // !defined(OS_IOS)
 }
 
 // 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;
@@ skipping 254 matching lines @@
   base::mac::CallWithEHFrame(^{
     self->EnterExitRunLoop(activity);
   });
 }
 
 // Called by MessagePumpCFRunLoopBase::EnterExitRunLoop.  The default
 // 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_);
+  InvokeForEnabledModes(&CFRunLoopAddSource, quit_source_);
 }
 
 MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
-  CFRunLoopRemoveSourceFromAllModes(run_loop(), quit_source_);
+  InvokeForEnabledModes(&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