Reland "EDK: Move //mojo/edk/system/waitable_event* to edk/util."

mojo/edk/util/waitable_event.cc

 // Copyright 2015 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 "mojo/edk/system/waitable_event.h"
+#include "mojo/edk/util/waitable_event.h"
 
-#include "base/logging.h"
-#include "base/time/time.h"
+#include "build/build_config.h"
+#include "mojo/edk/util/logging_internal.h"
 
-using mojo::util::CondVar;
-using mojo::util::Mutex;
-using mojo::util::MutexLocker;
+#if defined(OS_MACOSX) || defined(OS_IOS)
+#include <mach/kern_return.h>
+#include <mach/mach_time.h>
+#else
+#include <errno.h>
+#include <time.h>
+#endif  // defined(OS_MACOSX) || defined(OS_IOS)
 
 namespace mojo {
-namespace system {
+namespace util {
 
 namespace {
 
+// Mac OS X/iOS don't have a (useful) |clock_gettime()|.
+// Note: Chromium's |base::TimeTicks::Now()| uses boot time (obtained via
+// |sysctl()| with |CTL_KERN|/|KERN_BOOTTIME|). For our current purposes,
+// monotonic time (which pauses during sleeps) is sufficient. TODO(vtl): If/when
+// we use this for other purposes, maybe we should use boot time (maybe also on
+// POSIX).
+#if defined(OS_MACOSX) || defined(OS_IOS)
+mach_timebase_info_data_t GetMachTimebaseInfo() {
+  mach_timebase_info_data_t timebase_info = {};
+  kern_return_t error = mach_timebase_info(&timebase_info);
+  INTERNAL_DCHECK(error == KERN_SUCCESS);
+  return timebase_info;
+}
+
+// Returns the number of microseconds elapsed since epoch start (according to a
+// monotonic clock).
+uint64_t Now() {
+  const uint64_t kNanosecondsPerMicrosecond = 1000ULL;
+
+  // TODO(vtl): Without magic statics, this is not thread-safe, at least the
+  // first time around (neither is Mac Chromium's |base::TimeTicks::Now()|)!
+  static mach_timebase_info_data_t timebase_info = GetMachTimebaseInfo();
+
+  // |timebase_info| converts absolute time tick units into nanoseconds. By
+  // dividing by 1000 first, we reduce the risk of overflowing (at the cost of a
+  // risk of a slight loss in precision).
+  return mach_absolute_time() / kNanosecondsPerMicrosecond *
+         timebase_info.numer / timebase_info.denom;
+}
+#else
+// Returns the number of microseconds elapsed since epoch start (according to a
+// monotonic clock).
+uint64_t Now() {
+  const uint64_t kMicrosecondsPerSecond = 1000000ULL;
+  const uint64_t kNanosecondsPerMicrosecond = 1000ULL;
+
+  struct timespec now;
+  int error = clock_gettime(CLOCK_MONOTONIC, &now);
+  INTERNAL_DCHECK_WITH_ERRNO(!error, "clock_gettime", errno);
+  INTERNAL_DCHECK(now.tv_sec >= 0);
+  INTERNAL_DCHECK(now.tv_nsec >= 0);
+
+  return static_cast<uint64_t>(now.tv_sec) * kMicrosecondsPerSecond +
+         static_cast<uint64_t>(now.tv_nsec) / kNanosecondsPerMicrosecond;
+}
+#endif  // defined(OS_MACOSX) || defined(OS_IOS)
+
 // Waits with a timeout on |condition()|. Returns true on timeout, or false if
 // |condition()| ever returns true. |condition()| should have no side effects
 // (and will always be called with |*mutex| held).
 template <typename ConditionFn>
 bool WaitWithTimeoutImpl(Mutex* mutex,
                          CondVar* cv,
                          ConditionFn condition,
                          uint64_t timeout_microseconds)
     MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex) {
   mutex->AssertHeld();
 
   if (condition())
     return false;
 
   // We may get spurious wakeups.
   uint64_t wait_remaining = timeout_microseconds;
-  auto start = base::TimeTicks::Now();
+  uint64_t start = Now();
   while (true) {
     if (cv->WaitWithTimeout(mutex, wait_remaining))
       return true;  // Definitely timed out.
 
     // We may have been awoken.
     if (condition())
       return false;
 
     // Or the wakeup may have been spurious.
-    auto now = base::TimeTicks::Now();
-    DCHECK_GE(now, start);
-    uint64_t elapsed = static_cast<uint64_t>((now - start).InMicroseconds());
+    uint64_t now = Now();
+    INTERNAL_DCHECK(now >= start);
+    uint64_t elapsed = now - start;
     // It's possible that we may have timed out anyway.
     if (elapsed >= timeout_microseconds)
       return true;
 
     // Otherwise, recalculate the amount that we have left to wait.
     wait_remaining = timeout_microseconds - elapsed;
   }
 }
 
 }  // namespace
@@ skipping 21 matching lines @@
 bool AutoResetWaitableEvent::WaitWithTimeout(uint64_t timeout_microseconds) {
   MutexLocker locker(&mutex_);
 
   if (signaled_) {
     signaled_ = false;
     return false;
   }
 
   // We may get spurious wakeups.
   uint64_t wait_remaining = timeout_microseconds;
-  auto start = base::TimeTicks::Now();
+  uint64_t start = Now();
   while (true) {
     if (cv_.WaitWithTimeout(&mutex_, wait_remaining))
       return true;  // Definitely timed out.
 
     // We may have been awoken.
     if (signaled_)
       break;
 
     // Or the wakeup may have been spurious.
-    auto now = base::TimeTicks::Now();
-    DCHECK_GE(now, start);
-    uint64_t elapsed = static_cast<uint64_t>((now - start).InMicroseconds());
+    uint64_t now = Now();
+    INTERNAL_DCHECK(now >= start);
+    uint64_t elapsed = now - start;
     // It's possible that we may have timed out anyway.
     if (elapsed >= timeout_microseconds)
       return true;
 
     // Otherwise, recalculate the amount that we have left to wait.
     wait_remaining = timeout_microseconds - elapsed;
   }
 
   signaled_ = false;
   return false;
@@ skipping 36 matching lines @@
   auto last_signal_id = signal_id_;
   // Disable thread-safety analysis for the lambda: We could annotate it with
   // |MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_)|, but then the analyzer currently
   // isn't able to figure out that |WaitWithTimeoutImpl()| calls it while
   // holding |mutex_|.
   bool rv = WaitWithTimeoutImpl(
       &mutex_, &cv_, [this, last_signal_id]() MOJO_NO_THREAD_SAFETY_ANALYSIS {
         // Also check |signaled_| in case we're already signaled.
         return signaled_ || signal_id_ != last_signal_id;
       }, timeout_microseconds);
-  DCHECK(rv || signaled_ || signal_id_ != last_signal_id);
+  INTERNAL_DCHECK(rv || signaled_ || signal_id_ != last_signal_id);
   return rv;
 }
 
 bool ManualResetWaitableEvent::IsSignaledForTest() {
   MutexLocker locker(&mutex_);
   return signaled_;
 }
 
-}  // namespace system
+}  // namespace util
 }  // namespace mojo