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

mojo/edk/embedder/embedder_unittest.cc

 // Copyright 2014 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/embedder/embedder.h"
 
 #include <string.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/test_embedder.h"
 #include "mojo/edk/system/test/test_command_line.h"
 #include "mojo/edk/system/test/test_io_thread.h"
 #include "mojo/edk/system/test/timeouts.h"
-#include "mojo/edk/system/waitable_event.h"
 #include "mojo/edk/test/multiprocess_test_helper.h"
 #include "mojo/edk/test/scoped_ipc_support.h"
 #include "mojo/edk/util/command_line.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/thread_annotations.h"
+#include "mojo/edk/util/waitable_event.h"
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/cpp/system/handle.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using mojo::system::test::TestIOThread;
+using mojo::util::ManualResetWaitableEvent;
 using mojo::util::Mutex;
 using mojo::util::MutexLocker;
 
 namespace mojo {
 namespace embedder {
 namespace {
 
 const MojoHandleSignals kSignalReadadableWritable =
     MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE;
 
@@ skipping 69 matching lines @@
 
   // Valid from creation until whenever it gets closed (by the "owner" of this
   // object).
   // Note: We don't want use the C++ wrappers here, since we want to test the
   // API at the lowest level.
   MojoHandle bootstrap_message_pipe_;
 
   // Set after channel creation has been completed (i.e., the callback to
   // |CreateChannel()| has been called). Also used in the destructor to wait for
   // |DestroyChannel()| completion.
-  mojo::system::ManualResetWaitableEvent event_;
+  ManualResetWaitableEvent event_;
 
   // Valid after channel creation completion until destruction.
   ChannelInfo* channel_info_;
 
   // Whether the destructor should wait until the channel is destroyed.
   bool wait_on_shutdown_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedTestChannel);
 };
 
@@ skipping 76 matching lines @@
   bool TryWait() {
     return !event_.WaitWithTimeout(mojo::system::test::ActionTimeout());
   }
 
   MojoResult wait_result() const {
     MutexLocker l(&wait_result_mutex_);
     return wait_result_;
   }
 
  private:
-  mojo::system::ManualResetWaitableEvent event_;
+  ManualResetWaitableEvent event_;
 
   mutable Mutex wait_result_mutex_;
   MojoResult wait_result_ MOJO_GUARDED_BY(wait_result_mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestAsyncWaiter);
 };
 
 void WriteHello(MessagePipeHandle pipe) {
   static const char kHello[] = "hello";
   CHECK_EQ(MOJO_RESULT_OK,
@@ skipping 173 matching lines @@
 // TODO(vtl): I'm guessing this is true of this test too?
 #define MAYBE_MultiprocessMasterSlave DISABLED_MultiprocessMasterSlave
 #else
 #define MAYBE_MultiprocessMasterSlave MultiprocessMasterSlave
 #endif  // defined(OS_ANDROID)
 TEST_F(EmbedderTest, MAYBE_MultiprocessMasterSlave) {
   mojo::test::ScopedMasterIPCSupport ipc_support(test_io_task_runner());
 
   mojo::test::MultiprocessTestHelper multiprocess_test_helper;
   std::string connection_id;
-  mojo::system::ManualResetWaitableEvent event;
+  ManualResetWaitableEvent event;
   ChannelInfo* channel_info = nullptr;
   ScopedMessagePipeHandle mp = ConnectToSlave(
       nullptr, multiprocess_test_helper.server_platform_handle.Pass(),
-      base::Bind(&mojo::system::ManualResetWaitableEvent::Signal,
-                 base::Unretained(&event)),
+      base::Bind(&ManualResetWaitableEvent::Signal, base::Unretained(&event)),
       nullptr, &connection_id, &channel_info);
   ASSERT_TRUE(mp.is_valid());
   EXPECT_TRUE(channel_info);
   ASSERT_FALSE(connection_id.empty());
 
   multiprocess_test_helper.StartChildWithExtraSwitch(
       "MultiprocessMasterSlave", kConnectionIdFlag, connection_id);
 
   // Send a message saying "hello".
   EXPECT_EQ(MOJO_RESULT_OK, WriteMessageRaw(mp.get(), "hello", 5, nullptr, 0,
@@ skipping 52 matching lines @@
   test::InitWithSimplePlatformSupport();
 
   {
     mojo::test::ScopedSlaveIPCSupport ipc_support(
         test_io_thread.task_runner(), client_platform_handle.Pass());
 
     std::string connection_id;
     ASSERT_TRUE(mojo::system::test::GetTestCommandLine()->GetOptionValue(
         kConnectionIdFlag, &connection_id));
     ASSERT_FALSE(connection_id.empty());
-    mojo::system::ManualResetWaitableEvent event;
+    ManualResetWaitableEvent event;
     ChannelInfo* channel_info = nullptr;
     ScopedMessagePipeHandle mp = ConnectToMaster(
         connection_id,
-        base::Bind(&mojo::system::ManualResetWaitableEvent::Signal,
-                   base::Unretained(&event)),
+        base::Bind(&ManualResetWaitableEvent::Signal, base::Unretained(&event)),
         nullptr, &channel_info);
     ASSERT_TRUE(mp.is_valid());
     EXPECT_TRUE(channel_info);
 
     // Wait for the master to send us a message.
     EXPECT_EQ(MOJO_RESULT_OK,
               Wait(mp.get(), MOJO_HANDLE_SIGNAL_READABLE,
                    mojo::system::test::ActionTimeout(), nullptr));
 
     // It should say "hello".
@@ skipping 276 matching lines @@
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo