The Tor Browser: ipc/chromium/src/base/message_pump

ipc/chromium/src/base/message_pump_mac.h@6474c204b198 (annotated)

ipc/chromium/src/base/message_pump_mac.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2008 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
 // MessagePump interface called CFRunLoopBase.  CFRunLoopBase contains all
 // of the machinery necessary to dispatch events to a delegate, but does not
 // implement the specific run loop.  Concrete subclasses must provide their
 // own DoRun and Quit implementations.
 //
 // A concrete subclass that just runs a CFRunLoop loop is provided in
 // MessagePumpCFRunLoop.  For an NSRunLoop, the similar MessagePumpNSRunLoop
 // is provided.
 //
 // For the application's event loop, an implementation based on AppKit's
 // NSApplication event system is provided in MessagePumpNSApplication.
 //
 // Typically, MessagePumpNSApplication only makes sense on a Cocoa
 // application's main thread.  If a CFRunLoop-based message pump is needed on
 // any other thread, one of the other concrete subclasses is preferrable.
 // MessagePumpMac::Create is defined, which returns a new NSApplication-based
 // or NSRunLoop-based MessagePump subclass depending on which thread it is
 // called on.
 #ifndef BASE_MESSAGE_PUMP_MAC_H_
 #define BASE_MESSAGE_PUMP_MAC_H_
 #include "base/message_pump.h"
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/IOKitLib.h>
 #if defined(__OBJC__)
 @class NSAutoreleasePool;
 #else  // defined(__OBJC__)
 class NSAutoreleasePool;
 #endif  // defined(__OBJC__)
 namespace base {
 class TimeTicks;
 class MessagePumpCFRunLoopBase : public MessagePump {
   // Needs access to CreateAutoreleasePool.
   friend class MessagePumpScopedAutoreleasePool;
  public:
   MessagePumpCFRunLoopBase();
   virtual ~MessagePumpCFRunLoopBase();
   // 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.
   virtual void Run(Delegate* delegate);
   virtual void DoRun(Delegate* delegate) = 0;
   virtual void ScheduleWork();
   virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time);
  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_; }
   // 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 NSAutoreleasePool* CreateAutoreleasePool();
  private:
   // Timer callback scheduled by ScheduleDelayedWork.  This does not do any
   // work, but it signals delayed_work_source_ so that delayed work can be
   // performed within the appropriate priority constraints.
   static void RunDelayedWorkTimer(CFRunLoopTimerRef timer, void* info);
   // Perform highest-priority work.  This is associated with work_source_
   // signalled by ScheduleWork.  The static method calls the instance method;
   // the instance method returns true if work was done.
   static void RunWorkSource(void* info);
   bool RunWork();
   // Perform delayed-priority work.  This is associated with
   // delayed_work_source_ signalled by RunDelayedWorkTimer, and is responsible
   // for calling ScheduleDelayedWork again if appropriate.  The static method
   // calls the instance method; the instance method returns true if more
   // delayed work is available.
   static void RunDelayedWorkSource(void* info);
   bool RunDelayedWork();
   // Perform idle-priority work.  This is normally called by PreWaitObserver,
   // but is also associated with idle_work_source_.  When this function
   // actually does perform idle work, it will resignal that source.  The
   // static method calls the instance method; the instance method returns
   // true if idle work was done.
   static void RunIdleWorkSource(void* info);
   bool RunIdleWork();
   // Perform work that may have been deferred because it was not runnable
   // within a nested run loop.  This is associated with
   // nesting_deferred_work_source_ and is signalled by
   // MaybeScheduleNestingDeferredWork when returning from a nested loop,
   // so that an outer loop will be able to perform the necessary tasks if it
   // permits nestable tasks.
   static void RunNestingDeferredWorkSource(void* info);
   bool RunNestingDeferredWork();
   // Schedules possible nesting-deferred work to be processed before the run
   // loop goes to sleep, exits, or begins processing sources at the top of its
   // loop.  If this function detects that a nested loop had run since the
   // previous attempt to schedule nesting-deferred work, it will schedule a
   // call to RunNestingDeferredWorkSource.
   void MaybeScheduleNestingDeferredWork();
   // Observer callback responsible for performing idle-priority work, before
   // the run loop goes to sleep.  Associated with idle_work_observer_.
   static void PreWaitObserver(CFRunLoopObserverRef observer,
                               CFRunLoopActivity activity, void* info);
   // Observer callback called before the run loop processes any sources.
   // Associated with pre_source_observer_.
   static void PreSourceObserver(CFRunLoopObserverRef observer,
                                 CFRunLoopActivity activity, void* info);
   // Observer callback called when the run loop starts and stops, at the
   // beginning and end of calls to CFRunLoopRun.  This is used to maintain
   // nesting_level_.  Associated with enter_exit_observer_.
   static void EnterExitObserver(CFRunLoopObserverRef observer,
                                 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);
   // IOKit power state change notification callback, called when the system
   // enters and leaves the sleep state.
   static void PowerStateNotification(void* info, io_service_t service,
                                      uint32_t message_type,
                                      void* message_argument);
   // The thread's run loop.
   CFRunLoopRef run_loop_;
   // The timer, sources, and observers are described above alongside their
   // callbacks.
   CFRunLoopTimerRef delayed_work_timer_;
   CFRunLoopSourceRef work_source_;
   CFRunLoopSourceRef delayed_work_source_;
   CFRunLoopSourceRef idle_work_source_;
   CFRunLoopSourceRef nesting_deferred_work_source_;
   CFRunLoopObserverRef pre_wait_observer_;
   CFRunLoopObserverRef pre_source_observer_;
   CFRunLoopObserverRef enter_exit_observer_;
   // Objects used for power state notification.  See PowerStateNotification.
   io_connect_t root_power_domain_;
   IONotificationPortRef power_notification_port_;
   io_object_t power_notification_object_;
   // (weak) Delegate passed as an argument to the innermost Run call.
   Delegate* delegate_;
   // The time that delayed_work_timer_ is scheduled to fire.  This is tracked
   // independently of CFRunLoopTimerGetNextFireDate(delayed_work_timer_)
   // to be able to reset the timer properly after waking from system sleep.
   // See PowerStateNotification.
   CFAbsoluteTime delayed_work_fire_time_;
   // The recursion depth of the currently-executing CFRunLoopRun loop on the
   // run loop's thread.  0 if no run loops are running inside of whatever scope
   // the object was created in.
   int nesting_level_;
   // The recursion depth (calculated in the same way as nesting_level_) of the
   // innermost executing CFRunLoopRun loop started by a call to Run.
   int run_nesting_level_;
   // The deepest (numerically highest) recursion depth encountered since the
   // most recent attempt to run nesting-deferred work.
   int deepest_nesting_level_;
   // "Delegateless" work flags are set when work is ready to be performed but
   // must wait until a delegate is available to process it.  This can happen
   // when a MessagePumpCFRunLoopBase is instantiated and work arrives without
   // any call to Run on the stack.  The Run method will check for delegateless
   // work on entry and redispatch it as needed once a delegate is available.
   bool delegateless_work_;
   bool delegateless_delayed_work_;
   bool delegateless_idle_work_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpCFRunLoopBase);
 };
 class MessagePumpCFRunLoop : public MessagePumpCFRunLoopBase {
  public:
   MessagePumpCFRunLoop();
   virtual void DoRun(Delegate* delegate);
   virtual void Quit();
  private:
   virtual void EnterExitRunLoop(CFRunLoopActivity activity);
   // True if Quit is called to stop the innermost MessagePump
   // (innermost_quittable_) but some other CFRunLoopRun loop (nesting_level_)
   // is running inside the MessagePump's innermost Run call.
   bool quit_pending_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpCFRunLoop);
 };
 class MessagePumpNSRunLoop : public MessagePumpCFRunLoopBase {
  public:
   MessagePumpNSRunLoop();
   virtual ~MessagePumpNSRunLoop();
   virtual void DoRun(Delegate* delegate);
   virtual void Quit();
  private:
   // A source that doesn't do anything but provide something signalable
   // attached to the run loop.  This source will be signalled when Quit
   // is called, to cause the loop to wake up so that it can stop.
   CFRunLoopSourceRef quit_source_;
   // False after Quit is called.
   bool keep_running_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpNSRunLoop);
 };
 class MessagePumpNSApplication : public MessagePumpCFRunLoopBase {
  public:
   MessagePumpNSApplication();
   virtual void DoRun(Delegate* delegate);
   virtual void Quit();
  protected:
   // Returns nil if NSApp is currently in the middle of calling -sendEvent.
   virtual NSAutoreleasePool* CreateAutoreleasePool();
  private:
   // False after Quit is called.
   bool keep_running_;
   // True if DoRun is managing its own run loop as opposed to letting
   // -[NSApplication run] handle it.  The outermost run loop in the application
   // is managed by -[NSApplication run], inner run loops are handled by a loop
   // in DoRun.
   bool running_own_loop_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpNSApplication);
 };
 class MessagePumpMac {
  public:
   // Returns a new instance of MessagePumpNSApplication if called on the main
   // thread.  Otherwise, returns a new instance of MessagePumpNSRunLoop.
   static MessagePump* Create();
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(MessagePumpMac);
 };
 }  // namespace base
 #endif  // BASE_MESSAGE_PUMP_MAC_H_

The Tor Browser / annotate

ipc/chromium/src/base/message_pump_mac.h@6474c204b198 (annotated)

ipc/chromium/src/base/message_pump_mac.h