High resolution timer fix for Windows

base/message_loop/message_pump.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_PUMP_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_H_
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/message_loop/timer_slack.h"
@@ skipping 23 matching lines @@
     // if DoDelayedWork returns true.  Upon return |next_delayed_work_time|
     // indicates the time when DoDelayedWork should be called again.  If
     // |next_delayed_work_time| is null (per Time::is_null), then the queue of
     // future delayed work (timer events) is currently empty, and no additional
     // calls to this function need to be scheduled.
     virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) = 0;
 
     // Called from within Run just before the message pump goes to sleep.
     // Returns true to indicate that idle work was done.
     virtual bool DoIdleWork() = 0;
+
+    // Called when the pump is about to sleep. The delegate should update the
+    // timer granularity to the appropriate value for the pending tasks.
+    virtual void UpdateTimerGranularity() {}

[darin (slow to review), 2014/07/18 04:07:59]

why don't you just use DoIdleWork for this? it is always called before sleeping.

[jamesr, 2014/07/18 04:45:37]

it's also called before not sleeping (i.e. we have an idle work task that posts
more tasks) and we really should only do this when we're really about to sleep.
we could do it in MessageLoop::DoIdleWork just before returning false, but imho
that ties this a little too deeply to how the pump works. updating the
granularity changes the behavior of the sleep call so i like having it be as
close to possible as the sleep call

[darin (slow to review), 2014/07/18 04:55:54]

I don't think that's quite right. In that case, DoIdleWork returns true,
and we avoid waiting at all. We always completely drain the work queue of
work that can be done before sleeping, and if we do any work, then we
assume we could plausibly have more work to do.
^^^ Yes, just before returning false seems like the right time.
I don't think it is tying us too closely. Looking at the comment for
DoIdleWork, it seems to describe exactly what we are looking for here...
notification that the pump is about to sleep. The comment describing
UpdateTimerGranularity says almost exactly the same thing.

[jamesr, 2014/07/18 06:18:33]

Good points.  I agree doing this at the end of DoIdleWork() would be better.

   };
 
   MessagePump();
   virtual ~MessagePump();
 
   // The Run method is called to enter the message pump's run loop.
   //
   // Within the method, the message pump is responsible for processing native
   // messages as well as for giving cycles to the delegate periodically.  The
   // message pump should take care to mix delegate callbacks with native
@@ skipping 68 matching lines @@
   // used on the thread that called Run.
   virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time) = 0;
 
   // Sets the timer slack to the specified value.
   virtual void SetTimerSlack(TimerSlack timer_slack);
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_PUMP_H_