Revert 217172 "Enable high resolution time for TimeTicks::Now on..."

trunk/src/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 304 matching lines @@
   base::AutoLock locked(rollover_lock);
   // We should hold the lock while calling tick_function to make sure that
   // we keep last_seen_now stay correctly in sync.
   DWORD now = tick_function();
   if (now < last_seen_now)
     rollover_ms += 0x100000000I64;  // ~49.7 days.
   last_seen_now = now;
   return TimeDelta::FromMilliseconds(now + rollover_ms);
 }
 
-bool IsBuggyAthlon(const base::CPU& cpu) {
-  // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
-  // unreliable.  Fallback to low-res clock.
-  return cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15;
-}
-
 // Overview of time counters:
 // (1) CPU cycle counter. (Retrieved via RDTSC)
 // The CPU counter provides the highest resolution time stamp and is the least
 // expensive to retrieve. However, the CPU counter is unreliable and should not
 // be used in production. Its biggest issue is that it is per processor and it
 // is not synchronized between processors. Also, on some computers, the counters
 // will change frequency due to thermal and power changes, and stop in some
 // states.
 //
 // (2) QueryPerformanceCounter (QPC). The QPC counter provides a high-
@@ skipping 56 matching lines @@
                           ticks_per_second_);
     return microseconds;
   }
 
  private:
   HighResNowSingleton()
     : ticks_per_second_(0),
       skew_(0) {
     InitializeClock();
 
+    // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
+    // unreliable.  Fallback to low-res clock.
     base::CPU cpu;
-    if (IsBuggyAthlon(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_second_ = ticks_per_sec.QuadPart;
 
@@ skipping 11 matching lines @@
   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>;
 };
 
-TimeDelta HighResNowWrapper() {
-  return HighResNowSingleton::GetInstance()->Now();
-}
-
-typedef TimeDelta (*NowFunction)(void);
-NowFunction now_function = RolloverProtectedNow;
-
-bool CPUReliablySupportsHighResTime() {
-  base::CPU cpu;
-  if (!cpu.has_non_stop_time_stamp_counter())
-    return false;
-
-  if (IsBuggyAthlon(cpu))
-    return false;
-
-  return true;
-}
-
 }  // 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();
+  return TimeTicks() + RolloverProtectedNow();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
   return TimeTicks() + HighResNowSingleton::GetInstance()->Now();
 }
 
 // static
 TimeTicks TimeTicks::ThreadNow() {
   NOTREACHED();
@@ skipping 14 matching lines @@
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
   return TimeTicks(
       HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
 }
 
 // static
 bool TimeTicks::IsHighResClockWorking() {
   return HighResNowSingleton::GetInstance()->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));
 }