Fix regression where high resolution timers could be activated even under...

base/message_loop.cc

 // Copyright (c) 2010 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.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 161 matching lines @@
     ReloadWorkQueue();
     // If we end up with empty queues, then break out of the loop.
     did_work = DeletePendingTasks();
     if (!did_work)
       break;
   }
   DCHECK(!did_work);
 
   // OK, now make it so that no one can find us.
   lazy_tls_ptr.Pointer()->Set(NULL);
+
+#if defined(OS_WIN)
+  // If we left the high-resolution timer activated, deactivate it now.
+  // Doing this is not-critical, it is mainly to make sure we track
+  // the high resolution timer activations properly in our unit tests.
+  if (!high_resolution_timer_expiration_.is_null()) {
+    Time::ActivateHighResolutionTimer(false);
+    high_resolution_timer_expiration_ = base::TimeTicks();
+  }
+#endif
 }
 
 void MessageLoop::AddDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK(this == current());
   destruction_observers_.AddObserver(destruction_observer);
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
@@ skipping 138 matching lines @@
 #if defined(OS_WIN)
     if (high_resolution_timer_expiration_.is_null()) {
       // Windows timers are granular to 15.6ms.  If we only set high-res
       // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms,
       // which as a percentage is pretty inaccurate.  So enable high
       // res timers for any timer which is within 2x of the granularity.
       // This is a tradeoff between accuracy and power management.
       bool needs_high_res_timers =
           delay_ms < (2 * Time::kMinLowResolutionThresholdMs);
       if (needs_high_res_timers) {
-        Time::ActivateHighResolutionTimer(true);
-        high_resolution_timer_expiration_ = base::TimeTicks::Now() +
-            TimeDelta::FromMilliseconds(kHighResolutionTimerModeLeaseTimeMs);
+        if (Time::ActivateHighResolutionTimer(true)) {
+          high_resolution_timer_expiration_ = base::TimeTicks::Now() +
+              TimeDelta::FromMilliseconds(kHighResolutionTimerModeLeaseTimeMs);
+        }
       }
     }
 #endif
   } else {
     DCHECK_EQ(delay_ms, 0) << "delay should not be negative";
   }
 
 #if defined(OS_WIN)
   if (!high_resolution_timer_expiration_.is_null()) {
     if (base::TimeTicks::Now() > high_resolution_timer_expiration_) {

[jar (doing other things), 2010/10/20 00:37:19]

This will work.... but for all your effort to avoid taking a lock, Now() will
take a lock :-/. 

It would be better to put this down in the timer event handling code, but that
is a more complex change :-(.  I'm working on such a change (for other
appearances of Now() in the message loop), and that should probably be enhanced
to include this "timer event" (or perhaps we should post a delayed event to
handle this, and let it go down the standard track).

       Time::ActivateHighResolutionTimer(false);
       high_resolution_timer_expiration_ = base::TimeTicks();
     }
   }
 #endif
 
   // Warning: Don't try to short-circuit, and handle this thread's tasks more
   // directly, as it could starve handling of foreign threads.  Put every task
   // into this queue.
 
@@ skipping 317 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif