Cleanup Mutex and related classes.

src/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
@@ skipping 113 matching lines @@
 
 
 #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_time_(CurrentWallclockTime()),
-            initial_ticks_(TimeTicks::Now()),
-            mutex_(OS::CreateMutex()) {}
-
-  ~Clock() { delete mutex_; }
+            initial_ticks_(TimeTicks::Now()) {}
 
   Time Now() {
     // This must be executed under lock.
-    ScopedLock sl(mutex_);
+    LockGuard<Mutex> lock_guard(&mutex_);
 
     // Calculate the time elapsed since we started our timer.
     TimeDelta elapsed = TimeTicks::Now() - initial_ticks_;
 
     // Check if we don't need to synchronize with the wallclock yet.
     if (elapsed.InMicroseconds() <= kMaxMicrosecondsToAvoidDrift) {
       return initial_time_ + elapsed;
     }
 
     // Resynchronize with the wallclock.
     initial_ticks_ = TimeTicks::Now();
     initial_time_ = CurrentWallclockTime();
     return initial_time_;
   }
 
   Time NowFromSystemTime() {
-    ScopedLock sl(mutex_);
+    // This must be executed under lock.
+    LockGuard<Mutex> lock_guard(&mutex_);
+
+    // Resynchronize with the wallclock.
     initial_ticks_ = TimeTicks::Now();
     initial_time_ = CurrentWallclockTime();
     return initial_time_;
   }
 
  private:
   // Time between resampling the un-granular clock for this API (1 minute).
   static const int64_t kMaxMicrosecondsToAvoidDrift =
       Time::kMicrosecondsPerMinute;
 
   static Time CurrentWallclockTime() {
     FILETIME ft;
     ::GetSystemTimeAsFileTime(&ft);
     return Time::FromFiletime(ft);
   }
 
   TimeTicks initial_ticks_;
   Time initial_time_;
-  Mutex* mutex_;
+  Mutex mutex_;
 };
 
 
 static LazyDynamicInstance<Clock,
     DefaultCreateTrait<Clock>,
     ThreadSafeInitOnceTrait>::type clock = LAZY_DYNAMIC_INSTANCE_INITIALIZER;
 
 
 Time Time::Now() {
   return clock.Pointer()->Now();
@@ skipping 201 matching lines @@
     return (tick_count_ms * Time::kMicrosecondsPerMillisecond) + 1;
   }
 
  private:
   GETTICKCOUNT64PROC func_;
 };
 
 
 class RolloverProtectedTickClock V8_FINAL : public TickClock {
  public:
-  RolloverProtectedTickClock()
-      : mutex_(OS::CreateMutex()), last_seen_now_(0), rollover_ms_(1) {
-    // We initialize rollover_ms_ to 1 to ensure that we will never
-    // return 0 from TimeTicks::HighResNow() and TimeTicks::Now() below.
-  }
-  virtual ~RolloverProtectedTickClock() { delete mutex_; }
+  // We initialize rollover_ms_ to 1 to ensure that we will never
+  // return 0 from TimeTicks::HighResNow() and TimeTicks::Now() below.
+  RolloverProtectedTickClock() : last_seen_now_(0), rollover_ms_(1) {}
+  virtual ~RolloverProtectedTickClock() {}
 
   virtual int64_t Now() V8_OVERRIDE {
-    ScopedLock sl(mutex_);
+    LockGuard<Mutex> lock_guard(&mutex_);
     // We use timeGetTime() to implement TimeTicks::Now(), which rolls over
     // every ~49.7 days. We try to track rollover ourselves, which works if
     // TimeTicks::Now() is called at least every 49 days.
     // Note that we do not use GetTickCount() here, since timeGetTime() gives
     // more predictable delta values, as described here:
     // http://blogs.msdn.com/b/larryosterman/archive/2009/09/02/what-s-the-difference-between-gettickcount-and-timegettime.aspx
     DWORD now = timeGetTime();
     if (now < last_seen_now_) {
       rollover_ms_ += V8_INT64_C(0x100000000);  // ~49.7 days.
     }
     last_seen_now_ = now;
     return (now + rollover_ms_) * Time::kMicrosecondsPerMillisecond;
   }
 
  private:
-  Mutex* mutex_;
+  Mutex mutex_;
   DWORD last_seen_now_;
   int64_t rollover_ms_;
 };
 
 
 struct CreateTickClockTrait {
   static TickClock* Create() {
     // Try to load GetTickCount64() from kernel32.dll (available since Vista).
     HMODULE kernel32 = ::GetModuleHandleA("kernel32.dll");
     ASSERT(kernel32 != NULL);
@@ skipping 85 matching lines @@
   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);
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::internal