Use base/time/time_posix.cc on OS X and iOS.

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__)
 #include <time64.h>
 #endif
 #include <unistd.h>
 
 #include <limits>
 #include <ostream>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
 #include "build/build_config.h"
 
 #if defined(OS_ANDROID)
 #include "base/os_compat_android.h"
 #elif defined(OS_NACL)
 #include "base/os_compat_nacl.h"
-#endif
-
-#if !defined(OS_MACOSX)
-#include "base/lazy_instance.h"
-#include "base/synchronization/lock.h"
+#elif defined(OS_MACOSX)
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <sys/sysctl.h>
+#include "base/mac/mach_logging.h"
+#include "base/mac/scoped_mach_port.h"
 #endif
 
 namespace {
 
-#if !defined(OS_MACOSX)
 // This prevents a crash on traversing the environment global and looking up
 // the 'TZ' variable in libc. See: crbug.com/390567.
 base::LazyInstance<base::Lock>::Leaky
     g_sys_time_to_time_struct_lock = LAZY_INSTANCE_INITIALIZER;
 
 // Define a system-specific SysTime that wraps either to a time_t or
 // a time64_t depending on the host system, and associated convertion.
 // See crbug.com/162007
 #if defined(OS_ANDROID) && !defined(__LP64__)
 typedef time64_t SysTime;
@@ skipping 27 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
 
+#if !defined(OS_MACOSX)
 int64_t ConvertTimespecToMicros(const struct timespec& ts) {
   base::CheckedNumeric<int64_t> 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)
 int64_t ClockNow(clockid_t clk_id) {
   struct timespec ts;
   if (clock_gettime(clk_id, &ts) != 0) {
     NOTREACHED() << "clock_gettime(" << clk_id << ") failed.";
     return 0;
   }
   return ConvertTimespecToMicros(ts);
 }
 #else  // _POSIX_MONOTONIC_CLOCK
 #error No usable tick clock function on this platform.
 #endif  // _POSIX_MONOTONIC_CLOCK
-#endif  // !defined(OS_MACOSX)
+#endif
+
+int64_t ComputeCurrentTicks() {
+#if defined(OS_IOS)
+  // On iOS mach_absolute_time stops while the device is sleeping. Instead use
+  // now - KERN_BOOTTIME to get a time difference that is not impacted by clock
+  // changes. KERN_BOOTTIME will be updated by the system whenever the system
+  // clock change.
+  struct timeval boottime;
+  int mib[2] = {CTL_KERN, KERN_BOOTTIME};
+  size_t size = sizeof(boottime);
+  int kr = sysctl(mib, arraysize(mib), &boottime, &size, NULL, 0);
+  DCHECK_EQ(KERN_SUCCESS, kr);
+  base::TimeDelta time_difference = base::Time::Now() -
+      (base::Time::FromTimeT(boottime.tv_sec) +
+       base::TimeDelta::FromMicroseconds(boottime.tv_usec));
+  return time_difference.InMicroseconds();
+#elif defined(OS_MACOSX)
+  static mach_timebase_info_data_t timebase_info;
+  if (timebase_info.denom == 0) {
+    // Zero-initialization of statics guarantees that denom will be 0 before
+    // calling mach_timebase_info.  mach_timebase_info will never set denom to
+    // 0 as that would be invalid, so the zero-check can be used to determine
+    // whether mach_timebase_info has already been called.  This is
+    // recommended by Apple's QA1398.
+    kern_return_t kr = mach_timebase_info(&timebase_info);
+    MACH_DCHECK(kr == KERN_SUCCESS, kr) << "mach_timebase_info";
+  }
+
+  // mach_absolute_time is it when it comes to ticks on the Mac.  Other calls
+  // with less precision (such as TickCount) just call through to
+  // mach_absolute_time.
+
+  // timebase_info converts absolute time tick units into nanoseconds.  Convert
+  // to microseconds up front to stave off overflows.
+  base::CheckedNumeric<uint64_t> result(
+      mach_absolute_time() / base::Time::kNanosecondsPerMicrosecond);
+  result *= timebase_info.numer;
+  result /= timebase_info.denom;
+
+  // Don't bother with the rollover handling that the Windows version does.
+  // With numer and denom = 1 (the expected case), the 64-bit absolute time
+  // reported in nanoseconds is enough to last nearly 585 years.
+  return base::checked_cast<int64_t>(result.ValueOrDie());
+#else
+  return ClockNow(CLOCK_MONOTONIC);
+#endif
+}
+
+int64_t ComputeThreadTicks() {
+#if defined(OS_IOS)
+  NOTREACHED();
+  return 0;
+#elif defined(OS_MACOSX)
+  base::mac::ScopedMachSendRight thread(mach_thread_self());
+  mach_msg_type_number_t thread_info_count = THREAD_BASIC_INFO_COUNT;
+  thread_basic_info_data_t thread_info_data;
+
+  if (thread.get() == MACH_PORT_NULL) {
+    DLOG(ERROR) << "Failed to get mach_thread_self()";
+    return 0;
+  }
+
+  kern_return_t kr = thread_info(
+      thread.get(),
+      THREAD_BASIC_INFO,
+      reinterpret_cast<thread_info_t>(&thread_info_data),
+      &thread_info_count);
+  MACH_DCHECK(kr == KERN_SUCCESS, kr) << "thread_info";
+
+  base::CheckedNumeric<int64_t> absolute_micros(
+      thread_info_data.user_time.seconds);
+  absolute_micros *= base::Time::kMicrosecondsPerSecond;
+  absolute_micros += thread_info_data.user_time.microseconds;
+  return absolute_micros.ValueOrDie();
+#elif (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
+    defined(OS_ANDROID)
+  return ThreadTicks(ClockNow(CLOCK_THREAD_CPUTIME_ID));
+#else
+  NOTREACHED();
+  return 0;
+#endif
+}
 
 }  // namespace
 
 namespace base {
 
 struct timespec TimeDelta::ToTimeSpec() const {
   int64_t microseconds = InMicroseconds();
   time_t seconds = 0;
   if (microseconds >= Time::kMicrosecondsPerSecond) {
     seconds = InSeconds();
     microseconds -= seconds * Time::kMicrosecondsPerSecond;
   }
   struct timespec result =
       {seconds,
        static_cast<long>(microseconds * Time::kNanosecondsPerMicrosecond)};
   return result;
 }
 
-#if !defined(OS_MACOSX)
 // The Time routines in this file use standard POSIX routines, or almost-
 // standard routines in the case of timegm.  We need to use a Mach-specific
 // function for TimeTicks::Now() on Mac OS X.
 
 // Time -----------------------------------------------------------------------
 
 // Windows uses a Gregorian epoch of 1601.  We need to match this internally
 // so that our time representations match across all platforms.  See bug 14734.
 //   irb(main):010:0> Time.at(0).getutc()
 //   => Thu Jan 01 00:00:00 UTC 1970
@@ skipping 164 matching lines @@
   }
 
   // Adjust from Unix (1970) to Windows (1601) epoch.
   return Time((milliseconds * kMicrosecondsPerMillisecond) +
       kWindowsEpochDeltaMicroseconds);
 }
 
 // TimeTicks ------------------------------------------------------------------
 // static
 TimeTicks TimeTicks::Now() {
-  return TimeTicks(ClockNow(CLOCK_MONOTONIC));
+  return TimeTicks(ComputeCurrentTicks());
 }
 
 // static
 bool TimeTicks::IsHighResolution() {
   return true;
 }
 
 // static
 ThreadTicks ThreadTicks::Now() {
-#if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
-    defined(OS_ANDROID)
-  return ThreadTicks(ClockNow(CLOCK_THREAD_CPUTIME_ID));
-#else
-  NOTREACHED();
-  return ThreadTicks();
-#endif
+  return ThreadTicks(ComputeThreadTicks());
 }
 
-#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);
   if (t.tv_usec == 0 && t.tv_sec == 0)
     return Time();
   if (t.tv_usec == static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1 &&
       t.tv_sec == std::numeric_limits<time_t>::max())
     return Max();
   return Time((static_cast<int64_t>(t.tv_sec) * Time::kMicrosecondsPerSecond) +
@@ skipping 11 matching lines @@
     result.tv_sec = std::numeric_limits<time_t>::max();
     result.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
     return result;
   }
   int64_t us = us_ - kTimeTToMicrosecondsOffset;
   result.tv_sec = us / Time::kMicrosecondsPerSecond;
   result.tv_usec = us % Time::kMicrosecondsPerSecond;
   return result;
 }
 
+#if defined(OS_MACOSX)
+// static
+Time Time::FromCFAbsoluteTime(CFAbsoluteTime t) {
+  static_assert(std::numeric_limits<CFAbsoluteTime>::has_infinity,
+                "CFAbsoluteTime must have an infinity value");
+  if (t == 0)
+    return Time();  // Consider 0 as a null Time.
+  if (t == std::numeric_limits<CFAbsoluteTime>::infinity())
+    return Max();
+  return Time(static_cast<int64_t>((t + kCFAbsoluteTimeIntervalSince1970) *
+                                   kMicrosecondsPerSecond) +
+              kWindowsEpochDeltaMicroseconds);
+}
+
+CFAbsoluteTime Time::ToCFAbsoluteTime() const {
+  static_assert(std::numeric_limits<CFAbsoluteTime>::has_infinity,
+                "CFAbsoluteTime must have an infinity value");
+  if (is_null())
+    return 0;  // Consider 0 as a null Time.
+  if (is_max())
+    return std::numeric_limits<CFAbsoluteTime>::infinity();
+  return (static_cast<CFAbsoluteTime>(us_ - kWindowsEpochDeltaMicroseconds) /
+      kMicrosecondsPerSecond) - kCFAbsoluteTimeIntervalSince1970;
+}
+#endif  // OS_MACOSX
+
 }  // namespace base