EDK: Move mutex.*, cond_var.*, and thread_annotations.h to //mojo/edk/util.

mojo/edk/system/waitable_event.h

 // 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/system/cond_var.h"
-#include "mojo/edk/system/mutex.h"
-#include "mojo/edk/system/thread_annotations.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
@@ skipping 29 matching lines @@
   // 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:
-  CondVar cv_;
-  Mutex mutex_;
+  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
@@ skipping 20 matching lines @@
   // 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:
-  CondVar cv_;
-  Mutex mutex_;
+  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_