Change chrome from statically enabling high resolution timers on windows...

base/time_win.cc

 // Copyright (c) 2009 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.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 80 matching lines @@
 
 // Time -----------------------------------------------------------------------
 
 // The internal representation of Time uses FILETIME, whose epoch is 1601-01-01
 // 00:00:00 UTC.  ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the
 // number of leap year days between 1601 and 1970: (1970-1601)/4 excluding
 // 1700, 1800, and 1900.
 // static
 const int64 Time::kTimeTToMicrosecondsOffset = GG_INT64_C(11644473600000000);
 
+bool Time::high_resolution_timer_enabled_ = false;
+
 // static
 Time Time::Now() {
   if (initial_time == 0)
     InitializeClock();
 
   // We implement time using the high-resolution timers so that we can get
   // timeouts which are smaller than 10-15ms.  If we just used
   // CurrentWallclockMicroseconds(), we'd have the less-granular timer.
   //
   // To make this work, we initialize the clock (initial_time) and the
@@ skipping 30 matching lines @@
   return Time(FileTimeToMicroseconds(ft));
 }
 
 FILETIME Time::ToFileTime() const {
   FILETIME utc_ft;
   MicrosecondsToFileTime(us_, &utc_ft);
   return utc_ft;
 }
 
 // static
-bool Time::UseHighResolutionTimer(bool use) {
-  // TODO(mbelshe): Make sure that switching the system timer resolution
-  // doesn't break Timer firing order etc. An example test would be to have
-  // two threads. One would have a bunch of timers, and another would turn the
-  // high resolution timer on and off.
+void Time::EnableHighResolutionTimer(bool enable) {
+  // Test for single-threaded access.
+  static PlatformThreadId my_thread = PlatformThread::CurrentId();
+  DCHECK(PlatformThread::CurrentId() == my_thread);
 
-  MMRESULT result;
-  if (use)
-    result = timeBeginPeriod(1);
-  else
-    result = timeEndPeriod(1);
-  return (result == TIMERR_NOERROR);
+  if (high_resolution_timer_enabled_ == enable)
+    return;
+
+  high_resolution_timer_enabled_ = enable;
 }
 
 // static
+bool Time::ActivateHighResolutionTimer(bool activate) {
+  if (!high_resolution_timer_enabled_)
+    return false;
+
+  // Using anything other than 1ms makes timers granular
+  // to that interval.
+  const int kMinTimerIntervalMs = 1;
+  MMRESULT result;
+  if (activate)
+    result = timeBeginPeriod(kMinTimerIntervalMs);
+  else
+    result = timeEndPeriod(kMinTimerIntervalMs);
+  return result == TIMERR_NOERROR;
+}
+
+// static
 Time Time::FromExploded(bool is_local, const Exploded& exploded) {
   // Create the system struct representing our exploded time. It will either be
   // in local time or UTC.
   SYSTEMTIME st;
   st.wYear = exploded.year;
   st.wMonth = exploded.month;
   st.wDayOfWeek = exploded.day_of_week;
   st.wDay = exploded.day_of_month;
   st.wHour = exploded.hour;
   st.wMinute = exploded.minute;
@@ skipping 200 matching lines @@
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + RolloverProtectedNow();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
   return TimeTicks() + Singleton<HighResNowSingleton>::get()->Now();
 }