High resolution timer fix for Windows

base/message_loop/message_pump_win.cc

 // 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.
 
 #include "base/message_loop/message_pump_win.h"
 
 #include <math.h>
 
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 251 matching lines @@
   DCHECK(message_hwnd_);
 }
 
 void MessagePumpForUI::WaitForWork() {
   // Wait until a message is available, up to the time needed by the timer
   // manager to fire the next set of timers.
   int delay = GetCurrentDelay();
   if (delay < 0)  // Negative value means no timers waiting.
     delay = INFINITE;
 
+  // The delegate will crank the systemwide timer resolution if needed.
+  // Note that the |delay| value is not enough of an indicator if we need to
+  // to so. For example, imagine a 30 seconds delayed task that we only get
+  // arround to service 5ms before the deadline. Should we crank up the
+  // systemwide timer? no. A 30s timer can be fired 15ms later.
+  state_->delegate->UpdateTimerGranularity();
+
   DWORD result;
   result = MsgWaitForMultipleObjectsEx(0, NULL, delay, QS_ALLINPUT,
                                        MWMO_INPUTAVAILABLE);
 
   if (WAIT_OBJECT_0 == result) {
     // A WM_* message is available.
     // If a parent child relationship exists between windows across threads
     // then their thread inputs are implicitly attached.
     // This causes the MsgWaitForMultipleObjectsEx API to return indicating
     // that messages are ready for processing (Specifically, mouse messages
@@ skipping 240 matching lines @@
   }
 }
 
 // Wait until IO completes, up to the time needed by the timer manager to fire
 // the next set of timers.
 void MessagePumpForIO::WaitForWork() {
   // We do not support nested IO message loops. This is to avoid messy
   // recursion problems.
   DCHECK_EQ(1, state_->run_depth) << "Cannot nest an IO message loop!";
 
+  // See the comment in MessagePumpForUI::WaitForWork().
+  state_->delegate->UpdateTimerGranularity();
+
   int timeout = GetCurrentDelay();
   if (timeout < 0)  // Negative value means no timers waiting.
     timeout = INFINITE;
 
   WaitForIOCompletion(timeout, NULL);
 }
 
 bool MessagePumpForIO::WaitForIOCompletion(DWORD timeout, IOHandler* filter) {
   IOItem item;
   if (completed_io_.empty() || !MatchCompletedIOItem(filter, &item)) {
@@ skipping 104 matching lines @@
 
 // static
 MessagePumpForIO::IOHandler* MessagePumpForIO::KeyToHandler(
     ULONG_PTR key,
     bool* has_valid_io_context) {
   *has_valid_io_context = ((key & 1) == 0);
   return reinterpret_cast<IOHandler*>(key & ~static_cast<ULONG_PTR>(1));
 }
 
 }  // namespace base