base/time_posix.cc: Use time64_t on Android.

base/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.h"
 
 #include <sys/time.h>
 #include <time.h>
+#if defined(OS_ANDROID)
+#include <time64.h>
+#endif
 #include <unistd.h>
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 #if defined(OS_ANDROID)
 #include "base/os_compat_android.h"
 #elif defined(OS_NACL)
 #include "base/os_compat_nacl.h"
 #endif
 
+namespace {
+
+// 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)
+typedef time64_t SysTime;
+
+SysTime SysTimeFromTimeStruct(struct tm* timestruct, bool is_local) {
+  if (is_local)
+    return mktime64(timestruct);
+  else
+    return timegm64(timestruct);
+}
+
+void SysTimeToTimeStruct(SysTime t, struct tm* timestruct, bool is_local) {
+  if (is_local)
+    localtime64_r(&t, timestruct);
+  else
+    gmtime64_r(&t, timestruct);
+}
+
+#else  // OS_ANDROID
+typedef time_t SysTime;
+
+SysTime SysTimeFromTimeStruct(struct tm* timestruct, bool is_local) {
+  if (is_local)
+    return mktime(timestruct);
+  else
+    return timegm(timestruct);
+}
+
+void SysTimeToTimeStruct(SysTime t, struct tm* timestruct, bool is_local) {
+  if (is_local)
+    localtime_r(&t, timestruct);
+  else
+    gmtime_r(&t, timestruct);
+}
+#endif  // OS_ANDROID
+
+}  // namespace
+
 namespace base {
 
 #if defined(OS_ANDROID)
 #define _POSIX_MONOTONIC_CLOCK 1
 #endif
 
 struct timespec TimeDelta::ToTimeSpec() const {
   int64 microseconds = InMicroseconds();
   time_t seconds = 0;
   if (microseconds >= Time::kMicrosecondsPerSecond) {
@@ skipping 56 matching lines @@
   return Now();
 }
 
 void Time::Explode(bool is_local, Exploded* exploded) const {
   // Time stores times with microsecond resolution, but Exploded only carries
   // millisecond resolution, so begin by being lossy.  Adjust from Windows
   // epoch (1601) to Unix epoch (1970);
   int64 microseconds = us_ - kWindowsEpochDeltaMicroseconds;
   // The following values are all rounded towards -infinity.
   int64 milliseconds;  // Milliseconds since epoch.
-  time_t seconds;  // Seconds since epoch.
+  SysTime seconds;  // Seconds since epoch.
   int millisecond;  // Exploded millisecond value (0-999).
   if (microseconds >= 0) {
     // Rounding towards -infinity <=> rounding towards 0, in this case.
     milliseconds = microseconds / kMicrosecondsPerMillisecond;
     seconds = milliseconds / kMillisecondsPerSecond;
     millisecond = milliseconds % kMillisecondsPerSecond;
   } else {
     // Round these *down* (towards -infinity).
     milliseconds = (microseconds - kMicrosecondsPerMillisecond + 1) /
                    kMicrosecondsPerMillisecond;
     seconds = (milliseconds - kMillisecondsPerSecond + 1) /
               kMillisecondsPerSecond;
     // Make this nonnegative (and between 0 and 999 inclusive).
     millisecond = milliseconds % kMillisecondsPerSecond;
     if (millisecond < 0)
       millisecond += kMillisecondsPerSecond;
   }
 
   struct tm timestruct;
-  if (is_local)
-    localtime_r(&seconds, &timestruct);
-  else
-    gmtime_r(&seconds, &timestruct);
+  SysTimeToTimeStruct(seconds, &timestruct, is_local);
 
   exploded->year         = timestruct.tm_year + 1900;
   exploded->month        = timestruct.tm_mon + 1;
   exploded->day_of_week  = timestruct.tm_wday;
   exploded->day_of_month = timestruct.tm_mday;
   exploded->hour         = timestruct.tm_hour;
   exploded->minute       = timestruct.tm_min;
   exploded->second       = timestruct.tm_sec;
   exploded->millisecond  = millisecond;
 }
 
 // static
 Time Time::FromExploded(bool is_local, const Exploded& exploded) {
   struct tm timestruct;
   timestruct.tm_sec    = exploded.second;
   timestruct.tm_min    = exploded.minute;
   timestruct.tm_hour   = exploded.hour;
   timestruct.tm_mday   = exploded.day_of_month;
   timestruct.tm_mon    = exploded.month - 1;
   timestruct.tm_year   = exploded.year - 1900;
   timestruct.tm_wday   = exploded.day_of_week;  // mktime/timegm ignore this
   timestruct.tm_yday   = 0;     // mktime/timegm ignore this
   timestruct.tm_isdst  = -1;    // attempt to figure it out
 #if !defined(OS_NACL) && !defined(OS_SOLARIS)
   timestruct.tm_gmtoff = 0;     // not a POSIX field, so mktime/timegm ignore
   timestruct.tm_zone   = NULL;  // not a POSIX field, so mktime/timegm ignore
 #endif
 
-  time_t seconds;
-  if (is_local)
-    seconds = mktime(&timestruct);
-  else
-    seconds = timegm(&timestruct);
+  SysTime seconds = SysTimeFromTimeStruct(&timestruct, is_local);
 
   int64 milliseconds;
   // Handle overflow.  Clamping the range to what mktime and timegm might
   // return is the best that can be done here.  It's not ideal, but it's better
   // than failing here or ignoring the overflow case and treating each time
   // overflow as one second prior to the epoch.
   if (seconds == -1 &&
       (exploded.year < 1969 || exploded.year > 1970)) {
     // If exploded.year is 1969 or 1970, take -1 as correct, with the
     // time indicating 1 second prior to the epoch.  (1970 is allowed to handle
     // time zone and DST offsets.)  Otherwise, return the most future or past
     // time representable.  Assumes the time_t epoch is 1970-01-01 00:00:00 UTC.
     //
     // The minimum and maximum representible times that mktime and timegm could
     // return are used here instead of values outside that range to allow for
     // proper round-tripping between exploded and counter-type time
     // representations in the presence of possible truncation to time_t by
     // division and use with other functions that accept time_t.
     //
     // When representing the most distant time in the future, add in an extra
     // 999ms to avoid the time being less than any other possible value that
     // this function can return.
     if (exploded.year < 1969) {
-      milliseconds = std::numeric_limits<time_t>::min() *
+      milliseconds = std::numeric_limits<SysTime>::min() *
                      kMillisecondsPerSecond;
     } else {
-      milliseconds = (std::numeric_limits<time_t>::max() *
+      milliseconds = (std::numeric_limits<SysTime>::max() *
                       kMillisecondsPerSecond) +
                      kMillisecondsPerSecond - 1;
     }
   } else {
     milliseconds = seconds * kMillisecondsPerSecond + exploded.millisecond;
   }
 
   // Adjust from Unix (1970) to Windows (1601) epoch.
   return Time((milliseconds * kMicrosecondsPerMillisecond) +
       kWindowsEpochDeltaMicroseconds);
@@ skipping 91 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