Rename ASSERT* to DCHECK*.

src/base/platform/time.cc

 // Copyright 2013 the V8 project 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 "src/base/platform/time.h"
 
 #if V8_OS_POSIX
 #include <fcntl.h>  // for O_RDONLY
 #include <sys/time.h>
 #include <unistd.h>
@@ skipping 81 matching lines @@
 
 
 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,
+  DCHECK_GE(ts.tv_nsec, 0);
+  DCHECK_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);
+  DCHECK(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,
+  DCHECK_GE(ts.tv_nsec, 0);
+  DCHECK_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) *
@@ skipping 86 matching lines @@
       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);
+  DCHECK(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;
 }
 
 #elif V8_OS_POSIX
 
 Time Time::Now() {
   struct timeval tv;
   int result = gettimeofday(&tv, NULL);
-  ASSERT_EQ(0, result);
+  DCHECK_EQ(0, result);
   USE(result);
   return FromTimeval(tv);
 }
 
 
 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
+  DCHECK(ts.tv_nsec >= 0);
+  DCHECK(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);
 }
@@ skipping 11 matching lines @@
     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));
+  DCHECK(tv.tv_usec >= 0);
+  DCHECK(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);
 }
 
@@ skipping 77 matching lines @@
 // With recent updates on HAL and newer BIOS, QPC is getting more reliable but
 // it should be used with caution.
 //
 // (3) System time. The system time provides a low-resolution (typically 10ms
 // to 55 milliseconds) time stamp but is comparatively less expensive to
 // retrieve and more reliable.
 class HighResolutionTickClock V8_FINAL : public TickClock {
  public:
   explicit HighResolutionTickClock(int64_t ticks_per_second)
       : ticks_per_second_(ticks_per_second) {
-    ASSERT_LT(0, ticks_per_second);
+    DCHECK_LT(0, ticks_per_second);
   }
   virtual ~HighResolutionTickClock() {}
 
   virtual int64_t Now() V8_OVERRIDE {
     LARGE_INTEGER now;
     BOOL result = QueryPerformanceCounter(&now);
-    ASSERT(result);
+    DCHECK(result);
     USE(result);
 
     // Intentionally calculate microseconds in a round about manner to avoid
     // overflow and precision issues. Think twice before simplifying!
     int64_t whole_seconds = now.QuadPart / ticks_per_second_;
     int64_t leftover_ticks = now.QuadPart % ticks_per_second_;
     int64_t ticks = (whole_seconds * Time::kMicrosecondsPerSecond) +
         ((leftover_ticks * Time::kMicrosecondsPerSecond) / ticks_per_second_);
 
     // Make sure we never return 0 here, so that TimeTicks::HighResolutionNow()
@@ skipping 75 matching lines @@
 
 
 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());
+  DCHECK(!ticks.IsNull());
   return ticks;
 }
 
 
 TimeTicks TimeTicks::HighResolutionNow() {
   // Make sure we never return 0 here.
   TimeTicks ticks(high_res_tick_clock.Pointer()->Now());
-  ASSERT(!ticks.IsNull());
+  DCHECK(!ticks.IsNull());
   return ticks;
 }
 
 
 // static
 bool TimeTicks::IsHighResolutionClockWorking() {
   return high_res_tick_clock.Pointer()->IsHighResolution();
 }
 
 
@@ skipping 10 matching lines @@
   return HighResolutionNow();
 }
 
 
 TimeTicks TimeTicks::HighResolutionNow() {
   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);
+    DCHECK_EQ(KERN_SUCCESS, result);
     USE(result);
   }
   ticks = (mach_absolute_time() / Time::kNanosecondsPerMicrosecond *
            info.numer / info.denom);
 #elif V8_OS_SOLARIS
   ticks = (gethrtime() / Time::kNanosecondsPerMicrosecond);
 #elif V8_LIBRT_NOT_AVAILABLE
   // TODO(bmeurer): This is a temporary hack to support cross-compiling
   // Chrome for Android in AOSP. Remove this once AOSP is fixed, also
   // cleanup the tools/gyp/v8.gyp file.
   struct timeval tv;
   int result = gettimeofday(&tv, NULL);
-  ASSERT_EQ(0, result);
+  DCHECK_EQ(0, result);
   USE(result);
   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);
+  DCHECK_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);
 }
 
 
 // static
@@ skipping 73 matching lines @@
 
 
 // static
 bool TimeTicks::KernelTimestampAvailable() {
   return kernel_tick_clock.Pointer()->Available();
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::base