Fixit: Fork base::TimeTicks --> TimeTicks + ThreadTicks + TraceTicks

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 26 matching lines @@
 #include <windows.h>
 #include <mmsystem.h>
 #include <stdint.h>
 
 #include "base/basictypes.h"
 #include "base/cpu.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/synchronization/lock.h"
 
+using base::ThreadTicks;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
+using base::TraceTicks;
 
 namespace {
 
 // From MSDN, FILETIME "Contains a 64-bit value representing the number of
 // 100-nanosecond intervals since January 1, 1601 (UTC)."
 int64 FileTimeToMicroseconds(const FILETIME& ft) {
   // Need to bit_cast to fix alignment, then divide by 10 to convert
   // 100-nanoseconds to milliseconds. This only works on little-endian
   // machines.
   return bit_cast<int64, FILETIME>(ft) / 10;
@@ skipping 262 matching lines @@
 // easy to use a Singleton without even knowing it, and that may lead to many
 // gotchas). Its impact on startup time should be negligible due to low-level
 // nature of time code.
 base::Lock g_rollover_lock;
 
 // We use timeGetTime() to implement TimeTicks::Now().  This can be problematic
 // because it returns the number of milliseconds since Windows has started,
 // which will roll over the 32-bit value every ~49 days.  We try to track
 // rollover ourselves, which works if TimeTicks::Now() is called at least every
 // 49 days.
-TimeTicks RolloverProtectedNow() {
+TimeDelta RolloverProtectedNow() {
   base::AutoLock locked(g_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 = g_tick_function();
   if (now < g_last_seen_now)
     g_rollover_ms += 0x100000000I64;  // ~49.7 days.
   g_last_seen_now = now;
-  return TimeTicks() + TimeDelta::FromMilliseconds(now + g_rollover_ms);
+  return TimeDelta::FromMilliseconds(now + g_rollover_ms);
 }
 
 // Discussion of tick counter options on Windows:
 //
 // (1) CPU cycle counter. (Retrieved via RDTSC)
 // The CPU counter provides the highest resolution time stamp and is the least
 // expensive to retrieve. However, on older CPUs, two issues can affect its
 // reliability: First it is maintained per processor and not synchronized
 // between processors. Also, the counters will change frequency due to thermal
 // and power changes, and stop in some states.
@@ skipping 17 matching lines @@
 // give consistent results on a multiprocessor computer, but for older CPUs it
 // can be unreliable due bugs in BIOS or HAL.
 //
 // (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 = TimeTicks (*)(void);
+using NowFunction = TimeDelta (*)(void);
 
-TimeTicks InitialNowFunction();
-TimeTicks InitialSystemTraceNowFunction();
+TimeDelta InitialNowFunction();
+TimeDelta InitialSystemTraceNowFunction();
 
 // See "threading notes" in InitializeNowFunctionPointers() 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:
@@ skipping 15 matching lines @@
   // Otherwise, calculate microseconds in a round about manner to avoid
   // overflow and precision issues.
   int64 whole_seconds = qpc_value / g_qpc_ticks_per_second;
   int64 leftover_ticks = qpc_value - (whole_seconds * g_qpc_ticks_per_second);
   return TimeDelta::FromMicroseconds(
       (whole_seconds * Time::kMicrosecondsPerSecond) +
       ((leftover_ticks * Time::kMicrosecondsPerSecond) /
        g_qpc_ticks_per_second));
 }
 
-TimeTicks QPCNow() {
+TimeDelta QPCNow() {
   LARGE_INTEGER now;
   QueryPerformanceCounter(&now);
-  return TimeTicks() + QPCValueToTimeDelta(now.QuadPart);
+  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() {
   LARGE_INTEGER ticks_per_sec = {0};
   if (!QueryPerformanceFrequency(&ticks_per_sec))
     ticks_per_sec.QuadPart = 0;
 
-  // If Windows cannot provide a QPC implementation, both Now() and
-  // NowFromSystemTraceTime() must use the low-resolution clock.
+  // If Windows cannot provide a QPC implementation, both TimeTicks::Now() and
+  // TraceTicks::Now() must use the low-resolution clock.
   //
-  // If the QPC implementation is expensive and/or unreliable, Now() will use
-  // the low-resolution clock, but NowFromSystemTraceTime() will use the QPC (in
-  // the hope that it is still useful for tracing purposes). A CPU lacking a
+  // 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.
   //
   // Otherwise, both Now functions can use the high-resolution QPC clock. As of
   // 4 January 2015, ~68% of users fall within this category.
   NowFunction now_function;
   NowFunction system_trace_now_function;
   base::CPU cpu;
   if (ticks_per_sec.QuadPart <= 0) {
@@ skipping 13 matching lines @@
   // 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;
 }
 
-TimeTicks InitialNowFunction() {
+TimeDelta InitialNowFunction() {
   InitializeNowFunctionPointers();
   return g_now_function();
 }
 
-TimeTicks InitialSystemTraceNowFunction() {
+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 g_now_function();
+  return TimeTicks() + g_now_function();
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   if (g_now_function == &InitialNowFunction)
     InitializeNowFunctionPointers();
   return g_now_function == &QPCNow;
 }
 
 // static
-TimeTicks TimeTicks::ThreadNow() {
+ThreadTicks ThreadTicks::Now() {
   NOTREACHED();
-  return TimeTicks();
+  return ThreadTicks();
 }
 
 // static
-TimeTicks TimeTicks::NowFromSystemTraceTime() {
-  return g_system_trace_now_function();
+TraceTicks TraceTicks::Now() {
+  return TraceTicks() + g_system_trace_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);
 }