Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

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 362 matching lines @@
 // (3) System time. The system time provides a low-resolution (from ~1 to ~15.6
 // milliseconds) time stamp but is comparatively less expensive to retrieve and
 // more reliable. Time::EnableHighResolutionTimer() and
 // Time::ActivateHighResolutionTimer() can be called to alter the resolution of
 // this timer; and also other Windows applications can alter it, affecting this
 // one.
 
 using NowFunction = TimeDelta (*)(void);
 
 TimeDelta InitialNowFunction();
-TimeDelta InitialSystemTraceNowFunction();
 
-// See "threading notes" in InitializeNowFunctionPointers() for details on how
+// See "threading notes" in InitializeNowFunctionPointer() for details on how
 // concurrent reads/writes to these globals has been made safe.
 NowFunction g_now_function = &InitialNowFunction;
-NowFunction g_system_trace_now_function = &InitialSystemTraceNowFunction;
 int64 g_qpc_ticks_per_second = 0;
 
 // As of January 2015, use of <atomic> is forbidden in Chromium code. This is
 // what std::atomic_thread_fence does on Windows on all Intel architectures when
 // the memory_order argument is anything but std::memory_order_seq_cst:
 #define ATOMIC_THREAD_FENCE(memory_order) _ReadWriteBarrier();
 
 TimeDelta QPCValueToTimeDelta(LONGLONG qpc_value) {
   // Ensure that the assignment to |g_qpc_ticks_per_second|, made in
-  // InitializeNowFunctionPointers(), has happened by this point.
+  // InitializeNowFunctionPointer(), has happened by this point.
   ATOMIC_THREAD_FENCE(memory_order_acquire);
 
   DCHECK_GT(g_qpc_ticks_per_second, 0);
 
   // If the QPC Value is below the overflow threshold, we proceed with
   // simple multiply and divide.
   if (qpc_value < Time::kQPCOverflowThreshold) {
     return TimeDelta::FromMicroseconds(
         qpc_value * Time::kMicrosecondsPerSecond / g_qpc_ticks_per_second);
   }
@@ skipping 11 matching lines @@
   LARGE_INTEGER now;
   QueryPerformanceCounter(&now);
   return QPCValueToTimeDelta(now.QuadPart);
 }
 
 bool IsBuggyAthlon(const base::CPU& cpu) {
   // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is unreliable.
   return cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15;
 }
 
-void InitializeNowFunctionPointers() {
+void InitializeNowFunctionPointer() {
   LARGE_INTEGER ticks_per_sec = {};
   if (!QueryPerformanceFrequency(&ticks_per_sec))
     ticks_per_sec.QuadPart = 0;
 
-  // If Windows cannot provide a QPC implementation, both TimeTicks::Now() and
-  // TraceTicks::Now() must use the low-resolution clock.
+  // If Windows cannot provide a QPC implementation, TimeTicks::Now() must use
+  // the low-resolution clock.
   //
   // If the QPC implementation is expensive and/or unreliable, TimeTicks::Now()
-  // will use the low-resolution clock, but TraceTicks::Now() will use the QPC
-  // (in the hope that it is still useful for tracing purposes). A CPU lacking a
-  // non-stop time counter will cause Windows to provide an alternate QPC
-  // implementation that works, but is expensive to use. Certain Athlon CPUs are
-  // known to make the QPC implementation unreliable.
+  // will still use the low-resolution clock. A CPU lacking a non-stop time
+  // counter will cause Windows to provide an alternate QPC implementation that
+  // works, but is expensive to use. Certain Athlon CPUs are known to make the
+  // QPC implementation unreliable.
   //
-  // Otherwise, both Now functions can use the high-resolution QPC clock. As of
-  // 4 January 2015, ~68% of users fall within this category.
+  // Otherwise, Now uses the high-resolution QPC clock. As of 21 August 2015,
+  // ~72% of users fall within this category.
+  //
+  // TraceTicks::Now() always uses the same clock as TimeTicks::Now(), even
+  // when the QPC exists but is expensive or unreliable. This is because we'd
+  // eventually like to merge TraceTicks and TimeTicks and have one type of
+  // timestamp that is reliable, monotonic, and comparable. Also, while we could
+  // use the high-resolution timer for TraceTicks even when it's unreliable or
+  // slow, it's easier to make tracing tools accommodate a coarse timer than
+  // one that's unreliable or slow.
   NowFunction now_function;
-  NowFunction system_trace_now_function;
   base::CPU cpu;
-  if (ticks_per_sec.QuadPart <= 0) {
-    now_function = system_trace_now_function = &RolloverProtectedNow;
-  } else if (!cpu.has_non_stop_time_stamp_counter() || IsBuggyAthlon(cpu)) {
+  if (ticks_per_sec.QuadPart <= 0 || !cpu.has_non_stop_time_stamp_counter() ||
+      IsBuggyAthlon(cpu)) {
     now_function = &RolloverProtectedNow;
-    system_trace_now_function = &QPCNow;
   } else {
-    now_function = system_trace_now_function = &QPCNow;
+    now_function = &QPCNow;
   }
 
   // Threading note 1: In an unlikely race condition, it's possible for two or
-  // more threads to enter InitializeNowFunctionPointers() in parallel. This is
+  // more threads to enter InitializeNowFunctionPointer() in parallel. This is
   // not a problem since all threads should end up writing out the same values
   // to the global variables.
   //
   // Threading note 2: A release fence is placed here to ensure, from the
   // perspective of other threads using the function pointers, that the
   // assignment to |g_qpc_ticks_per_second| happens before the function pointers
   // are changed.
   g_qpc_ticks_per_second = ticks_per_sec.QuadPart;
   ATOMIC_THREAD_FENCE(memory_order_release);
   g_now_function = now_function;
-  g_system_trace_now_function = system_trace_now_function;
 }
 
 TimeDelta InitialNowFunction() {
-  InitializeNowFunctionPointers();
+  InitializeNowFunctionPointer();
   return g_now_function();
 }
 
-TimeDelta InitialSystemTraceNowFunction() {
-  InitializeNowFunctionPointers();
-  return g_system_trace_now_function();
-}
-
 }  // namespace
 
 // static
 TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
     TickFunctionType ticker) {
   base::AutoLock locked(g_rollover_lock);
   TickFunctionType old = g_tick_function;
   g_tick_function = ticker;
   g_rollover_ms = 0;
   g_last_seen_now = 0;
   return old;
 }
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + g_now_function();
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   if (g_now_function == &InitialNowFunction)
-    InitializeNowFunctionPointers();
+    InitializeNowFunctionPointer();
   return g_now_function == &QPCNow;
 }
 
 // static
 ThreadTicks ThreadTicks::Now() {
   NOTREACHED();
   return ThreadTicks();
 }
 
 // static
 TraceTicks TraceTicks::Now() {
-  return TraceTicks() + g_system_trace_now_function();
+  return TraceTicks() + g_now_function();
 }
 
 // static
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
   return TimeTicks() + QPCValueToTimeDelta(qpc_value);
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return QPCValueToTimeDelta(qpc_value);
 }