mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-15 22:29:43 +00:00
278 lines
11 KiB
Objective-C
278 lines
11 KiB
Objective-C
// 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 "base/basictypes.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_
|