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

base/time/time_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 "base/time/time.h"
 
 #include <time.h>
 
 #include <limits>
 #include <string>
@@ skipping 672 matching lines @@
   HighResClockTest(&TimeTicks::Now);
 }
 
 // Fails frequently on Android http://crbug.com/352633 with:
 // Expected: (delta_thread.InMicroseconds()) > (0), actual: 0 vs 0
 #if defined(OS_ANDROID)
 #define MAYBE_ThreadNow DISABLED_ThreadNow
 #else
 #define MAYBE_ThreadNow ThreadNow
 #endif
-TEST(TimeTicks, MAYBE_ThreadNow) {
-  if (TimeTicks::IsThreadNowSupported()) {
+TEST(ThreadTicks, MAYBE_ThreadNow) {
+  if (ThreadTicks::IsSupported()) {
     TimeTicks begin = TimeTicks::Now();
-    TimeTicks begin_thread = TimeTicks::ThreadNow();
+    ThreadTicks begin_thread = ThreadTicks::Now();
     // Make sure that ThreadNow value is non-zero.
-    EXPECT_GT(begin_thread, TimeTicks());
+    EXPECT_GT(begin_thread, ThreadTicks());
     // Sleep for 10 milliseconds to get the thread de-scheduled.
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
-    TimeTicks end_thread = TimeTicks::ThreadNow();
+    ThreadTicks end_thread = ThreadTicks::Now();
     TimeTicks end = TimeTicks::Now();
     TimeDelta delta = end - begin;
     TimeDelta delta_thread = end_thread - begin_thread;
     // Make sure that some thread time have elapsed.
     EXPECT_GT(delta_thread.InMicroseconds(), 0);
     // But the thread time is at least 9ms less than clock time.
     TimeDelta difference = delta - delta_thread;
     EXPECT_GE(difference.InMicroseconds(), 9000);
   }
 }
 
-TEST(TimeTicks, NowFromSystemTraceTime) {
+TEST(TraceTicks, NowFromSystemTraceTime) {
   // Re-use HighRes test for now since clock properties are identical.
-  HighResClockTest(&TimeTicks::NowFromSystemTraceTime);
+  using NowFunction = TimeTicks (*)(void);
+  HighResClockTest(reinterpret_cast<NowFunction>(&TraceTicks::Now));
 }
 
 TEST(TimeTicks, SnappedToNextTickBasic) {
   base::TimeTicks phase = base::TimeTicks::FromInternalValue(4000);
-  base::TimeDelta interval = base::TimeDelta::FromInternalValue(1000);
+  base::TimeDelta interval = base::TimeDelta::FromMicroseconds(1000);
   base::TimeTicks timestamp;
 
   // Timestamp in previous interval.
   timestamp = base::TimeTicks::FromInternalValue(3500);
   EXPECT_EQ(4000,
             timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
 
   // Timestamp in next interval.
   timestamp = base::TimeTicks::FromInternalValue(4500);
   EXPECT_EQ(5000,
@@ skipping 22 matching lines @@
   // Timestamp equal to phase.
   timestamp = base::TimeTicks::FromInternalValue(4000);
   EXPECT_EQ(4000,
             timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
 }
 
 TEST(TimeTicks, SnappedToNextTickOverflow) {
   // int(big_timestamp / interval) < 0, so this causes a crash if the number of
   // intervals elapsed is attempted to be stored in an int.
   base::TimeTicks phase = base::TimeTicks::FromInternalValue(0);
-  base::TimeDelta interval = base::TimeDelta::FromInternalValue(4000);
+  base::TimeDelta interval = base::TimeDelta::FromMicroseconds(4000);
   base::TimeTicks big_timestamp =
       base::TimeTicks::FromInternalValue(8635916564000);
 
   EXPECT_EQ(8635916564000,
             big_timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
   EXPECT_EQ(8635916564000,
             big_timestamp.SnappedToNextTick(big_timestamp, interval)
                 .ToInternalValue());
 }
 
@@ skipping 319 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base