Make Time functions go through the Platform layer.

src/platform/default-platform-time.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "platform/time.h"
+#include "default-platform.h"
 
 #if V8_OS_POSIX
 #include <sys/time.h>
 #endif
 #if V8_OS_MACOSX
 #include <mach/mach_time.h>
 #endif
 
-#include <cstring>
-
 #include "checks.h"
 #include "cpu.h"
-#include "platform.h"
+#include "platform/time.h"
+#include "v8.h"
 #if V8_OS_WIN
 #include "win32-headers.h"
 #endif
 
 namespace v8 {
 namespace internal {
 
-TimeDelta TimeDelta::FromDays(int days) {
-  return TimeDelta(days * Time::kMicrosecondsPerDay);
-}
-
-
-TimeDelta TimeDelta::FromHours(int hours) {
-  return TimeDelta(hours * Time::kMicrosecondsPerHour);
-}
-
-
-TimeDelta TimeDelta::FromMinutes(int minutes) {
-  return TimeDelta(minutes * Time::kMicrosecondsPerMinute);
-}
-
-
-TimeDelta TimeDelta::FromSeconds(int64_t seconds) {
-  return TimeDelta(seconds * Time::kMicrosecondsPerSecond);
-}
-
-
-TimeDelta TimeDelta::FromMilliseconds(int64_t milliseconds) {
-  return TimeDelta(milliseconds * Time::kMicrosecondsPerMillisecond);
-}
-
-
-TimeDelta TimeDelta::FromNanoseconds(int64_t nanoseconds) {
-  return TimeDelta(nanoseconds / Time::kNanosecondsPerMicrosecond);
-}
-
-
-int TimeDelta::InDays() const {
-  return static_cast<int>(delta_ / Time::kMicrosecondsPerDay);
-}
-
-
-int TimeDelta::InHours() const {
-  return static_cast<int>(delta_ / Time::kMicrosecondsPerHour);
-}
-
-
-int TimeDelta::InMinutes() const {
-  return static_cast<int>(delta_ / Time::kMicrosecondsPerMinute);
-}
-
-
-double TimeDelta::InSecondsF() const {
-  return static_cast<double>(delta_) / Time::kMicrosecondsPerSecond;
-}
-
-
-int64_t TimeDelta::InSeconds() const {
-  return delta_ / Time::kMicrosecondsPerSecond;
-}
-
-
-double TimeDelta::InMillisecondsF() const {
-  return static_cast<double>(delta_) / Time::kMicrosecondsPerMillisecond;
-}
-
-
-int64_t TimeDelta::InMilliseconds() const {
-  return delta_ / Time::kMicrosecondsPerMillisecond;
-}
-
-
-int64_t TimeDelta::InNanoseconds() const {
-  return delta_ * Time::kNanosecondsPerMicrosecond;
-}
-
-
-#if V8_OS_MACOSX
-
-TimeDelta TimeDelta::FromMachTimespec(struct mach_timespec ts) {
-  ASSERT_GE(ts.tv_nsec, 0);
-  ASSERT_LT(ts.tv_nsec,
-            static_cast<long>(Time::kNanosecondsPerSecond));  // NOLINT
-  return TimeDelta(ts.tv_sec * Time::kMicrosecondsPerSecond +
-                   ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
-}
-
-
-struct mach_timespec TimeDelta::ToMachTimespec() const {
-  struct mach_timespec ts;
-  ASSERT(delta_ >= 0);
-  ts.tv_sec = delta_ / Time::kMicrosecondsPerSecond;
-  ts.tv_nsec = (delta_ % Time::kMicrosecondsPerSecond) *
-      Time::kNanosecondsPerMicrosecond;
-  return ts;
-}
-
-#endif  // V8_OS_MACOSX
-
-
-#if V8_OS_POSIX
-
-TimeDelta TimeDelta::FromTimespec(struct timespec ts) {
-  ASSERT_GE(ts.tv_nsec, 0);
-  ASSERT_LT(ts.tv_nsec,
-            static_cast<long>(Time::kNanosecondsPerSecond));  // NOLINT
-  return TimeDelta(ts.tv_sec * Time::kMicrosecondsPerSecond +
-                   ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
-}
-
-
-struct timespec TimeDelta::ToTimespec() const {
-  struct timespec ts;
-  ts.tv_sec = delta_ / Time::kMicrosecondsPerSecond;
-  ts.tv_nsec = (delta_ % Time::kMicrosecondsPerSecond) *
-      Time::kNanosecondsPerMicrosecond;
-  return ts;
-}
-
-#endif  // V8_OS_POSIX
-
-
 #if V8_OS_WIN
 
 // We implement time using the high-resolution timers so that we can get
 // timeouts which are smaller than 10-15ms. To avoid any drift, we
 // periodically resync the internal clock to the system clock.
 class Clock V8_FINAL {
  public:
   Clock() : initial_ticks_(GetSystemTicks()), initial_time_(GetSystemTime()) {}
 
   Time Now() {
@@ skipping 40 matching lines @@
   Time initial_time_;
   Mutex mutex_;
 };
 
 
 static LazyStaticInstance<Clock,
     DefaultConstructTrait<Clock>,
     ThreadSafeInitOnceTrait>::type clock = LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
-Time Time::Now() {
-  return clock.Pointer()->Now();
+double DefaultPlatform::CurrentTime() {
+  return clock.Pointer()->Now().ToInternalValue();
 }
 
 
-Time Time::NowFromSystemTime() {
-  return clock.Pointer()->NowFromSystemTime();
-}
-
-
-// Time between windows epoch and standard epoch.
-static const int64_t kTimeToEpochInMicroseconds = V8_INT64_C(11644473600000000);
-
-
-Time Time::FromFiletime(FILETIME ft) {
-  if (ft.dwLowDateTime == 0 && ft.dwHighDateTime == 0) {
-    return Time();
-  }
-  if (ft.dwLowDateTime == std::numeric_limits<DWORD>::max() &&
-      ft.dwHighDateTime == std::numeric_limits<DWORD>::max()) {
-    return Max();
-  }
-  int64_t us = (static_cast<uint64_t>(ft.dwLowDateTime) +
-                (static_cast<uint64_t>(ft.dwHighDateTime) << 32)) / 10;
-  return Time(us - kTimeToEpochInMicroseconds);
-}
-
-
-FILETIME Time::ToFiletime() const {
-  ASSERT(us_ >= 0);
-  FILETIME ft;
-  if (IsNull()) {
-    ft.dwLowDateTime = 0;
-    ft.dwHighDateTime = 0;
-    return ft;
-  }
-  if (IsMax()) {
-    ft.dwLowDateTime = std::numeric_limits<DWORD>::max();
-    ft.dwHighDateTime = std::numeric_limits<DWORD>::max();
-    return ft;
-  }
-  uint64_t us = static_cast<uint64_t>(us_ + kTimeToEpochInMicroseconds) * 10;
-  ft.dwLowDateTime = static_cast<DWORD>(us);
-  ft.dwHighDateTime = static_cast<DWORD>(us >> 32);
-  return ft;
+double DefaultPlatform::CurrentTimeFromSystemTime() {
+  return clock.Pointer()->NowFromSystemTime().ToInternalValue();
 }
 
 #elif V8_OS_POSIX
 
-Time Time::Now() {
+int64_t DefaultPlatform::CurrentTime() {
   struct timeval tv;
   int result = gettimeofday(&tv, NULL);
   ASSERT_EQ(0, result);
   USE(result);
-  return FromTimeval(tv);
+  return Time::FromTimeval(tv).ToInternalValue();
 }
 
 
-Time Time::NowFromSystemTime() {
-  return Now();
-}
-
-
-Time Time::FromTimespec(struct timespec ts) {
-  ASSERT(ts.tv_nsec >= 0);
-  ASSERT(ts.tv_nsec < static_cast<long>(kNanosecondsPerSecond));  // NOLINT
-  if (ts.tv_nsec == 0 && ts.tv_sec == 0) {
-    return Time();
-  }
-  if (ts.tv_nsec == static_cast<long>(kNanosecondsPerSecond - 1) &&  // NOLINT
-      ts.tv_sec == std::numeric_limits<time_t>::max()) {
-    return Max();
-  }
-  return Time(ts.tv_sec * kMicrosecondsPerSecond +
-              ts.tv_nsec / kNanosecondsPerMicrosecond);
-}
-
-
-struct timespec Time::ToTimespec() const {
-  struct timespec ts;
-  if (IsNull()) {
-    ts.tv_sec = 0;
-    ts.tv_nsec = 0;
-    return ts;
-  }
-  if (IsMax()) {
-    ts.tv_sec = std::numeric_limits<time_t>::max();
-    ts.tv_nsec = static_cast<long>(kNanosecondsPerSecond - 1);  // NOLINT
-    return ts;
-  }
-  ts.tv_sec = us_ / kMicrosecondsPerSecond;
-  ts.tv_nsec = (us_ % kMicrosecondsPerSecond) * kNanosecondsPerMicrosecond;
-  return ts;
-}
-
-
-Time Time::FromTimeval(struct timeval tv) {
-  ASSERT(tv.tv_usec >= 0);
-  ASSERT(tv.tv_usec < static_cast<suseconds_t>(kMicrosecondsPerSecond));
-  if (tv.tv_usec == 0 && tv.tv_sec == 0) {
-    return Time();
-  }
-  if (tv.tv_usec == static_cast<suseconds_t>(kMicrosecondsPerSecond - 1) &&
-      tv.tv_sec == std::numeric_limits<time_t>::max()) {
-    return Max();
-  }
-  return Time(tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec);
-}
-
-
-struct timeval Time::ToTimeval() const {
-  struct timeval tv;
-  if (IsNull()) {
-    tv.tv_sec = 0;
-    tv.tv_usec = 0;
-    return tv;
-  }
-  if (IsMax()) {
-    tv.tv_sec = std::numeric_limits<time_t>::max();
-    tv.tv_usec = static_cast<suseconds_t>(kMicrosecondsPerSecond - 1);
-    return tv;
-  }
-  tv.tv_sec = us_ / kMicrosecondsPerSecond;
-  tv.tv_usec = us_ % kMicrosecondsPerSecond;
-  return tv;
+int64_t DefaultPlatform::CurrentTimeFromSystemTime() {
+  return CurrentTime();
 }
 
 #endif  // V8_OS_WIN
 
 
-Time Time::FromJsTime(double ms_since_epoch) {
-  // The epoch is a valid time, so this constructor doesn't interpret
-  // 0 as the null time.
-  if (ms_since_epoch == std::numeric_limits<double>::max()) {
-    return Max();
-  }
-  return Time(
-      static_cast<int64_t>(ms_since_epoch * kMicrosecondsPerMillisecond));
-}
-
-
-double Time::ToJsTime() const {
-  if (IsNull()) {
-    // Preserve 0 so the invalid result doesn't depend on the platform.
-    return 0;
-  }
-  if (IsMax()) {
-    // Preserve max without offset to prevent overflow.
-    return std::numeric_limits<double>::max();
-  }
-  return static_cast<double>(us_) / kMicrosecondsPerMillisecond;
-}
-
-
 #if V8_OS_WIN
 
 class TickClock {
  public:
   virtual ~TickClock() {}
   virtual int64_t Now() = 0;
   virtual bool IsHighResolution() = 0;
 };
 
 
@@ skipping 116 matching lines @@
     // is unreliable, fallback to the low-resolution tick clock.
     CPU cpu;
     if (strcmp(cpu.vendor(), "AuthenticAMD") == 0 && cpu.family() == 15) {
       return tick_clock.Pointer();
     }
 
     return new HighResolutionTickClock(ticks_per_second.QuadPart);
   }
 };
 
-
 static LazyDynamicInstance<TickClock,
     CreateHighResTickClockTrait,
     ThreadSafeInitOnceTrait>::type high_res_tick_clock =
         LAZY_DYNAMIC_INSTANCE_INITIALIZER;
 
 
-TimeTicks TimeTicks::Now() {
-  // Make sure we never return 0 here.
-  TimeTicks ticks(tick_clock.Pointer()->Now());
-  ASSERT(!ticks.IsNull());
-  return ticks;
+int64_t DefaultPlatform::TimeTicksNow() {
+  return tick_clock.Pointer()->Now();
 }
 
 
-TimeTicks TimeTicks::HighResolutionNow() {
-  // Make sure we never return 0 here.
-  TimeTicks ticks(high_res_tick_clock.Pointer()->Now());
-  ASSERT(!ticks.IsNull());
-  return ticks;
+int64_t DefaultPlatform::TimeTicksHighResNow() {
+  return high_res_tick_clock.Pointer()->Now();
 }
 
 
-// static
-bool TimeTicks::IsHighResolutionClockWorking() {
+bool DefaultPlatform::TimeTicksHasHighRes() {
   return high_res_tick_clock.Pointer()->IsHighResolution();
 }
 
 #else  // V8_OS_WIN
 
-TimeTicks TimeTicks::Now() {
-  return HighResolutionNow();
-}
-
-
-TimeTicks TimeTicks::HighResolutionNow() {
+int64_t DefaultPlatform::TimeTicksHighResNow() {
   int64_t ticks;
 #if V8_OS_MACOSX
   static struct mach_timebase_info info;
   if (info.denom == 0) {
     kern_return_t result = mach_timebase_info(&info);
     ASSERT_EQ(KERN_SUCCESS, result);
     USE(result);
   }
   ticks = (mach_absolute_time() / Time::kNanosecondsPerMicrosecond *
            info.numer / info.denom);
@@ skipping 10 matching lines @@
   ticks = (tv.tv_sec * Time::kMicrosecondsPerSecond + tv.tv_usec);
 #elif V8_OS_POSIX
   struct timespec ts;
   int result = clock_gettime(CLOCK_MONOTONIC, &ts);
   ASSERT_EQ(0, result);
   USE(result);
   ticks = (ts.tv_sec * Time::kMicrosecondsPerSecond +
            ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
 #endif  // V8_OS_MACOSX
   // Make sure we never return 0 here.
-  return TimeTicks(ticks + 1);
+  return ticks + 1;
 }
 
 
-// static
-bool TimeTicks::IsHighResolutionClockWorking() {
+int64_t DefaultPlatform::TimeTicksNow() {
+  return DefaultPlatform::TimeTicksHighResNow();
+}
+
+
+bool DefaultPlatform::TimeTicksHasHighRes() {
   return true;
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::internal