EDK: Split embedder.* into embedder.* and multiprocess_embedder.*.

mojo/edk/embedder/multiprocess_embedder_unittest.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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/embedder/embedder.h"
+#include "mojo/edk/embedder/multiprocess_embedder.h"
 
 #include <string.h>
 
 #include <memory>
 
 #include "base/logging.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/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/ref_ptr.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/c/system/functions.h"
+#include "mojo/public/c/system/types.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::platform::PlatformHandleWatcher;
 using mojo::platform::ScopedPlatformHandle;
 using mojo::platform::TaskRunner;
 using mojo::system::test::TestIOThread;
 using mojo::util::ManualResetWaitableEvent;
-using mojo::util::Mutex;
-using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace embedder {
 namespace {
 
 const MojoHandleSignals kSignalReadadableWritable =
     MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE;
 
 const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE |
@@ skipping 68 matching lines @@
 
   // 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);
 };
 
-class EmbedderTest : public testing::Test {
+class MultiprocessEmbedderTest : public testing::Test {
  public:
-  EmbedderTest() : test_io_thread_(TestIOThread::StartMode::AUTO) {}
-  ~EmbedderTest() override {}
+  MultiprocessEmbedderTest() : test_io_thread_(TestIOThread::StartMode::AUTO) {}
+  ~MultiprocessEmbedderTest() override {}
 
  protected:
   TestIOThread& test_io_thread() { return test_io_thread_; }
   const RefPtr<TaskRunner>& test_io_task_runner() {
     return test_io_thread_.task_runner();
   }
   PlatformHandleWatcher* test_io_watcher() {
     return test_io_thread_.platform_handle_watcher();
   }
 
  private:
   void SetUp() override { test::InitWithSimplePlatformSupport(); }
 
   void TearDown() override { EXPECT_TRUE(test::Shutdown()); }
 
   TestIOThread test_io_thread_;
 
-  MOJO_DISALLOW_COPY_AND_ASSIGN(EmbedderTest);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(MultiprocessEmbedderTest);
 };
 
-TEST_F(EmbedderTest, ChannelsBasic) {
+TEST_F(MultiprocessEmbedderTest, ChannelsBasic) {
   mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone(),
                                            test_io_watcher());
 
   PlatformChannelPair channel_pair;
   ScopedTestChannel server_channel(channel_pair.PassServerHandle());
   MojoHandle server_mp = server_channel.bootstrap_message_pipe();
   EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
   ScopedTestChannel client_channel(channel_pair.PassClientHandle());
   MojoHandle client_mp = client_channel.bootstrap_message_pipe();
   EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
@@ skipping 25 matching lines @@
 
   // By this point, these waits should basically be no-ops (since we've waited
   // for the client message pipe to become readable, which implies that both
   // the server and client channels were completely created).
   server_channel.WaitForChannelCreationCompletion();
   client_channel.WaitForChannelCreationCompletion();
   EXPECT_TRUE(server_channel.channel_info());
   EXPECT_TRUE(client_channel.channel_info());
 }
 
-class TestAsyncWaiter {
- public:
-  TestAsyncWaiter() : wait_result_(MOJO_RESULT_UNKNOWN) {}
-
-  void Awake(MojoResult result) {
-    MutexLocker l(&wait_result_mutex_);
-    wait_result_ = result;
-    event_.Signal();
-  }
-
-  bool TryWait() {
-    return !event_.WaitWithTimeout(mojo::system::test::ActionTimeout());
-  }
-
-  MojoResult wait_result() const {
-    MutexLocker l(&wait_result_mutex_);
-    return wait_result_;
-  }
-
- private:
-  ManualResetWaitableEvent event_;
-
-  mutable Mutex wait_result_mutex_;
-  MojoResult wait_result_ MOJO_GUARDED_BY(wait_result_mutex_);
-
-  MOJO_DISALLOW_COPY_AND_ASSIGN(TestAsyncWaiter);
-};
-
-TEST_F(EmbedderTest, AsyncWait) {
-  ScopedMessagePipeHandle client_mp;
-  ScopedMessagePipeHandle server_mp;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateMessagePipe(nullptr, &client_mp, &server_mp));
-
-  TestAsyncWaiter waiter;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                      [&waiter](MojoResult result) { waiter.Awake(result); }));
-
-  // TODO(vtl): With C++14 lambda captures, we'll be able to avoid this
-  // nonsense.
-  {
-    auto server_mp_value = server_mp.get();
-    test_io_thread().PostTask([server_mp_value]() {
-      static const char kHello[] = "hello";
-      CHECK_EQ(MOJO_RESULT_OK,
-               WriteMessageRaw(server_mp_value, kHello,
-                               static_cast<uint32_t>(sizeof(kHello)), nullptr,
-                               0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    });
-  }
-  EXPECT_TRUE(waiter.TryWait());
-  EXPECT_EQ(MOJO_RESULT_OK, waiter.wait_result());
-
-  // If message is in the queue, it does't allow us to wait.
-  TestAsyncWaiter waiter_that_doesnt_wait;
-  EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
-            AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                      [&waiter_that_doesnt_wait](MojoResult result) {
-                        waiter_that_doesnt_wait.Awake(result);
-                      }));
-
-  char buffer[1000];
-  uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
-  CHECK_EQ(MOJO_RESULT_OK,
-           ReadMessageRaw(client_mp.get(), buffer, &num_bytes, nullptr, nullptr,
-                          MOJO_READ_MESSAGE_FLAG_NONE));
-
-  TestAsyncWaiter unsatisfiable_waiter;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                      [&unsatisfiable_waiter](MojoResult result) {
-                        unsatisfiable_waiter.Awake(result);
-                      }));
-
-  // TODO(vtl): With C++14 lambda captures, we'll be able to avoid this
-  // nonsense (and use |Close()| rather than |CloseRaw()|).
-  {
-    auto server_mp_value = server_mp.release();
-    test_io_thread().PostTask(
-        [server_mp_value]() { CloseRaw(server_mp_value); });
-  }
-
-  EXPECT_TRUE(unsatisfiable_waiter.TryWait());
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            unsatisfiable_waiter.wait_result());
-}
-
-TEST_F(EmbedderTest, ChannelsHandlePassing) {
+TEST_F(MultiprocessEmbedderTest, ChannelsHandlePassing) {
   mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone(),
                                            test_io_watcher());
 
   PlatformChannelPair channel_pair;
   ScopedTestChannel server_channel(channel_pair.PassServerHandle());
   MojoHandle server_mp = server_channel.bootstrap_message_pipe();
   EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
   ScopedTestChannel client_channel(channel_pair.PassClientHandle());
   MojoHandle client_mp = client_channel.bootstrap_message_pipe();
   EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
@@ skipping 108 matching lines @@
   EXPECT_TRUE(client_channel.channel_info());
 }
 
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 // 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) {
+TEST_F(MultiprocessEmbedderTest, MAYBE_MultiprocessMasterSlave) {
   mojo::test::ScopedMasterIPCSupport ipc_support(test_io_task_runner().Clone(),
                                                  test_io_watcher());
 
   mojo::test::MultiprocessTestHelper multiprocess_test_helper;
   std::string connection_id;
   ManualResetWaitableEvent event;
   ChannelInfo* channel_info = nullptr;
   ScopedMessagePipeHandle mp = ConnectToSlave(
       nullptr, multiprocess_test_helper.server_platform_handle.Pass(),
       [&event]() { event.Signal(); }, nullptr, &connection_id, &channel_info);
@@ skipping 23 matching lines @@
 
   mp.reset();
 
   EXPECT_TRUE(multiprocess_test_helper.WaitForChildTestShutdown());
 
   EXPECT_FALSE(event.WaitWithTimeout(mojo::system::test::ActionTimeout()));
   test_io_thread().PostTaskAndWait(
       [channel_info]() { DestroyChannelOnIOThread(channel_info); });
 }
 
-TEST_F(EmbedderTest, ChannelShutdownRace_MessagePipeClose) {
+TEST_F(MultiprocessEmbedderTest, ChannelShutdownRace_MessagePipeClose) {
   const size_t kIterations = 1000;
   mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone(),
                                            test_io_watcher());
 
   for (size_t i = 0; i < kIterations; i++) {
     PlatformChannelPair channel_pair;
     std::unique_ptr<ScopedTestChannel> server_channel(
         new ScopedTestChannel(channel_pair.PassServerHandle()));
     server_channel->WaitForChannelCreationCompletion();
     server_channel->NoWaitOnShutdown();
@@ skipping 76 matching lines @@
 //  10.                          (close)
 //  11.                                      (wait/cl.)
 //  12.                                                  (wait/cl.)
 
 #if defined(OS_ANDROID)
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_MultiprocessChannels DISABLED_MultiprocessChannels
 #else
 #define MAYBE_MultiprocessChannels MultiprocessChannels
 #endif  // defined(OS_ANDROID)
-TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) {
+TEST_F(MultiprocessEmbedderTest, MAYBE_MultiprocessChannels) {
   // TODO(vtl): This should eventually initialize a master process instead,
   // probably.
   mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone(),
                                            test_io_watcher());
 
   mojo::test::MultiprocessTestHelper multiprocess_test_helper;
   multiprocess_test_helper.StartChild("MultiprocessChannelsClient");
 
   {
     ScopedTestChannel server_channel(
@@ skipping 225 matching lines @@
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo