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

base/time/time_posix.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 <stdint.h>
 #include <sys/time.h>
 #include <time.h>
 #if defined(OS_ANDROID) && !defined(__LP64__)
@@ skipping 63 matching lines @@
 
 void SysTimeToTimeStruct(SysTime t, struct tm* timestruct, bool is_local) {
   base::AutoLock locked(g_sys_time_to_time_struct_lock.Get());
   if (is_local)
     localtime_r(&t, timestruct);
   else
     gmtime_r(&t, timestruct);
 }
 #endif  // OS_ANDROID
 
-// Helper function to get results from clock_gettime() as TimeTicks object.
-// Minimum requirement is MONOTONIC_CLOCK to be supported on the system.
-// FreeBSD 6 has CLOCK_MONOTONIC but defines _POSIX_MONOTONIC_CLOCK to -1.
+int64 ConvertTimespecToMicros(const struct timespec& ts) {
+  base::CheckedNumeric<int64> result(ts.tv_sec);
+  result *= base::Time::kMicrosecondsPerSecond;
+  result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
+  return result.ValueOrDie();
+}
+
+// Helper function to get results from clock_gettime() and convert to a
+// microsecond timebase. Minimum requirement is MONOTONIC_CLOCK to be supported
+// on the system. FreeBSD 6 has CLOCK_MONOTONIC but defines
+// _POSIX_MONOTONIC_CLOCK to -1.
 #if (defined(OS_POSIX) &&                                               \
      defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0) || \
     defined(OS_BSD) || defined(OS_ANDROID)
-base::TimeTicks ClockNow(clockid_t clk_id) {
-  uint64_t absolute_micro;
-
+int64 ClockNow(clockid_t clk_id) {
   struct timespec ts;
   if (clock_gettime(clk_id, &ts) != 0) {
     NOTREACHED() << "clock_gettime(" << clk_id << ") failed.";
-    return base::TimeTicks();
+    return 0;
   }
-
-  absolute_micro =
-      (static_cast<int64>(ts.tv_sec) * base::Time::kMicrosecondsPerSecond) +
-      (static_cast<int64>(ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond));
-
-  return base::TimeTicks::FromInternalValue(absolute_micro);
+  return ConvertTimespecToMicros(ts);
 }
 #else  // _POSIX_MONOTONIC_CLOCK
 #error No usable tick clock function on this platform.
 #endif  // _POSIX_MONOTONIC_CLOCK
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace
 
 namespace base {
 
@@ skipping 189 matching lines @@
   }
 
   // Adjust from Unix (1970) to Windows (1601) epoch.
   return Time((milliseconds * kMicrosecondsPerMillisecond) +
       kWindowsEpochDeltaMicroseconds);
 }
 
 // TimeTicks ------------------------------------------------------------------
 // static
 TimeTicks TimeTicks::Now() {
-  return ClockNow(CLOCK_MONOTONIC);
+  return TimeTicks(ClockNow(CLOCK_MONOTONIC));
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   return true;
 }
 
 // static
-TimeTicks TimeTicks::ThreadNow() {
+ThreadTicks ThreadTicks::Now() {
 #if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
     defined(OS_ANDROID)
-  return ClockNow(CLOCK_THREAD_CPUTIME_ID);
+  return ThreadTicks(ClockNow(CLOCK_THREAD_CPUTIME_ID));
 #else
   NOTREACHED();
-  return TimeTicks();
+  return ThreadTicks();
 #endif
 }
 
 // Use the Chrome OS specific system-wide clock.
 #if defined(OS_CHROMEOS)
 // static
-TimeTicks TimeTicks::NowFromSystemTraceTime() {
-  uint64_t absolute_micro;
-
+TraceTicks TraceTicks::Now() {
   struct timespec ts;
   if (clock_gettime(kClockSystemTrace, &ts) != 0) {
     // NB: fall-back for a chrome os build running on linux
-    return Now();
+    return TraceTicks(ClockNow(CLOCK_MONOTONIC));
   }
-
-  absolute_micro =
-      (static_cast<int64>(ts.tv_sec) * Time::kMicrosecondsPerSecond) +
-      (static_cast<int64>(ts.tv_nsec) / Time::kNanosecondsPerMicrosecond);
-
-  return TimeTicks(absolute_micro);
+  return TraceTicks(ConvertTimespecToMicros(ts));
 }
 
 #else  // !defined(OS_CHROMEOS)
 
 // static
-TimeTicks TimeTicks::NowFromSystemTraceTime() {
-  return Now();
+TraceTicks TraceTicks::Now() {
+  return TraceTicks(ClockNow(CLOCK_MONOTONIC));
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 #endif  // !OS_MACOSX
 
 // static
 Time Time::FromTimeVal(struct timeval t) {
   DCHECK_LT(t.tv_usec, static_cast<int>(Time::kMicrosecondsPerSecond));
   DCHECK_GE(t.tv_usec, 0);
@@ skipping 20 matching lines @@
     result.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
     return result;
   }
   int64 us = us_ - kTimeTToMicrosecondsOffset;
   result.tv_sec = us / Time::kMicrosecondsPerSecond;
   result.tv_usec = us % Time::kMicrosecondsPerSecond;
   return result;
 }
 
 }  // namespace base