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

mojo/edk/system/waitable_event.h

Index: mojo/edk/system/waitable_event.h
diff --git a/mojo/edk/system/waitable_event.h b/mojo/edk/system/waitable_event.h
deleted file mode 100644
index 38c75e06564db3c1c1b44d236188be3b95c0172e..0000000000000000000000000000000000000000
--- a/mojo/edk/system/waitable_event.h
+++ /dev/null
@@ -1,127 +0,0 @@
-// 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.
-
-// Provides classes with functionality analogous to (but much more limited than)
-// Chromium's |base::WaitableEvent|, which in turn provides functionality
-// analogous to Windows's Event. (Unlike these two, we have separate types for
-// the manual- and auto-reset versions.)
-
-#ifndef MOJO_EDK_SYSTEM_WAITABLE_EVENT_H_
-#define MOJO_EDK_SYSTEM_WAITABLE_EVENT_H_
-
-#include "mojo/edk/util/cond_var.h"
-#include "mojo/edk/util/mutex.h"
-#include "mojo/edk/util/thread_annotations.h"
-#include "mojo/public/cpp/system/macros.h"
-
-namespace mojo {
-namespace system {
-
-// AutoResetWaitableEvent ------------------------------------------------------
-
-// An event that can be signaled and waited on. This version automatically
-// returns to the unsignaled state after unblocking one waiter. (This is similar
-// to Windows's auto-reset Event, which is also imitated by Chromium's
-// auto-reset |base::WaitableEvent|. However, there are some limitations -- see
-// |Signal()|.) This class is thread-safe.
-class AutoResetWaitableEvent {
- public:
-  AutoResetWaitableEvent() {}
-  ~AutoResetWaitableEvent() {}
-
-  // Put the event in the signaled state. Exactly one |Wait()| will be unblocked
-  // and the event will be returned to the unsignaled state.
-  //
-  // Notes (these are arguably bugs, but not worth working around):
-  // * That |Wait()| may be one that occurs on the calling thread, *after* the
-  //   call to |Signal()|.
-  // * A |Signal()|, followed by a |Reset()|, may cause *no* waiting thread to
-  //   be unblocked.
-  // * We rely on pthreads's queueing for picking which waiting thread to
-  //   unblock, rather than enforcing FIFO ordering.
-  void Signal();
-
-  // Put the event into the unsignaled state. Generally, this is not recommended
-  // on an auto-reset event (see notes above).
-  void Reset();
-
-  // Blocks the calling thread until the event is signaled. Upon unblocking, the
-  // event is returned to the unsignaled state, so that (unless |Reset()| is
-  // called) each |Signal()| unblocks exactly one |Wait()|.
-  void Wait();
-
-  // Like |Wait()|, but with a timeout. Also unblocks if |timeout_microseconds|
-  // without being signaled in which case it returns true (otherwise, it returns
-  // false).
-  bool WaitWithTimeout(uint64_t timeout_microseconds);
-
-  // Returns whether this event is in a signaled state or not. For use in tests
-  // only (in general, this is racy). Note: Unlike
-  // |base::WaitableEvent::IsSignaled()|, this doesn't reset the signaled state.
-  bool IsSignaledForTest();
-
- private:
-  util::CondVar cv_;
-  util::Mutex mutex_;
-
-  // True if this event is in the signaled state.
-  bool signaled_ MOJO_GUARDED_BY(mutex_) = false;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(AutoResetWaitableEvent);
-};
-
-// ManualResetWaitableEvent ----------------------------------------------------
-
-// An event that can be signaled and waited on. This version remains signaled
-// until explicitly reset. (This is similar to Windows's manual-reset Event,
-// which is also imitated by Chromium's manual-reset |base::WaitableEvent|.)
-// This class is thread-safe.
-class ManualResetWaitableEvent {
- public:
-  ManualResetWaitableEvent() {}
-  ~ManualResetWaitableEvent() {}
-
-  // Put the event into the unsignaled state.
-  void Reset();
-
-  // Put the event in the signaled state. If this is a manual-reset event, it
-  // wakes all waiting threads (blocked on |Wait()| or |WaitWithTimeout()|).
-  // Otherwise, it wakes a single waiting thread (and returns to the unsignaled
-  // state), if any; if there are none, it remains signaled.
-  void Signal();
-
-  // Blocks the calling thread until the event is signaled.
-  void Wait();
-
-  // Like |Wait()|, but with a timeout. Also unblocks if |timeout_microseconds|
-  // without being signaled in which case it returns true (otherwise, it returns
-  // false).
-  bool WaitWithTimeout(uint64_t timeout_microseconds);
-
-  // Returns whether this event is in a signaled state or not. For use in tests
-  // only (in general, this is racy).
-  bool IsSignaledForTest();
-
- private:
-  util::CondVar cv_;
-  util::Mutex mutex_;
-
-  // True if this event is in the signaled state.
-  bool signaled_ MOJO_GUARDED_BY(mutex_) = false;
-
-  // While |CondVar::SignalAll()| (|pthread_cond_broadcast()|) will wake all
-  // waiting threads, one has to deal with spurious wake-ups. Checking
-  // |signaled_| isn't sufficient, since another thread may have been awoken and
-  // (manually) reset |signaled_|. This is a counter that is incremented in
-  // |Signal()| before calling |CondVar::SignalAll()|. A waiting thread knows it
-  // was awoken if |signal_id_| is different from when it started waiting.
-  unsigned signal_id_ MOJO_GUARDED_BY(mutex_) = 0u;
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(ManualResetWaitableEvent);
-};
-
-}  // namespace system
-}  // namespace mojo
-
-#endif  // MOJO_EDK_SYSTEM_WAITABLE_EVENT_H_