Add interface to system trace clock.

base/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.h"
 
 #include <time.h>
 
 #include "base/compiler_specific.h"
 #include "base/threading/platform_thread.h"
@@ skipping 446 matching lines @@
     //
     // Unfortunately, our InMilliseconds() function truncates
     // rather than rounds.  We should consider fixing this
     // so that our averages come out better.
     EXPECT_GE(delta.InMilliseconds(), 9);
     EXPECT_GE(delta.InMicroseconds(), 9000);
     EXPECT_EQ(delta.InSeconds(), 0);
   }
 }
 
-TEST(TimeTicks, HighResNow) {
+static void HighResClockTest(TimeTicks (*GetTicks)()) {
 #if defined(OS_WIN)
   // HighResNow doesn't work on some systems.  Since the product still works
   // even if it doesn't work, it makes this entire test questionable.
   if (!TimeTicks::IsHighResClockWorking())
     return;
 #endif
 
   // Why do we loop here?
   // We're trying to measure that intervals increment in a VERY small amount
   // of time --  less than 15ms.  Unfortunately, if we happen to have a
   // context switch in the middle of our test, the context switch could easily
   // exceed our limit.  So, we iterate on this several times.  As long as we're
   // able to detect the fine-granularity timers at least once, then the test
   // has succeeded.
 
   const int kTargetGranularityUs = 15000;  // 15ms
 
   bool success = false;
   int retries = 100;  // Arbitrary.
   TimeDelta delta;
   while (!success && retries--) {
-    TimeTicks ticks_start = TimeTicks::HighResNow();
+    TimeTicks ticks_start = GetTicks();
     // Loop until we can detect that the clock has changed.  Non-HighRes timers
     // will increment in chunks, e.g. 15ms.  By spinning until we see a clock
     // change, we detect the minimum time between measurements.
     do {
-      delta = TimeTicks::HighResNow() - ticks_start;
+      delta = GetTicks() - ticks_start;
     } while (delta.InMilliseconds() == 0);
 
     if (delta.InMicroseconds() <= kTargetGranularityUs)
       success = true;
   }
 
   // In high resolution mode, we expect to see the clock increment
   // in intervals less than 15ms.
   EXPECT_TRUE(success);
 }
 
+TEST(TimeTicks, HighResNow) {
+  HighResClockTest(&TimeTicks::HighResNow);
+}
+
+TEST(TimeTicks, NowFromSystemTraceTime) {
+  // Re-use HighResNow test for now since clock properties are identical.
+  HighResClockTest(&TimeTicks::NowFromSystemTraceTime);
+}
+
 TEST(TimeDelta, FromAndIn) {
   EXPECT_TRUE(TimeDelta::FromDays(2) == TimeDelta::FromHours(48));
   EXPECT_TRUE(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180));
   EXPECT_TRUE(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120));
   EXPECT_TRUE(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000));
   EXPECT_TRUE(TimeDelta::FromMilliseconds(2) ==
               TimeDelta::FromMicroseconds(2000));
   EXPECT_EQ(13, TimeDelta::FromDays(13).InDays());
   EXPECT_EQ(13, TimeDelta::FromHours(13).InHours());
   EXPECT_EQ(13, TimeDelta::FromMinutes(13).InMinutes());
@@ skipping 38 matching lines @@
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
   Time t = Time::FromUTCExploded(exploded);
   // Unix 1970 epoch.
   EXPECT_EQ(GG_INT64_C(11644473600000000), t.ToInternalValue());
 
   // We can't test 1601 epoch, since the system time functions on Linux
   // only compute years starting from 1900.
 }