Make PlatformChannelPair "dumb".

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 157 matching lines @@
         connection_id_(master_ipc_support_->GenerateConnectionIdentifier()),
         slave_id_(kInvalidProcessIdentifier) {}
   ~TestSlaveConnection() {}
 
   // After this is called, |ShutdownChannelToSlave()| must be called (possibly
   // after |WaitForChannelToSlave()|) before destruction.
   RefPtr<MessagePipeDispatcher> ConnectToSlave() {
     embedder::PlatformChannelPair channel_pair;
     // Note: |ChannelId|s and |ProcessIdentifier|s are interchangeable.
     RefPtr<MessagePipeDispatcher> mp = master_ipc_support_->ConnectToSlave(
-        connection_id_, nullptr, channel_pair.PassServerHandle(),
+        connection_id_, nullptr, channel_pair.handle0.Pass(),
         [this]() { event_.Signal(); }, nullptr, &slave_id_);
     EXPECT_TRUE(mp);
     EXPECT_NE(slave_id_, kInvalidProcessIdentifier);
     EXPECT_NE(slave_id_, kMasterProcessIdentifier);
-    slave_platform_handle_ = channel_pair.PassClientHandle();
+    slave_platform_handle_ = channel_pair.handle1.Pass();
     return mp;
   }
 
   void WaitForChannelToSlave() {
     EXPECT_FALSE(event_.WaitWithTimeout(test::ActionTimeout()));
   }
 
   void ShutdownChannelToSlave() {
     // Since |event_| is manual-reset, calling this multiple times is OK.
     WaitForChannelToSlave();
@@ skipping 378 matching lines @@
 // Note: This test isn't in an anonymous namespace, since it needs to be
 // friended by |IPCSupport|.
 TEST_F(IPCSupportTest, MasterSlaveInternal) {
   ConnectionIdentifier connection_id =
       master_ipc_support().GenerateConnectionIdentifier();
 
   embedder::PlatformChannelPair channel_pair;
   ProcessIdentifier slave_id = kInvalidProcessIdentifier;
   ScopedPlatformHandle master_second_platform_handle =
       master_ipc_support().ConnectToSlaveInternal(
-          connection_id, nullptr, channel_pair.PassServerHandle(), &slave_id);
+          connection_id, nullptr, channel_pair.handle0.Pass(), &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(),
-      test_io_thread().platform_handle_watcher(),
-      channel_pair.PassClientHandle());
+      test_io_thread().platform_handle_watcher(), channel_pair.handle1.Pass());
 
   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 103 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