EDK: Add PlatformHandleWatcher to IPCSupport class.

mojo/edk/system/ipc_support_unittest.cc

 // 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/system/ipc_support.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 213 matching lines @@
   // Note: Before destruction, |ShutdownIPCSupport()| must be called.
   TestSlave(embedder::PlatformSupport* platform_support,
             test::TestIOThread* test_io_thread,
             ScopedPlatformHandle platform_handle)
       : test_io_thread_(test_io_thread),
         slave_ipc_support_(platform_support,
                            embedder::ProcessType::SLAVE,
                            test_io_thread->task_runner().Clone(),
                            &slave_process_delegate_,
                            test_io_thread->task_runner().Clone(),
+                           test_io_thread->platform_handle_watcher(),
                            platform_handle.Pass()) {}
   ~TestSlave() {}
 
   // After this is called, |ShutdownChannelToMaster()| must be called (possibly
   // after |WaitForChannelToMaster()|) before destruction.
   RefPtr<MessagePipeDispatcher> ConnectToMaster(
       const ConnectionIdentifier& connection_id) {
     ProcessIdentifier master_id = kInvalidProcessIdentifier;
     RefPtr<MessagePipeDispatcher> mp = slave_ipc_support_.ConnectToMaster(
         connection_id, [this]() { event_.Signal(); }, nullptr, &master_id);
@@ skipping 117 matching lines @@
 class IPCSupportTest : public testing::Test {
  public:
   // Note: Run master process delegate methods on the I/O thread.
   IPCSupportTest()
       : test_io_thread_(test::TestIOThread::StartMode::AUTO),
         master_ipc_support_(&platform_support_,
                             embedder::ProcessType::MASTER,
                             test_io_thread_.task_runner().Clone(),
                             &master_process_delegate_,
                             test_io_thread_.task_runner().Clone(),
+                            test_io_thread_.platform_handle_watcher(),
                             ScopedPlatformHandle()) {}
   ~IPCSupportTest() override {}
 
   std::unique_ptr<TestSlaveSetup> SetupSlave() {
     std::unique_ptr<TestSlaveSetup> s(
         new TestSlaveSetup(&platform_support_, &test_io_thread_,
                            &master_process_delegate_, &master_ipc_support_));
     s->Init();
     return s;
   }
@@ skipping 199 matching lines @@
           connection_id, nullptr, channel_pair.PassServerHandle(), &slave_id);
   ASSERT_TRUE(master_second_platform_handle.is_valid());
   EXPECT_NE(slave_id, kInvalidProcessIdentifier);
   EXPECT_NE(slave_id, kMasterProcessIdentifier);
 
   TestSlaveProcessDelegate slave_process_delegate;
   // Note: Run process delegate methods on the I/O thread.
   IPCSupport slave_ipc_support(
       &platform_support(), embedder::ProcessType::SLAVE,
       test_io_thread().task_runner().Clone(), &slave_process_delegate,
-      test_io_thread().task_runner().Clone(), channel_pair.PassClientHandle());
+      test_io_thread().task_runner().Clone(),
+      test_io_thread().platform_handle_watcher(),
+      channel_pair.PassClientHandle());
 
   ScopedPlatformHandle slave_second_platform_handle =
       slave_ipc_support.ConnectToMasterInternal(connection_id);
   ASSERT_TRUE(slave_second_platform_handle.is_valid());
 
   // Write an 'x' through the master's end.
   size_t n = 0;
   EXPECT_TRUE(mojo::test::BlockingWrite(master_second_platform_handle.get(),
                                         "x", 1, &n));
   EXPECT_EQ(1u, n);
@@ skipping 66 matching lines @@
       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
   ASSERT_TRUE(client_platform_handle.is_valid());
 
   embedder::SimplePlatformSupport platform_support;
   test::TestIOThread test_io_thread(test::TestIOThread::StartMode::AUTO);
   TestSlaveProcessDelegate slave_process_delegate;
   // Note: Run process delegate methods on the I/O thread.
   IPCSupport ipc_support(
       &platform_support, embedder::ProcessType::SLAVE,
       test_io_thread.task_runner().Clone(), &slave_process_delegate,
-      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_string;
   ASSERT_TRUE(test::GetTestCommandLine()->GetOptionValue(
       kConnectionIdFlag, &connection_id_string));
   bool ok = false;
   ConnectionIdentifier connection_id =
       ConnectionIdentifier::FromString(connection_id_string, &ok);
   ASSERT_TRUE(ok);
 
   ScopedPlatformHandle second_platform_handle =
@@ skipping 15 matching lines @@
 
   test_io_thread.PostTaskAndWait(
       [&ipc_support]() { ipc_support.ShutdownOnIOThread(); });
 }
 
 // TODO(vtl): Also test the case of the master "dying" before the slave. (The
 // slave should get OnMasterDisconnect(), which we currently don't test.)
 
 }  // namespace system
 }  // namespace mojo