The Tor Browser: ipc/chromium/src/base/time_posix.cc@6474c204b198 (annotated)

ipc/chromium/src/base/time_posix.cc@6474c204b198 (annotated)

ipc/chromium/src/base/time_posix.cc

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2006-2008 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"
 #ifdef OS_MACOSX
 #include <mach/mach_time.h>
 #endif
 #include <sys/time.h>
 #ifdef ANDROID
 #include <time64.h>
 #else
 #include <time.h>
 #endif
 #if defined(ANDROID) || defined(OS_POSIX)
 #include <unistd.h>
 #endif
 #include <limits>
 #include "base/basictypes.h"
 #include "base/logging.h"
 namespace base {
 // 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 -----------------------------------------------------------------------
 // Some functions in time.cc use time_t directly, so we provide a zero offset
 // for them.  The epoch is 1970-01-01 00:00:00 UTC.
 // static
 const int64_t Time::kTimeTToMicrosecondsOffset = GG_INT64_C(0);
 // static
 Time Time::Now() {
   struct timeval tv;
   struct timezone tz = { 0, 0 };  // UTC
   if (gettimeofday(&tv, &tz) != 0) {
     DCHECK(0) << "Could not determine time of day";
   }
   // Combine seconds and microseconds in a 64-bit field containing microseconds
   // since the epoch.  That's enough for nearly 600 centuries.
   return tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec;
 }
 // static
 Time Time::NowFromSystemTime() {
   // Just use Now() because Now() returns the system time.
   return Now();
 }
 // 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
   timestruct.tm_gmtoff = 0;     // not a POSIX field, so mktime/timegm ignore
   timestruct.tm_zone   = NULL;  // not a POSIX field, so mktime/timegm ignore
   time_t seconds;
 #ifdef ANDROID
     seconds = mktime(&timestruct);
 #else
   if (is_local)
     seconds = mktime(&timestruct);
   else
     seconds = timegm(&timestruct);
 #endif
   int64_t 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() *
                      kMillisecondsPerSecond;
     } else {
       milliseconds = (std::numeric_limits<time_t>::max() *
                       kMillisecondsPerSecond) +
                      kMillisecondsPerSecond - 1;
     }
   } else {
     milliseconds = seconds * kMillisecondsPerSecond + exploded.millisecond;
   }
   return Time(milliseconds * kMicrosecondsPerMillisecond);
 }
 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.
   int64_t milliseconds = us_ / kMicrosecondsPerMillisecond;
   time_t seconds = milliseconds / kMillisecondsPerSecond;
   struct tm timestruct;
   if (is_local)
     localtime_r(&seconds, &timestruct);
   else
     gmtime_r(&seconds, &timestruct);
   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  = milliseconds % kMillisecondsPerSecond;
 }
 // TimeTicks ------------------------------------------------------------------
 // static
 TimeTicks TimeTicks::Now() {
   uint64_t absolute_micro;
 #if 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);
     DCHECK(kr == KERN_SUCCESS);
   }
   // 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.
   absolute_micro = mach_absolute_time() / Time::kNanosecondsPerMicrosecond *
                    timebase_info.numer / 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.
 #elif defined(OS_OPENBSD) || defined(OS_POSIX) && \
       defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
   struct timespec ts;
   if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
     NOTREACHED() << "clock_gettime(CLOCK_MONOTONIC) failed.";
     return TimeTicks();
   }
   absolute_micro =
       (static_cast<int64_t>(ts.tv_sec) * Time::kMicrosecondsPerSecond) +
       (static_cast<int64_t>(ts.tv_nsec) / Time::kNanosecondsPerMicrosecond);
 #else  // _POSIX_MONOTONIC_CLOCK
 #error No usable tick clock function on this platform.
 #endif  // _POSIX_MONOTONIC_CLOCK
   return TimeTicks(absolute_micro);
 }
 // static
 TimeTicks TimeTicks::HighResNow() {
   return Now();
 }
 }  // namespace base

The Tor Browser / annotate

ipc/chromium/src/base/time_posix.cc@6474c204b198 (annotated)

ipc/chromium/src/base/time_posix.cc