Fuchsia port of base/time, with some refactoring of POSIX time modules.

base/time/time_mac.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 <CoreFoundation/CFDate.h>
 #include <CoreFoundation/CFTimeZone.h>
 #include <mach/mach.h>
 #include <mach/mach_time.h>
@@ skipping 100 matching lines @@
 namespace base {
 
 // The Time routines in this file use Mach and CoreFoundation APIs, since the
 // POSIX definition of time_t in Mac OS X wraps around after 2038--and
 // there are already cookie expiration dates, etc., past that time out in
 // the field.  Using CFDate prevents that problem, and using mach_absolute_time
 // for TimeTicks gives us nice high-resolution interval timing.
 
 // Time -----------------------------------------------------------------------
 
-// Core Foundation uses a double second count since 2001-01-01 00:00:00 UTC.
-// The UNIX epoch is 1970-01-01 00:00:00 UTC.
-// 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
-//   irb(main):011:0> Time.at(-11644473600).getutc()
-//   => Mon Jan 01 00:00:00 UTC 1601
-static const int64_t kWindowsEpochDeltaSeconds = INT64_C(11644473600);
-
-// static
-const int64_t Time::kWindowsEpochDeltaMicroseconds =
-    kWindowsEpochDeltaSeconds * Time::kMicrosecondsPerSecond;
-
-// Some functions in time.cc use time_t directly, so we provide an offset
-// to convert from time_t (Unix epoch) and internal (Windows epoch).
-// static
-const int64_t Time::kTimeTToMicrosecondsOffset = kWindowsEpochDeltaMicroseconds;
-
 // static
 Time Time::Now() {
   return FromCFAbsoluteTime(CFAbsoluteTimeGetCurrent());
 }
 
 // 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);
+              kTimeTToMicrosecondsOffset);
 }
 
 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;
+  return (static_cast<CFAbsoluteTime>(us_ - kTimeTToMicrosecondsOffset) /
+          kMicrosecondsPerSecond) -
+         kCFAbsoluteTimeIntervalSince1970;
 }
 
 // static
 Time Time::NowFromSystemTime() {
   // Just use Now() because Now() returns the system time.
   return Now();
 }
 
 // static
 bool Time::FromExploded(bool is_local, const Exploded& exploded, Time* time) {
@@ skipping 10 matching lines @@
   CFCalendarComposeAbsoluteTime(
       gregorian, &absolute_time, "yMdHmsS", exploded.year, exploded.month,
       exploded.day_of_month, exploded.hour, exploded.minute, exploded.second,
       exploded.millisecond);
   CFAbsoluteTime seconds = absolute_time + kCFAbsoluteTimeIntervalSince1970;
 
   // CFAbsolutTime is typedef of double. Convert seconds to
   // microseconds and then cast to int64. If
   // it cannot be suited to int64, then fail to avoid overflows.
   double microseconds =
-      (seconds * kMicrosecondsPerSecond) + kWindowsEpochDeltaMicroseconds;
+      (seconds * kMicrosecondsPerSecond) + kTimeTToMicrosecondsOffset;
   if (microseconds > std::numeric_limits<int64_t>::max() ||
       microseconds < std::numeric_limits<int64_t>::min()) {
     *time = Time(0);
     return false;
   }
 
   base::Time converted_time = Time(static_cast<int64_t>(microseconds));
 
   // If |exploded.day_of_month| is set to 31
   // on a 28-30 day month, it will return the first day of the next month.
@@ skipping 13 matching lines @@
   *time = Time(0);
   return false;
 }
 
 void Time::Explode(bool is_local, Exploded* exploded) const {
   // Avoid rounding issues, by only putting the integral number of seconds
   // (rounded towards -infinity) into a |CFAbsoluteTime| (which is a |double|).
   int64_t microsecond = us_ % kMicrosecondsPerSecond;
   if (microsecond < 0)
     microsecond += kMicrosecondsPerSecond;
-  CFAbsoluteTime seconds = ((us_ - microsecond) / kMicrosecondsPerSecond) -
-                           kWindowsEpochDeltaSeconds -
+  CFAbsoluteTime seconds = ((us_ - microsecond - kTimeTToMicrosecondsOffset) /
+                            kMicrosecondsPerSecond) -
                            kCFAbsoluteTimeIntervalSince1970;
 
   base::ScopedCFTypeRef<CFTimeZoneRef> time_zone(
       is_local
           ? CFTimeZoneCopySystem()
           : CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorDefault, 0));
   base::ScopedCFTypeRef<CFCalendarRef> gregorian(CFCalendarCreateWithIdentifier(
       kCFAllocatorDefault, kCFGregorianCalendar));
   CFCalendarSetTimeZone(gregorian, time_zone);
   int second, day_of_week;
@@ skipping 49 matching lines @@
   return Clock::MAC_MACH_ABSOLUTE_TIME;
 #endif  // defined(OS_IOS)
 }
 
 // static
 ThreadTicks ThreadTicks::Now() {
   return ThreadTicks(ComputeThreadTicks());
 }
 
 }  // namespace base