Reset the Mac message pump's delayed work timer upon waking from system sleep

base/message_pump_mac.mm

 // 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>
 
 #include "base/scoped_nsautorelease_pool.h"
 #include "base/time.h"
 
 namespace {
 
 void NoOp(void* info) {
 }
 
 const CFTimeInterval kCFTimeIntervalMax =
     std::numeric_limits<CFTimeInterval>::max();
 
 }  // namespace
 
 namespace base {
 
 // 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
@@ skipping 56 matching lines @@
   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);
@@ skipping 69 matching lines @@
                                         Time::kMicrosecondsPerSecond) /
                     Time::kMicrosecondsPerSecond);
   CFGregorianDate gregorian = {
     exploded.year,
     exploded.month,
     exploded.day_of_month,
     exploded.hour,
     exploded.minute,
     seconds
   };
-  CFAbsoluteTime fire_time = CFGregorianDateGetAbsoluteTime(gregorian, NULL);
+  delayed_work_fire_time_ = CFGregorianDateGetAbsoluteTime(gregorian, NULL);
 
-  CFRunLoopTimerSetNextFireDate(delayed_work_timer_, fire_time);
+  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
@@ skipping 198 matching lines @@
                                                  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
+
+  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) {
 }
 
 MessagePumpCFRunLoop::MessagePumpCFRunLoop()
     : quit_pending_(false) {
 }
 
 // Called by MessagePumpCFRunLoopBase::DoRun.  If other CFRunLoopRun loops were
@@ skipping 129 matching lines @@
 // static
 MessagePump* MessagePumpMac::Create() {
   if ([NSThread isMainThread]) {
     return new MessagePumpNSApplication;
   }
 
   return new MessagePumpNSRunLoop;
 }
 
 }  // namespace base