EDK: Add a PlatformHandleWatcher argument to embedder::InitIPCSupport().

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>
 
@@ skipping 10 matching lines @@
 #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/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 {
@@ skipping 84 matching lines @@
 class EmbedderTest : public testing::Test {
  public:
   EmbedderTest() : test_io_thread_(TestIOThread::StartMode::AUTO) {}
   ~EmbedderTest() 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);
 };
 
 TEST_F(EmbedderTest, ChannelsBasic) {
-  mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone());
+  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);
 
   // We can write to a message pipe handle immediately.
@@ skipping 111 matching lines @@
     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) {
-  mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone());
+  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);
 
   MojoHandle h0, h1;
@@ skipping 107 matching lines @@
 }
 
 #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) {
-  mojo::test::ScopedMasterIPCSupport ipc_support(test_io_task_runner().Clone());
+  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);
   ASSERT_TRUE(mp.is_valid());
   EXPECT_TRUE(channel_info);
@@ skipping 23 matching lines @@
 
   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) {
   const size_t kIterations = 1000;
-  mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone());
+  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();
 
     MojoHandle server_mp = server_channel->bootstrap_message_pipe();
     EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
 
     // Race between channel shutdown and closing a message pipe. The message
     // pipe doesn't have to be the bootstrap pipe. It just has to be bound to
     // the channel.
     server_channel.reset();
     MojoClose(server_mp);
   }
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessMasterSlave) {
   ScopedPlatformHandle client_platform_handle =
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   EXPECT_TRUE(client_platform_handle.is_valid());
 
   TestIOThread test_io_thread(TestIOThread::StartMode::AUTO);
   test::InitWithSimplePlatformSupport();
 
   {
     mojo::test::ScopedSlaveIPCSupport ipc_support(
-        test_io_thread.task_runner().Clone(), client_platform_handle.Pass());
+        test_io_thread.task_runner().Clone(),
+        test_io_thread.platform_handle_watcher(),
+        client_platform_handle.Pass());
 
     std::string connection_id;
     ASSERT_TRUE(mojo::system::test::GetTestCommandLine()->GetOptionValue(
         kConnectionIdFlag, &connection_id));
     ASSERT_FALSE(connection_id.empty());
     ManualResetWaitableEvent event;
     ChannelInfo* channel_info = nullptr;
     ScopedMessagePipeHandle mp = ConnectToMaster(
         connection_id, [&event]() { event.Signal(); }, nullptr, &channel_info);
     ASSERT_TRUE(mp.is_valid());
@@ skipping 44 matching lines @@
 
 #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) {
   // TODO(vtl): This should eventually initialize a master process instead,
   // probably.
-  mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner().Clone());
+  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(
         multiprocess_test_helper.server_platform_handle.Pass());
     MojoHandle server_mp = server_channel.bootstrap_message_pipe();
     EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
     server_channel.WaitForChannelCreationCompletion();
@@ skipping 106 matching lines @@
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   EXPECT_TRUE(client_platform_handle.is_valid());
 
   TestIOThread test_io_thread(TestIOThread::StartMode::AUTO);
   test::InitWithSimplePlatformSupport();
 
   {
     // TODO(vtl): This should eventually initialize a slave process instead,
     // probably.
     mojo::test::ScopedIPCSupport ipc_support(
-        test_io_thread.task_runner().Clone());
+        test_io_thread.task_runner().Clone(),
+        test_io_thread.platform_handle_watcher());
 
     ScopedTestChannel client_channel(client_platform_handle.Pass());
     MojoHandle client_mp = client_channel.bootstrap_message_pipe();
     EXPECT_NE(client_mp, MOJO_HANDLE_INVALID);
     client_channel.WaitForChannelCreationCompletion();
     CHECK(client_channel.channel_info() != nullptr);
 
     // 1. Read the first message from |client_mp|.
     MojoHandleSignalsState state;
     EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
@@ skipping 93 matching lines @@
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo