Initialize the now_funciton to the HighResNowWrapper in case High Res is supported

base/time/time_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.
 
 
 // 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 341 matching lines @@
 // reality due to bugs in BIOS or HAL on some, especially old computers.
 // With recent updates on HAL and newer BIOS, QPC is getting more reliable but
 // it should be used with caution.
 //
 // (3) System time. The system time provides a low-resolution (typically 10ms
 // to 55 milliseconds) time stamp but is comparatively less expensive to
 // retrieve and more reliable.
 class HighResNowSingleton {
  public:
   HighResNowSingleton()
-    : ticks_per_second_(0),
-      skew_(0) {
-    InitializeClock();
+      : ticks_per_second_(0),
+        skew_(0) {
 
     base::CPU cpu;
     if (IsBuggyAthlon(cpu))
-      DisableHighResClock();
+      return;
+
+    // Synchronize the QPC clock with GetSystemTimeAsFileTime.
+    LARGE_INTEGER ticks_per_sec = {0};
+    if (!QueryPerformanceFrequency(&ticks_per_sec))
+      return; // QPC is not available.
+    ticks_per_second_ = ticks_per_sec.QuadPart;
+
+    skew_ = UnreliableNow() - ReliableNow();
   }
 
   bool IsUsingHighResClock() {
-    return ticks_per_second_ != 0.0;
-  }
-
-  void DisableHighResClock() {
-    ticks_per_second_ = 0.0;
+    return ticks_per_second_ != 0;
   }
 
   TimeDelta Now() {
     if (IsUsingHighResClock())
       return TimeDelta::FromMicroseconds(UnreliableNow());
 
     // Just fallback to the slower clock.
     return RolloverProtectedNow();
   }
 
@@ skipping 14 matching lines @@
     // overflow and precision issues.
     int64 whole_seconds = qpc_value / ticks_per_second_;
     int64 leftover_ticks = qpc_value - (whole_seconds * ticks_per_second_);
     int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) +
                          ((leftover_ticks * Time::kMicrosecondsPerSecond) /
                           ticks_per_second_);
     return microseconds;
   }
 
  private:
-  // Synchronize the QPC clock with GetSystemTimeAsFileTime.
-  void InitializeClock() {
-    LARGE_INTEGER ticks_per_sec = {0};
-    if (!QueryPerformanceFrequency(&ticks_per_sec))
-      return;  // Broken, we don't guarantee this function works.
-    ticks_per_second_ = ticks_per_sec.QuadPart;
-
-    skew_ = UnreliableNow() - ReliableNow();
-  }
-
   // Get the number of microseconds since boot in an unreliable fashion.
   int64 UnreliableNow() {
     LARGE_INTEGER now;
     QueryPerformanceCounter(&now);
     return QPCValueToMicroseconds(now.QuadPart);
   }
 
   // Get the number of microseconds since boot in a reliable fashion.
   int64 ReliableNow() {
     return RolloverProtectedNow().InMicroseconds();
   }
 
   int64 ticks_per_second_;  // 0 indicates QPF failed and we're broken.
   int64 skew_;  // Skew between lo-res and hi-res clocks (for debugging).
 };
 
 static base::LazyInstance<HighResNowSingleton>::Leaky
     leaky_high_res_now_singleton = LAZY_INSTANCE_INITIALIZER;
 
 HighResNowSingleton* GetHighResNowSingleton() {
   return leaky_high_res_now_singleton.Pointer();
 }
 
 TimeDelta HighResNowWrapper() {
   return GetHighResNowSingleton()->Now();
 }
 
 typedef TimeDelta (*NowFunction)(void);
-NowFunction now_function = RolloverProtectedNow;
 
 bool CPUReliablySupportsHighResTime() {
   base::CPU cpu;
   if (!cpu.has_non_stop_time_stamp_counter() ||
       !GetHighResNowSingleton()->IsUsingHighResClock())
     return false;
 
   if (IsBuggyAthlon(cpu))
     return false;
 
   return true;
 }
 
+NowFunction GetNowFunction() {
+  if (!CPUReliablySupportsHighResTime())
+    return RolloverProtectedNow;
+  return HighResNowWrapper;
+}
+
+NowFunction now_function = GetNowFunction();

[willchan no longer on Chromium, 2014/08/25 23:07:25]

FYI: this results in a static initializer. This may slow down Windows Chrome
startup. You may want to use a function local static instead since it won't
create a static initializer. Of course, since we don't lock function local
static initialization, that will possibly lead to races, depending on how this
code gets run.

[M-A Ruel, 2014/08/26 02:03:19]

Furthermore, the static initializer is unneeded:

TimeDelta InitialNowFunction() {
  if (!CPUReliablySupportsHighResTime()) {
    InterlockedExchange(&now_function, RolloverProtectedNow);
    return RolloverProtectedNow();
  }
  InterlockedExchange(&now_function, HighResNowWrapper);
  return HighResNowWrapper();
}

NowFunction now_function = InitialNowFunction;

+
 }  // namespace
 
 // static
 TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
     TickFunctionType ticker) {
   base::AutoLock locked(rollover_lock);
   TickFunctionType old = tick_function;
   tick_function = ticker;
   rollover_ms = 0;
   last_seen_now = 0;
   return old;
 }
 
 // static
-bool TimeTicks::SetNowIsHighResNowIfSupported() {
-  if (!CPUReliablySupportsHighResTime()) {
-    return false;
-  }
-
-  now_function = HighResNowWrapper;
-  return true;
-}
-
-// static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + now_function();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
   return TimeTicks() + HighResNowWrapper();
 }
 
 // static
@@ skipping 34 matching lines @@
     return TimeTicks() + TimeDelta::FromMilliseconds(timeGetTime());
   }
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return TimeDelta(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
 }