mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-19 19:29:32 +00:00
763 lines
30 KiB
Plaintext
763 lines
30 KiB
Plaintext
// 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.
|
|
|
|
#include "base/message_pump_mac.h"
|
|
|
|
#import <AppKit/AppKit.h>
|
|
#import <Foundation/Foundation.h>
|
|
#include <IOKit/IOMessage.h>
|
|
#include <IOKit/pwr_mgt/IOPMLib.h>
|
|
|
|
#include <limits>
|
|
|
|
#import "base/chrome_application_mac.h"
|
|
#include "base/logging.h"
|
|
#include "base/time.h"
|
|
|
|
namespace {
|
|
|
|
void NoOp(void* info) {
|
|
}
|
|
|
|
const CFTimeInterval kCFTimeIntervalMax =
|
|
std::numeric_limits<CFTimeInterval>::max();
|
|
|
|
} // namespace
|
|
|
|
namespace base {
|
|
|
|
// A scoper for autorelease pools created from message pump run loops.
|
|
// Avoids dirtying up the ScopedNSAutoreleasePool interface for the rare
|
|
// case where an autorelease pool needs to be passed in.
|
|
class MessagePumpScopedAutoreleasePool {
|
|
public:
|
|
explicit MessagePumpScopedAutoreleasePool(MessagePumpCFRunLoopBase* pump) :
|
|
pool_(pump->CreateAutoreleasePool()) {
|
|
}
|
|
~MessagePumpScopedAutoreleasePool() {
|
|
[pool_ drain];
|
|
}
|
|
|
|
private:
|
|
NSAutoreleasePool* pool_;
|
|
DISALLOW_COPY_AND_ASSIGN(MessagePumpScopedAutoreleasePool);
|
|
};
|
|
|
|
// Must be called on the run loop thread.
|
|
MessagePumpCFRunLoopBase::MessagePumpCFRunLoopBase()
|
|
: delegate_(NULL),
|
|
delayed_work_fire_time_(kCFTimeIntervalMax),
|
|
nesting_level_(0),
|
|
run_nesting_level_(0),
|
|
deepest_nesting_level_(0),
|
|
delegateless_work_(false),
|
|
delegateless_delayed_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);
|
|
CFRunLoopAddTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
|
|
|
|
CFRunLoopSourceContext source_context = CFRunLoopSourceContext();
|
|
source_context.info = this;
|
|
source_context.perform = RunWorkSource;
|
|
work_source_ = CFRunLoopSourceCreate(NULL, // allocator
|
|
1, // priority
|
|
&source_context);
|
|
CFRunLoopAddSource(run_loop_, work_source_, kCFRunLoopCommonModes);
|
|
|
|
source_context.perform = RunDelayedWorkSource;
|
|
delayed_work_source_ = CFRunLoopSourceCreate(NULL, // allocator
|
|
2, // priority
|
|
&source_context);
|
|
CFRunLoopAddSource(run_loop_, delayed_work_source_, kCFRunLoopCommonModes);
|
|
|
|
source_context.perform = RunIdleWorkSource;
|
|
idle_work_source_ = CFRunLoopSourceCreate(NULL, // allocator
|
|
3, // priority
|
|
&source_context);
|
|
CFRunLoopAddSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
|
|
|
|
source_context.perform = RunNestingDeferredWorkSource;
|
|
nesting_deferred_work_source_ = CFRunLoopSourceCreate(NULL, // allocator
|
|
0, // priority
|
|
&source_context);
|
|
CFRunLoopAddSource(run_loop_, nesting_deferred_work_source_,
|
|
kCFRunLoopCommonModes);
|
|
|
|
CFRunLoopObserverContext observer_context = CFRunLoopObserverContext();
|
|
observer_context.info = this;
|
|
pre_wait_observer_ = CFRunLoopObserverCreate(NULL, // allocator
|
|
kCFRunLoopBeforeWaiting,
|
|
true, // repeat
|
|
0, // priority
|
|
PreWaitObserver,
|
|
&observer_context);
|
|
CFRunLoopAddObserver(run_loop_, pre_wait_observer_, kCFRunLoopCommonModes);
|
|
|
|
pre_source_observer_ = CFRunLoopObserverCreate(NULL, // allocator
|
|
kCFRunLoopBeforeSources,
|
|
true, // repeat
|
|
0, // priority
|
|
PreSourceObserver,
|
|
&observer_context);
|
|
CFRunLoopAddObserver(run_loop_, pre_source_observer_, kCFRunLoopCommonModes);
|
|
|
|
enter_exit_observer_ = CFRunLoopObserverCreate(NULL, // allocator
|
|
kCFRunLoopEntry |
|
|
kCFRunLoopExit,
|
|
true, // repeat
|
|
0, // priority
|
|
EnterExitObserver,
|
|
&observer_context);
|
|
CFRunLoopAddObserver(run_loop_, enter_exit_observer_, kCFRunLoopCommonModes);
|
|
|
|
root_power_domain_ = IORegisterForSystemPower(this,
|
|
&power_notification_port_,
|
|
PowerStateNotification,
|
|
&power_notification_object_);
|
|
if (root_power_domain_ != MACH_PORT_NULL) {
|
|
CFRunLoopAddSource(
|
|
run_loop_,
|
|
IONotificationPortGetRunLoopSource(power_notification_port_),
|
|
kCFRunLoopCommonModes);
|
|
}
|
|
}
|
|
|
|
// 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() {
|
|
if (root_power_domain_ != MACH_PORT_NULL) {
|
|
CFRunLoopRemoveSource(
|
|
run_loop_,
|
|
IONotificationPortGetRunLoopSource(power_notification_port_),
|
|
kCFRunLoopCommonModes);
|
|
IODeregisterForSystemPower(&power_notification_object_);
|
|
IOServiceClose(root_power_domain_);
|
|
IONotificationPortDestroy(power_notification_port_);
|
|
}
|
|
|
|
CFRunLoopRemoveObserver(run_loop_, enter_exit_observer_,
|
|
kCFRunLoopCommonModes);
|
|
CFRelease(enter_exit_observer_);
|
|
|
|
CFRunLoopRemoveObserver(run_loop_, pre_source_observer_,
|
|
kCFRunLoopCommonModes);
|
|
CFRelease(pre_source_observer_);
|
|
|
|
CFRunLoopRemoveObserver(run_loop_, pre_wait_observer_,
|
|
kCFRunLoopCommonModes);
|
|
CFRelease(pre_wait_observer_);
|
|
|
|
CFRunLoopRemoveSource(run_loop_, nesting_deferred_work_source_,
|
|
kCFRunLoopCommonModes);
|
|
CFRelease(nesting_deferred_work_source_);
|
|
|
|
CFRunLoopRemoveSource(run_loop_, idle_work_source_, kCFRunLoopCommonModes);
|
|
CFRelease(idle_work_source_);
|
|
|
|
CFRunLoopRemoveSource(run_loop_, delayed_work_source_, kCFRunLoopCommonModes);
|
|
CFRelease(delayed_work_source_);
|
|
|
|
CFRunLoopRemoveSource(run_loop_, work_source_, kCFRunLoopCommonModes);
|
|
CFRelease(work_source_);
|
|
|
|
CFRunLoopRemoveTimer(run_loop_, delayed_work_timer_, kCFRunLoopCommonModes);
|
|
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_;
|
|
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_delayed_work_) {
|
|
CFRunLoopSourceSignal(delayed_work_source_);
|
|
delegateless_delayed_work_ = false;
|
|
}
|
|
if (delegateless_idle_work_) {
|
|
CFRunLoopSourceSignal(idle_work_source_);
|
|
delegateless_idle_work_ = false;
|
|
}
|
|
}
|
|
|
|
DoRun(delegate);
|
|
|
|
// Restore the previous state of the object.
|
|
delegate_ = last_delegate;
|
|
run_nesting_level_ = last_run_nesting_level;
|
|
}
|
|
|
|
// May be called on any thread.
|
|
void MessagePumpCFRunLoopBase::ScheduleWork() {
|
|
CFRunLoopSourceSignal(work_source_);
|
|
CFRunLoopWakeUp(run_loop_);
|
|
}
|
|
|
|
// 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();
|
|
CFRunLoopTimerSetNextFireDate(delayed_work_timer_, delayed_work_fire_time_);
|
|
}
|
|
|
|
// 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;
|
|
|
|
// CFRunLoopTimers fire outside of the priority scheme for CFRunLoopSources.
|
|
// In order to establish the proper priority where delegate_->DoDelayedWork
|
|
// can only be called if delegate_->DoWork returns false, the timer used
|
|
// to schedule delayed work must signal a CFRunLoopSource set at a lower
|
|
// priority than the one used for delegate_->DoWork.
|
|
CFRunLoopSourceSignal(self->delayed_work_source_);
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::RunWorkSource(void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
self->RunWork();
|
|
}
|
|
|
|
// Called by MessagePumpCFRunLoopBase::RunWorkSource.
|
|
bool MessagePumpCFRunLoopBase::RunWork() {
|
|
if (!delegate_) {
|
|
// This point can be reached with a NULL delegate_ if Run is not on the
|
|
// stack but foreign code is spinning the CFRunLoop. Arrange to come back
|
|
// here when a delegate is available.
|
|
delegateless_work_ = true;
|
|
return false;
|
|
}
|
|
|
|
// The NSApplication-based run loop only drains the autorelease pool at each
|
|
// UI event (NSEvent). The autorelease pool is not drained for each
|
|
// CFRunLoopSource target that's run. Use a local pool for any autoreleased
|
|
// objects if the app is not currently handling a UI event to ensure they're
|
|
// released promptly even in the absence of UI events.
|
|
MessagePumpScopedAutoreleasePool autorelease_pool(this);
|
|
|
|
// Call DoWork once, and if something was done, arrange to come back here
|
|
// again as long as the loop is still running.
|
|
bool did_work = delegate_->DoWork();
|
|
if (did_work) {
|
|
CFRunLoopSourceSignal(work_source_);
|
|
}
|
|
|
|
return did_work;
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::RunDelayedWorkSource(void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
self->RunDelayedWork();
|
|
}
|
|
|
|
// Called by MessagePumpCFRunLoopBase::RunDelayedWorkSource.
|
|
bool MessagePumpCFRunLoopBase::RunDelayedWork() {
|
|
if (!delegate_) {
|
|
// This point can be reached with a NULL delegate_ if Run is not on the
|
|
// stack but foreign code is spinning the CFRunLoop. Arrange to come back
|
|
// here when a delegate is available.
|
|
delegateless_delayed_work_ = true;
|
|
return false;
|
|
}
|
|
|
|
// The NSApplication-based run loop only drains the autorelease pool at each
|
|
// UI event (NSEvent). The autorelease pool is not drained for each
|
|
// CFRunLoopSource target that's run. Use a local pool for any autoreleased
|
|
// objects if the app is not currently handling a UI event to ensure they're
|
|
// released promptly even in the absence of UI events.
|
|
MessagePumpScopedAutoreleasePool autorelease_pool(this);
|
|
|
|
TimeTicks next_time;
|
|
delegate_->DoDelayedWork(&next_time);
|
|
|
|
bool more_work = !next_time.is_null();
|
|
if (more_work) {
|
|
TimeDelta delay = next_time - TimeTicks::Now();
|
|
if (delay > TimeDelta()) {
|
|
// There's more delayed work to be done in the future.
|
|
ScheduleDelayedWork(next_time);
|
|
} else {
|
|
// There's more delayed work to be done, and its time is in the past.
|
|
// Arrange to come back here directly as long as the loop is still
|
|
// running.
|
|
CFRunLoopSourceSignal(delayed_work_source_);
|
|
}
|
|
}
|
|
|
|
return more_work;
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::RunIdleWorkSource(void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
self->RunIdleWork();
|
|
}
|
|
|
|
// Called by MessagePumpCFRunLoopBase::RunIdleWorkSource.
|
|
bool MessagePumpCFRunLoopBase::RunIdleWork() {
|
|
if (!delegate_) {
|
|
// This point can be reached with a NULL delegate_ if Run is not on the
|
|
// stack but foreign code is spinning the CFRunLoop. Arrange to come back
|
|
// here when a delegate is available.
|
|
delegateless_idle_work_ = true;
|
|
return false;
|
|
}
|
|
|
|
// The NSApplication-based run loop only drains the autorelease pool at each
|
|
// UI event (NSEvent). The autorelease pool is not drained for each
|
|
// CFRunLoopSource target that's run. Use a local pool for any autoreleased
|
|
// objects if the app is not currently handling a UI event to ensure they're
|
|
// released promptly even in the absence of UI events.
|
|
MessagePumpScopedAutoreleasePool autorelease_pool(this);
|
|
|
|
// Call DoIdleWork once, and if something was done, arrange to come back here
|
|
// again as long as the loop is still running.
|
|
bool did_work = delegate_->DoIdleWork();
|
|
if (did_work) {
|
|
CFRunLoopSourceSignal(idle_work_source_);
|
|
}
|
|
|
|
return did_work;
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource(void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
self->RunNestingDeferredWork();
|
|
}
|
|
|
|
// Called by MessagePumpCFRunLoopBase::RunNestingDeferredWorkSource.
|
|
bool MessagePumpCFRunLoopBase::RunNestingDeferredWork() {
|
|
if (!delegate_) {
|
|
// This point can be reached with a NULL delegate_ if Run is not on the
|
|
// stack but foreign code is spinning the CFRunLoop. There's no sense in
|
|
// attempting to do any work or signalling the work sources because
|
|
// without a delegate, work is not possible.
|
|
return false;
|
|
}
|
|
|
|
// Immediately try work in priority order.
|
|
if (!RunWork()) {
|
|
if (!RunDelayedWork()) {
|
|
if (!RunIdleWork()) {
|
|
return false;
|
|
}
|
|
} else {
|
|
// There was no work, and delayed work was done. Arrange for the loop
|
|
// to try non-nestable idle work on a subsequent pass.
|
|
CFRunLoopSourceSignal(idle_work_source_);
|
|
}
|
|
} else {
|
|
// Work was done. Arrange for the loop to try non-nestable delayed and
|
|
// idle work on a subsequent pass.
|
|
CFRunLoopSourceSignal(delayed_work_source_);
|
|
CFRunLoopSourceSignal(idle_work_source_);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Called before the run loop goes to sleep or exits, or processes sources.
|
|
void MessagePumpCFRunLoopBase::MaybeScheduleNestingDeferredWork() {
|
|
// deepest_nesting_level_ is set as run loops are entered. If the deepest
|
|
// level encountered is deeper than the current level, a nested loop
|
|
// (relative to the current level) ran since the last time nesting-deferred
|
|
// work was scheduled. When that situation is encountered, schedule
|
|
// nesting-deferred work in case any work was deferred because nested work
|
|
// was disallowed.
|
|
if (deepest_nesting_level_ > nesting_level_) {
|
|
deepest_nesting_level_ = nesting_level_;
|
|
CFRunLoopSourceSignal(nesting_deferred_work_source_);
|
|
}
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::PreWaitObserver(CFRunLoopObserverRef observer,
|
|
CFRunLoopActivity activity,
|
|
void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
|
|
// Attempt to do some idle work before going to sleep.
|
|
self->RunIdleWork();
|
|
|
|
// The run loop is about to go to sleep. If any of the work done since it
|
|
// started or woke up resulted in a nested run loop running,
|
|
// nesting-deferred work may have accumulated. Schedule it for processing
|
|
// if appropriate.
|
|
self->MaybeScheduleNestingDeferredWork();
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::PreSourceObserver(CFRunLoopObserverRef observer,
|
|
CFRunLoopActivity activity,
|
|
void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
|
|
// The run loop has reached the top of the loop and is about to begin
|
|
// processing sources. If the last iteration of the loop at this nesting
|
|
// level did not sleep or exit, nesting-deferred work may have accumulated
|
|
// if a nested loop ran. Schedule nesting-deferred work for processing if
|
|
// appropriate.
|
|
self->MaybeScheduleNestingDeferredWork();
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::EnterExitObserver(CFRunLoopObserverRef observer,
|
|
CFRunLoopActivity activity,
|
|
void* info) {
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
|
|
switch (activity) {
|
|
case kCFRunLoopEntry:
|
|
++self->nesting_level_;
|
|
if (self->nesting_level_ > self->deepest_nesting_level_) {
|
|
self->deepest_nesting_level_ = self->nesting_level_;
|
|
}
|
|
break;
|
|
|
|
case kCFRunLoopExit:
|
|
// Not all run loops go to sleep. If a run loop is stopped before it
|
|
// goes to sleep due to a CFRunLoopStop call, or if the timeout passed
|
|
// to CFRunLoopRunInMode expires, the run loop may proceed directly from
|
|
// handling sources to exiting without any sleep. This most commonly
|
|
// occurs when CFRunLoopRunInMode is passed a timeout of 0, causing it
|
|
// to make a single pass through the loop and exit without sleep. Some
|
|
// native loops use CFRunLoop in this way. Because PreWaitObserver will
|
|
// not be called in these case, MaybeScheduleNestingDeferredWork needs
|
|
// to be called here, as the run loop exits.
|
|
//
|
|
// MaybeScheduleNestingDeferredWork consults self->nesting_level_
|
|
// to determine whether to schedule nesting-deferred work. It expects
|
|
// the nesting level to be set to the depth of the loop that is going
|
|
// to sleep or exiting. It must be called before decrementing the
|
|
// value so that the value still corresponds to the level of the exiting
|
|
// loop.
|
|
self->MaybeScheduleNestingDeferredWork();
|
|
--self->nesting_level_;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
self->EnterExitRunLoop(activity);
|
|
}
|
|
|
|
// Called from the run loop.
|
|
// static
|
|
void MessagePumpCFRunLoopBase::PowerStateNotification(void* info,
|
|
io_service_t service,
|
|
uint32_t message_type,
|
|
void* message_argument) {
|
|
// CFRunLoopTimer (NSTimer) is scheduled in terms of CFAbsoluteTime, which
|
|
// measures the number of seconds since 2001-01-01 00:00:00.0 Z. It is
|
|
// implemented in terms of kernel ticks, as in mach_absolute_time. While an
|
|
// offset and scale factor can be applied to convert between the two time
|
|
// bases at any time after boot, the kernel clock stops while the system is
|
|
// asleep, altering the offset. (The offset will also change when the
|
|
// real-time clock is adjusted.) CFRunLoopTimers are not readjusted to take
|
|
// this into account when the system wakes up, so any timers that were
|
|
// pending while the system was asleep will be delayed by the sleep
|
|
// duration.
|
|
//
|
|
// The MessagePump interface assumes that scheduled delayed work will be
|
|
// performed at the time ScheduleDelayedWork was asked to perform it. The
|
|
// delay caused by the CFRunLoopTimer not firing at the appropriate time
|
|
// results in a stall of queued delayed work when the system wakes up.
|
|
// With this limitation, scheduled work would not be performed until
|
|
// (system wake time + scheduled work time - system sleep time), while it
|
|
// would be expected to be performed at (scheduled work time).
|
|
//
|
|
// To work around this problem, when the system wakes up from sleep, if a
|
|
// delayed work timer is pending, it is rescheduled to fire at the original
|
|
// time that it was scheduled to fire.
|
|
//
|
|
// This mechanism is not resilient if the real-time clock does not maintain
|
|
// stable time while the system is sleeping, but it matches the behavior of
|
|
// the various other MessagePump implementations, and MessageLoop seems to
|
|
// be limited in the same way.
|
|
//
|
|
// References
|
|
// - Chris Kane, "NSTimer and deep sleep," cocoa-dev@lists.apple.com,
|
|
// http://lists.apple.com/archives/Cocoa-dev/2002/May/msg01547.html
|
|
// - Apple Technical Q&A QA1340, "Registering and unregistering for sleep
|
|
// and wake notifications,"
|
|
// http://developer.apple.com/mac/library/qa/qa2004/qa1340.html
|
|
// - Core Foundation source code, CF-550/CFRunLoop.c and CF-550/CFDate.c,
|
|
// http://www.opensource.apple.com/
|
|
|
|
MessagePumpCFRunLoopBase* self = static_cast<MessagePumpCFRunLoopBase*>(info);
|
|
|
|
switch (message_type) {
|
|
case kIOMessageSystemWillPowerOn:
|
|
if (self->delayed_work_fire_time_ != kCFTimeIntervalMax) {
|
|
CFRunLoopTimerSetNextFireDate(self->delayed_work_timer_,
|
|
self->delayed_work_fire_time_);
|
|
}
|
|
break;
|
|
|
|
case kIOMessageSystemWillSleep:
|
|
case kIOMessageCanSystemSleep:
|
|
// The system will wait for 30 seconds before entering sleep if neither
|
|
// IOAllowPowerChange nor IOCancelPowerChange are called. That would be
|
|
// pretty antisocial.
|
|
IOAllowPowerChange(self->root_power_domain_,
|
|
reinterpret_cast<long>(message_argument));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Called by MessagePumpCFRunLoopBase::EnterExitRunLoop. The default
|
|
// implementation is a no-op.
|
|
void MessagePumpCFRunLoopBase::EnterExitRunLoop(CFRunLoopActivity activity) {
|
|
}
|
|
|
|
// Base version returns a standard NSAutoreleasePool.
|
|
NSAutoreleasePool* MessagePumpCFRunLoopBase::CreateAutoreleasePool() {
|
|
return [[NSAutoreleasePool alloc] init];
|
|
}
|
|
|
|
MessagePumpCFRunLoop::MessagePumpCFRunLoop()
|
|
: quit_pending_(false) {
|
|
}
|
|
|
|
// 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.
|
|
int result;
|
|
do {
|
|
MessagePumpScopedAutoreleasePool autorelease_pool(this);
|
|
result = CFRunLoopRunInMode(kCFRunLoopDefaultMode,
|
|
kCFTimeIntervalMax,
|
|
false);
|
|
} while (result != kCFRunLoopRunStopped && result != kCFRunLoopRunFinished);
|
|
}
|
|
|
|
// Must be called on the run loop thread.
|
|
void MessagePumpCFRunLoop::Quit() {
|
|
// Stop the innermost run loop managed by this MessagePumpCFRunLoop object.
|
|
if (nesting_level() == run_nesting_level()) {
|
|
// This object is running the innermost loop, just stop it.
|
|
CFRunLoopStop(run_loop());
|
|
} else {
|
|
// There's another loop running inside the loop managed by this object.
|
|
// In other words, someone else called CFRunLoopRunInMode on the same
|
|
// thread, deeper on the stack than the deepest Run call. Don't preempt
|
|
// other run loops, just mark this object to quit the innermost Run as
|
|
// soon as the other inner loops not managed by Run are done.
|
|
quit_pending_ = true;
|
|
}
|
|
}
|
|
|
|
// Called by MessagePumpCFRunLoopBase::EnterExitObserver.
|
|
void MessagePumpCFRunLoop::EnterExitRunLoop(CFRunLoopActivity activity) {
|
|
if (activity == kCFRunLoopExit &&
|
|
nesting_level() == run_nesting_level() &&
|
|
quit_pending_) {
|
|
// 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) {
|
|
CFRunLoopSourceContext source_context = CFRunLoopSourceContext();
|
|
source_context.perform = NoOp;
|
|
quit_source_ = CFRunLoopSourceCreate(NULL, // allocator
|
|
0, // priority
|
|
&source_context);
|
|
CFRunLoopAddSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
|
|
}
|
|
|
|
MessagePumpNSRunLoop::~MessagePumpNSRunLoop() {
|
|
CFRunLoopRemoveSource(run_loop(), quit_source_, kCFRunLoopCommonModes);
|
|
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());
|
|
}
|
|
|
|
MessagePumpNSApplication::MessagePumpNSApplication()
|
|
: keep_running_(true),
|
|
running_own_loop_(false) {
|
|
}
|
|
|
|
void MessagePumpNSApplication::DoRun(Delegate* delegate) {
|
|
bool last_running_own_loop_ = running_own_loop_;
|
|
|
|
// TODO(dmaclach): Get rid of this gratuitous sharedApplication.
|
|
// Tests should be setting up their applications on their own.
|
|
//[CrApplication sharedApplication];
|
|
|
|
if (![NSApp isRunning]) {
|
|
running_own_loop_ = false;
|
|
// NSApplication manages autorelease pools itself when run this way.
|
|
[NSApp run];
|
|
} else {
|
|
running_own_loop_ = true;
|
|
NSDate* distant_future = [NSDate distantFuture];
|
|
while (keep_running_) {
|
|
MessagePumpScopedAutoreleasePool autorelease_pool(this);
|
|
NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
|
|
untilDate:distant_future
|
|
inMode:NSDefaultRunLoopMode
|
|
dequeue:YES];
|
|
if (event) {
|
|
[NSApp sendEvent:event];
|
|
}
|
|
}
|
|
keep_running_ = true;
|
|
}
|
|
|
|
running_own_loop_ = last_running_own_loop_;
|
|
}
|
|
|
|
void MessagePumpNSApplication::Quit() {
|
|
if (!running_own_loop_) {
|
|
[NSApp stop:nil];
|
|
} else {
|
|
keep_running_ = false;
|
|
}
|
|
|
|
// Send a fake event to wake the loop up.
|
|
[NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined
|
|
location:NSMakePoint(0, 0)
|
|
modifierFlags:0
|
|
timestamp:0
|
|
windowNumber:0
|
|
context:NULL
|
|
subtype:0
|
|
data1:0
|
|
data2:0]
|
|
atStart:NO];
|
|
}
|
|
|
|
// Prevents an autorelease pool from being created if the app is in the midst of
|
|
// handling a UI event because various parts of AppKit depend on objects that
|
|
// are created while handling a UI event to be autoreleased in the event loop.
|
|
// An example of this is NSWindowController. When a window with a window
|
|
// controller is closed it goes through a stack like this:
|
|
// (Several stack frames elided for clarity)
|
|
//
|
|
// #0 [NSWindowController autorelease]
|
|
// #1 DoAClose
|
|
// #2 MessagePumpCFRunLoopBase::DoWork()
|
|
// #3 [NSRunLoop run]
|
|
// #4 [NSButton performClick:]
|
|
// #5 [NSWindow sendEvent:]
|
|
// #6 [NSApp sendEvent:]
|
|
// #7 [NSApp run]
|
|
//
|
|
// -performClick: spins a nested run loop. If the pool created in DoWork was a
|
|
// standard NSAutoreleasePool, it would release the objects that were
|
|
// autoreleased into it once DoWork released it. This would cause the window
|
|
// controller, which autoreleased itself in frame #0, to release itself, and
|
|
// possibly free itself. Unfortunately this window controller controls the
|
|
// window in frame #5. When the stack is unwound to frame #5, the window would
|
|
// no longer exists and crashes may occur. Apple gets around this by never
|
|
// releasing the pool it creates in frame #4, and letting frame #7 clean it up
|
|
// when it cleans up the pool that wraps frame #7. When an autorelease pool is
|
|
// released it releases all other pools that were created after it on the
|
|
// autorelease pool stack.
|
|
//
|
|
// CrApplication is responsible for setting handlingSendEvent to true just
|
|
// before it sends the event throught the event handling mechanism, and
|
|
// returning it to its previous value once the event has been sent.
|
|
NSAutoreleasePool* MessagePumpNSApplication::CreateAutoreleasePool() {
|
|
#if(0)
|
|
NSAutoreleasePool* pool = nil;
|
|
DCHECK([NSApp isKindOfClass:[CrApplication class]]);
|
|
if (![static_cast<CrApplication*>(NSApp) isHandlingSendEvent]) {
|
|
pool = MessagePumpCFRunLoopBase::CreateAutoreleasePool();
|
|
}
|
|
return pool;
|
|
#else
|
|
perror("MessagePumpNSApplication::CreateAutoreleasePool: crash imminent");
|
|
return nil;
|
|
#endif
|
|
}
|
|
|
|
// static
|
|
// 10.4 does not have isMainThread, so we simulate it, assuming that the
|
|
// first thread through will be the main thread, and then others will not.
|
|
MessagePump* MessagePumpMac::Create() {
|
|
static int threads_created = 0;
|
|
//if ([NSThread isMainThread]) {
|
|
if (!threads_created) {
|
|
threads_created++;
|
|
return new MessagePumpNSApplication;
|
|
}
|
|
|
|
return new MessagePumpNSRunLoop;
|
|
}
|
|
|
|
} // namespace base
|