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

--1:000000000000
+:b0db6e549e0c
+// 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 / file comparison

comparison: ipc/chromium/src/base/message_pump_mac.h

ipc/chromium/src/base/message_pump_mac.h