Filter run loop modes in message_pump_mac.mm

base/message_loop/message_pump_mac.h

 // 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.
 
 // The basis for all native run loops on the Mac is the CFRunLoop.  It can be
 // used directly, it can be used as the driving force behind the similar
 // Foundation NSRunLoop, and it can be used to implement higher-level event
 // loops such as the NSApplication event loop.
 //
 // This file introduces a basic CFRunLoop-based implementation of the
@@ skipping 61 matching lines @@
 // Objective-C TUs, it is a type alias for NSAutoreleasePool. In all cases, a
 // method that takes or returns an NSAutoreleasePool* can use
 // AutoreleasePoolType* instead.
 #if !defined(__OBJC__) || __has_feature(objc_arc)
 class AutoreleasePoolType;
 #else   // !defined(__OBJC__) || __has_feature(objc_arc)
 typedef NSAutoreleasePool AutoreleasePoolType;
 #endif  // !defined(__OBJC__) || __has_feature(objc_arc)
 
 class BASE_EXPORT MessagePumpCFRunLoopBase : public MessagePump {
+ public:
+  // MessagePump:
+  void Run(Delegate* delegate) override;
+  void ScheduleWork() override;
+  void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
+  void SetTimerSlack(TimerSlack timer_slack) override;
+
+ protected:
   // Needs access to CreateAutoreleasePool.
   friend class MessagePumpScopedAutoreleasePool;
   friend class TestMessagePumpCFRunLoopBase;
 
- public:
-  MessagePumpCFRunLoopBase();
+  // Tasks will be pumped in the run loop modes described by |mode_mask|, which
+  // maps bits to the index of an internal array of run loop mode identifiers.
+  explicit MessagePumpCFRunLoopBase(int mode_mask);
   ~MessagePumpCFRunLoopBase() override;
 
   // Subclasses should implement the work they need to do in MessagePump::Run
   // in the DoRun method.  MessagePumpCFRunLoopBase::Run calls DoRun directly.
   // This arrangement is used because MessagePumpCFRunLoopBase needs to set
   // up and tear down things before and after the "meat" of DoRun.
-  void Run(Delegate* delegate) override;
   virtual void DoRun(Delegate* delegate) = 0;
 
-  void ScheduleWork() override;
-  void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override;
-  void SetTimerSlack(TimerSlack timer_slack) override;
-
- protected:
   // Accessors for private data members to be used by subclasses.
   CFRunLoopRef run_loop() const { return run_loop_; }
   int nesting_level() const { return nesting_level_; }
   int run_nesting_level() const { return run_nesting_level_; }
 
   // Sets this pump's delegate.  Signals the appropriate sources if
   // |delegateless_work_| is true.  |delegate| can be NULL.
   void SetDelegate(Delegate* delegate);
 
   // Return an autorelease pool to wrap around any work being performed.
   // In some cases, CreateAutoreleasePool may return nil intentionally to
   // preventing an autorelease pool from being created, allowing any
   // objects autoreleased by work to fall into the current autorelease pool.
   virtual AutoreleasePoolType* CreateAutoreleasePool();
 
+  // Invokes function(run_loop_, arg, mode) for all the modes in |mode_mask_|.
+  template <typename Argument>
+  void InvokeForEnabledModes(void function(CFRunLoopRef, Argument, CFStringRef),
+                             Argument argument);
+
  private:
   // Marking timers as invalid at the right time helps significantly reduce
   // power use (see the comment in RunDelayedWorkTimer()), however there is no
   // public API for doing so. CFRuntime.h states that CFRuntimeBase, upon which
   // the above timer invalidation functions are based, can change from release
   // to release and should not be accessed directly (this struct last changed at
   // least in 2008 in CF-476).
   //
   // 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 right bit.
@@ skipping 56 matching lines @@
                                 CFRunLoopActivity activity, void* info);
 
   // Called by EnterExitObserver after performing maintenance on nesting_level_.
   // This allows subclasses an opportunity to perform additional processing on
   // the basis of run loops starting and stopping.
   virtual void EnterExitRunLoop(CFRunLoopActivity activity);
 
   // The thread's run loop.
   CFRunLoopRef run_loop_;
 
+  // Bitmask controlling the run loop modes in which posted tasks may run.
+  const int mode_mask_;
+
   // The timer, sources, and observers are described above alongside their
   // callbacks.
   CFRunLoopTimerRef delayed_work_timer_;
   CFRunLoopSourceRef work_source_;
   CFRunLoopSourceRef idle_work_source_;
   CFRunLoopSourceRef nesting_deferred_work_source_;
   CFRunLoopObserverRef pre_wait_observer_;
   CFRunLoopObserverRef pre_source_observer_;
   CFRunLoopObserverRef enter_exit_observer_;
 
@@ skipping 159 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(MessagePumpMac);
 };
 
 // Tasks posted to the message loop are posted under this mode, as well
 // as kCFRunLoopCommonModes.
 extern const CFStringRef BASE_EXPORT kMessageLoopExclusiveRunLoopMode;
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_MAC_H_