time: Add a static TimeTicks method that returns the underlying clock

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 385 matching lines @@
 // this timer; and also other Windows applications can alter it, affecting this
 // one.
 
 using NowFunction = TimeDelta (*)(void);
 
 TimeDelta InitialNowFunction();
 
 // See "threading notes" in InitializeNowFunctionPointer() for details on how
 // concurrent reads/writes to these globals has been made safe.
 NowFunction g_now_function = &InitialNowFunction;
+TimeTicks::Clock g_now_clock = TimeTicks::WIN_ROLLOVER_PROTECTED_TIME_GET_TIME;
+
 int64_t 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
   // InitializeNowFunctionPointer(), has happened by this point.
@@ skipping 36 matching lines @@
   //
   // If the QPC implementation is expensive and/or unreliable, TimeTicks::Now()
   // 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, Now uses the high-resolution QPC clock. As of 21 August 2015,
   // ~72% of users fall within this category.
   NowFunction now_function;
+  const char* now_clock;
   base::CPU cpu;
   if (ticks_per_sec.QuadPart <= 0 ||
       !cpu.has_non_stop_time_stamp_counter() || IsBuggyAthlon(cpu)) {
     now_function = &RolloverProtectedNow;
+    now_clock = Clock::WIN_ROLLOVER_PROTECTED_TIME_GET_TIME;
   } else {
     now_function = &QPCNow;
+    now_clock = Clock::WIN_QPC;
   }
 
   // Threading note 1: In an unlikely race condition, it's possible for two or
   // 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_now_clock = now_clock;
   g_qpc_ticks_per_second = ticks_per_sec.QuadPart;
   ATOMIC_THREAD_FENCE(memory_order_release);
   g_now_function = now_function;
 }
 
 TimeDelta InitialNowFunction() {
   InitializeNowFunctionPointer();
   return g_now_function();
 }
 
@@ skipping 16 matching lines @@
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   if (g_now_function == &InitialNowFunction)
     InitializeNowFunctionPointer();
   return g_now_function == &QPCNow;
 }
 
 // static
+TimeTicks::Clock TimeTicks::GetClock() {

[fmeawad, 2016/03/30 20:25:19]

nit: I might be confused, but why not something like that instead:
return IsHighResolution? WIN_QPC : WIN_ROLLOVER_PROTECTED_TIME_GET_TIME;

[danakj, 2016/03/30 20:26:29]

Oh, that's pretty nice yah.

[charliea (OOO until 10-5), 2016/03/31 15:38:38]

Agreed. That's a much nicer way of doing this. Done.

+  if (g_now_function == &InitialNowFunction)
+    InitializeNowFunctionPointer();
+  return g_now_clock;
+}
+
+// static
 ThreadTicks ThreadTicks::Now() {
   DCHECK(IsSupported());
 
   // Get the number of TSC ticks used by the current thread.
   ULONG64 thread_cycle_time = 0;
   GetQueryThreadCycleTimeFunction()(::GetCurrentThread(), &thread_cycle_time);
 
   // Get the frequency of the TSC.
   double tsc_ticks_per_second = TSCTicksPerSecond();
   if (tsc_ticks_per_second == 0)
@@ skipping 82 matching lines @@
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
   return TimeTicks() + QPCValueToTimeDelta(qpc_value);
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return QPCValueToTimeDelta(qpc_value);
 }