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

base/time/time_win_unittest.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.
 
 #include <windows.h>
 #include <mmsystem.h>
 #include <process.h>
 
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
+using base::TraceTicks;
 
 namespace {
 
 class MockTimeTicks : public TimeTicks {
  public:
   static DWORD Ticker() {
     return static_cast<int>(InterlockedIncrement(&ticker_));
   }
 
   static void InstallTicker() {
@@ skipping 148 matching lines @@
   typedef TimeTicks (*TestFunc)();
   struct TestCase {
     TestFunc func;
     const char *description;
   };
   // Cheating a bit here:  assumes sizeof(TimeTicks) == sizeof(Time)
   // in order to create a single test case list.
   COMPILE_ASSERT(sizeof(TimeTicks) == sizeof(Time),
                  test_only_works_with_same_sizes);
   TestCase cases[] = {
-    { reinterpret_cast<TestFunc>(Time::Now), "Time::Now" },
-    { TimeTicks::Now, "TimeTicks::Now" },
-    { TimeTicks::NowFromSystemTraceTime, "TimeTicks::NowFromSystemTraceTime" },
+    { reinterpret_cast<TestFunc>(&Time::Now), "Time::Now" },
+    { &TimeTicks::Now, "TimeTicks::Now" },
+    { reinterpret_cast<TestFunc>(&TraceTicks::Now), "TraceTicks::Now" },
     { NULL, "" }
   };
 
   int test_case = 0;
   while (cases[test_case].func) {
     TimeTicks start = TimeTicks::Now();
     for (int index = 0; index < kLoops; index++)
       cases[test_case].func();
     TimeTicks stop = TimeTicks::Now();
     // Turning off the check for acceptible delays.  Without this check,
@@ skipping 57 matching lines @@
     const TimeTicks converted_value = TimeTicks::FromQPCValue(ticks);
     const double converted_microseconds_since_origin =
         static_cast<double>((converted_value - TimeTicks()).InMicroseconds());
     EXPECT_NEAR(expected_microseconds_since_origin,
                 converted_microseconds_since_origin,
                 1.0)
         << "ticks=" << ticks << ", to be converted via logic path: "
         << (ticks < Time::kQPCOverflowThreshold ? "FAST" : "SAFE");
   }
 }