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 61 matching lines @@
 
 int64 CurrentWallclockMicroseconds() {
   FILETIME ft;
   ::GetSystemTimeAsFileTime(&ft);
   return FileTimeToMicroseconds(ft);
 }
 
 // Time between resampling the un-granular clock for this API.  60 seconds.
 const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond;
 
+base::Lock initialize_clock_lock;

[jar (doing other things), 2014/08/15 17:40:39]

nit: We're not allowed to have such items at global scope (re: they are not
POD).  You need to use a singleton construct, and you are allowed to have them
at global scope.  This will ensure that the lock is initialized before use, and
will be relatively efficient in the "fast path" later in the program's lifetime.
 It would IMO be fine to use leaky lazy singleton, and leak the lock at process
termination.

[fmeawad, 2014/08/15 21:50:50]

I copied the lock from rollover_lock in the same file, and I added a comment on
why to use it in this patch.

I would be happy to use the leaky lazy singleton if you think it is still
needed.

 int64 initial_time = 0;
 TimeTicks initial_ticks;
 
 void InitializeClock() {
+  base::AutoLock locked(initialize_clock_lock);
   initial_ticks = TimeTicks::Now();
   initial_time = CurrentWallclockMicroseconds();
 }
 
 }  // namespace
 
 // 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
@@ skipping 16 matching lines @@
   //
   // To make this work, we initialize the clock (initial_time) and the
   // counter (initial_ctr).  To compute the initial time, we can check
   // the number of ticks that have elapsed, and compute the delta.
   //
   // To avoid any drift, we periodically resync the counters to the system
   // clock.
   while (true) {
     TimeTicks ticks = TimeTicks::Now();
 
+    int64 start_time = 0;
+    TimeTicks start_ticks;
+    {
+        base::AutoLock locked(initialize_clock_lock);
+        start_time = initial_time;
+        start_ticks = initial_ticks;
+    }
+
     // Calculate the time elapsed since we started our timer
-    TimeDelta elapsed = ticks - initial_ticks;
+    TimeDelta elapsed = ticks - start_ticks;
 
     // Check if enough time has elapsed that we need to resync the clock.
     if (elapsed.InMilliseconds() > kMaxMillisecondsToAvoidDrift) {
       InitializeClock();
       continue;
     }
 
-    return Time(elapsed + Time(initial_time));
+    return Time(elapsed + Time(start_time));
   }
 }
 
 // static
 Time Time::NowFromSystemTime() {
   // Force resync.
   InitializeClock();
   return Time(initial_time);
 }
 
@@ skipping 210 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();
@@ skipping 42 matching lines @@
   return old;
 }
 
 // static
 bool TimeTicks::SetNowIsHighResNowIfSupported() {
   if (!CPUReliablySupportsHighResTime()) {
     return false;
   }
 
   now_function = HighResNowWrapper;
+  InitializeClock();
   return true;
 }
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + now_function();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
@@ skipping 38 matching lines @@
     return TimeTicks() + TimeDelta::FromMilliseconds(timeGetTime());
   }
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return TimeDelta(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
 }