Access singletons with a new GetInstance() method instead of Singleton<T>.

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 292 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:
-  HighResNowSingleton()
-    : ticks_per_microsecond_(0.0),
-      skew_(0) {
-    InitializeClock();
-
-    // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
-    // unreliable.  Fallback to low-res clock.
-    base::CPU cpu;
-    if (cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15)
-      DisableHighResClock();
+  static HighResNowSingleton* GetInstance() {
+    return Singleton<HighResNowSingleton>::get();
   }
 
   bool IsUsingHighResClock() {
     return ticks_per_microsecond_ != 0.0;
   }
 
   void DisableHighResClock() {
     ticks_per_microsecond_ = 0.0;
   }
 
   TimeDelta Now() {
     if (IsUsingHighResClock())
       return TimeDelta::FromMicroseconds(UnreliableNow());
 
     // Just fallback to the slower clock.
     return RolloverProtectedNow();
   }
 
   int64 GetQPCDriftMicroseconds() {
     if (!IsUsingHighResClock())
       return 0;
 
     return abs((UnreliableNow() - ReliableNow()) - skew_);
   }
 
  private:
+  HighResNowSingleton()
+    : ticks_per_microsecond_(0.0),
+      skew_(0) {
+    InitializeClock();
+
+    // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
+    // unreliable.  Fallback to low-res clock.
+    base::CPU cpu;
+    if (cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15)
+      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_microsecond_ = static_cast<float>(ticks_per_sec.QuadPart) /
       static_cast<float>(Time::kMicrosecondsPerSecond);
 
     skew_ = UnreliableNow() - ReliableNow();
   }
 
   // Get the number of microseconds since boot in an unreliable fashion.
   int64 UnreliableNow() {
     LARGE_INTEGER now;
     QueryPerformanceCounter(&now);
     return static_cast<int64>(now.QuadPart / ticks_per_microsecond_);
   }
 
   // Get the number of microseconds since boot in a reliable fashion.
   int64 ReliableNow() {
     return RolloverProtectedNow().InMicroseconds();
   }
 
   // Cached clock frequency -> microseconds. This assumes that the clock
   // frequency is faster than one microsecond (which is 1MHz, should be OK).
   float ticks_per_microsecond_;  // 0 indicates QPF failed and we're broken.
   int64 skew_;  // Skew between lo-res and hi-res clocks (for debugging).
 
-  DISALLOW_COPY_AND_ASSIGN(HighResNowSingleton);
+  friend struct DefaultSingletonTraits<HighResNowSingleton>;
 };
 
 }  // namespace
 
 // static
 TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
     TickFunctionType ticker) {
   TickFunctionType old = tick_function;
   tick_function = ticker;
   return old;
 }
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + RolloverProtectedNow();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
-  return TimeTicks() + Singleton<HighResNowSingleton>::get()->Now();
+  return TimeTicks() + HighResNowSingleton::GetInstance()->Now();
 }
 
 // static
 int64 TimeTicks::GetQPCDriftMicroseconds() {
-  return Singleton<HighResNowSingleton>::get()->GetQPCDriftMicroseconds();
+  return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds();
 }
 
 // static
 bool TimeTicks::IsHighResClockWorking() {
-  return Singleton<HighResNowSingleton>::get()->IsUsingHighResClock();
+  return HighResNowSingleton::GetInstance()->IsUsingHighResClock();
 }