Help make Base compile under NaCl...

base/time_posix.cc

 // Copyright (c) 2010 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>
 
 #include <limits>
@@ skipping 42 matching lines @@
   return Time((tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec) +
       kWindowsEpochDeltaMicroseconds);
 }
 
 // static
 Time Time::NowFromSystemTime() {
   // Just use Now() because Now() returns the system time.
   return Now();
 }
 
+#if defined(OS_NACL)
+#include <stdlib.h>
+// NaCl doesn't have timegm, so we use this hack for now.
+// http://code.google.com/p/nativeclient/issues/detail?id=1160

[brettw, 2010/12/01 22:59:56]

I'd like to at least see a comment here about why this works. Like along the
lines of "since we want GMT, we reset the time zone informations stored in the
environment, get the time, and then put it back. TODO(abarth) this will not work
across threads, blah blah blah."

+static time_t my_timegm (struct tm *tm) {
+  time_t ret;
+  char *tz;
+  tz = getenv("TZ");
+  setenv("TZ", "", 1);
+  tzset();
+  ret = mktime(tm);
+  if (tz)
+    setenv("TZ", tz, 1);
+  else
+    unsetenv("TZ");
+  tzset();
+  return ret;
+}
+#endif
+
 // 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)
   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
+#if defined(OS_NACL)
+    seconds = my_timegm(&timestruct);
+#else
     seconds = timegm(&timestruct);
+#endif
 
   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
@@ skipping 66 matching lines @@
     return TimeTicks();
   }
 
   absolute_micro =
       (static_cast<int64>(ts.tv_sec) * Time::kMicrosecondsPerSecond) +
       (static_cast<int64>(ts.tv_nsec) / Time::kNanosecondsPerMicrosecond);
 
   return TimeTicks(absolute_micro);
 }
 
+#elif defined(OS_NACL)
+TimeTicks TimeTicks::Now() {
+  // NaCl sadly does not have _POSIX_TIMERS enabled in sys/features.h
+  // Apparently NaCl only has CLOCK_REALTIME:
+  // http://code.google.com/p/nativeclient/issues/detail?id=1159
+  return TimeTicks(clock());
+}
+
 #else  // _POSIX_MONOTONIC_CLOCK
 #error No usable tick clock function on this platform.
 #endif  // _POSIX_MONOTONIC_CLOCK
 
 // static
 TimeTicks TimeTicks::HighResNow() {
   return Now();
 }
 
 #endif  // !OS_MACOSX
@@ skipping 13 matching lines @@
 
 struct timeval Time::ToTimeVal() const {
   struct timeval result;
   int64 us = us_ - kTimeTToMicrosecondsOffset;
   result.tv_sec = us / Time::kMicrosecondsPerSecond;
   result.tv_usec = us % Time::kMicrosecondsPerSecond;
   return result;
 }
 
 }  // namespace base