Make HighResNowSingleton a leaky LazyInstance

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 24 matching lines @@
 // there is nothing else to waken the Wait.
 
 #include "base/time/time.h"
 
 #pragma comment(lib, "winmm.lib")
 #include <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/cpu.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 
 // From MSDN, FILETIME "Contains a 64-bit value representing the number of
 // 100-nanosecond intervals since January 1, 1601 (UTC)."
@@ skipping 294 matching lines @@
 // give consistent result on a multiprocessor computer, but it is unreliable in
 // 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:
-  static HighResNowSingleton* GetInstance() {
-    return Singleton<HighResNowSingleton>::get();
+  HighResNowSingleton()
+    : ticks_per_second_(0),
+      skew_(0) {
+    InitializeClock();
+
+    base::CPU cpu;
+    if (IsBuggyAthlon(cpu))
+      DisableHighResClock();
   }
 
   bool IsUsingHighResClock() {
     return ticks_per_second_ != 0.0;
   }
 
   void DisableHighResClock() {
     ticks_per_second_ = 0.0;
   }
 
@@ skipping 19 matching lines @@
     // overflow and precision issues. Think twice before simplifying!
     int64 whole_seconds = qpc_value / ticks_per_second_;
     int64 leftover_ticks = qpc_value % ticks_per_second_;
     int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) +
                          ((leftover_ticks * Time::kMicrosecondsPerSecond) /
                           ticks_per_second_);
     return microseconds;
   }
 
  private:
-  HighResNowSingleton()
-    : ticks_per_second_(0),
-      skew_(0) {
-    InitializeClock();
-
-    base::CPU cpu;
-    if (IsBuggyAthlon(cpu))
-      DisableHighResClock();
-  }
-
   // 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).
-
-  friend struct DefaultSingletonTraits<HighResNowSingleton>;
 };
 
+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 HighResNowSingleton::GetInstance()->Now();
+  return GetHighResNowSingleton()->Now();
 }
 
 typedef TimeDelta (*NowFunction)(void);
 NowFunction now_function = RolloverProtectedNow;
 
 bool CPUReliablySupportsHighResTime() {
   base::CPU cpu;
   if (!cpu.has_non_stop_time_stamp_counter())
     return false;
 
@@ skipping 26 matching lines @@
   return true;
 }
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + now_function();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
-  return TimeTicks() + HighResNowSingleton::GetInstance()->Now();
+  return TimeTicks() + HighResNowWrapper();
 }
 
 // static
 bool TimeTicks::IsHighResNowFastAndReliable() {
   return CPUReliablySupportsHighResTime();
 }
 
 // static
 TimeTicks TimeTicks::ThreadNow() {
   NOTREACHED();
   return TimeTicks();
 }
 
 // static
 TimeTicks TimeTicks::NowFromSystemTraceTime() {
   return HighResNow();
 }
 
 // static
 int64 TimeTicks::GetQPCDriftMicroseconds() {
-  return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds();
+  return GetHighResNowSingleton()->GetQPCDriftMicroseconds();
 }
 
 // static
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
-  return TimeTicks(
-      HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
+  return TimeTicks(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
 }
 
 // static
 bool TimeTicks::IsHighResClockWorking() {
-  return HighResNowSingleton::GetInstance()->IsUsingHighResClock();
+  return GetHighResNowSingleton()->IsUsingHighResClock();
 }
 
 TimeTicks TimeTicks::UnprotectedNow() {
   if (now_function == HighResNowWrapper) {
     return Now();
   } else {
     return TimeTicks() + TimeDelta::FromMilliseconds(timeGetTime());
   }
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
-  return TimeDelta(
-      HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
+  return TimeDelta(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
 }