Make PlatformChannelPair "dumb".

mojo/edk/system/connection_manager_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.
 
 // This is really a unit test for |MasterConnectionManager| and
 // |SlaveConnectionManager| (since they need to be tested together).
 
 #include "mojo/edk/system/connection_manager.h"
 
 #include <stdint.h>
@@ skipping 180 matching lines @@
 
   // Connects the given |slave| (with the given |slave_process_delegate|) to the
   // given master, creating and using a |TestSlaveInfo| with the given
   // |slave_name|, and returns the process identifier for the slave.
   ProcessIdentifier ConnectSlave(
       MasterConnectionManager* master,
       embedder::SlaveProcessDelegate* slave_process_delegate,
       SlaveConnectionManager* slave,
       const std::string& slave_name) {
     embedder::PlatformChannelPair platform_channel_pair;
-    ProcessIdentifier slave_process_identifier =
-        master->AddSlave(new TestSlaveInfo(slave_name),
-                         platform_channel_pair.PassServerHandle());
+    ProcessIdentifier slave_process_identifier = master->AddSlave(
+        new TestSlaveInfo(slave_name), platform_channel_pair.handle0.Pass());
     slave->Init(task_runner().Clone(), slave_process_delegate,
-                platform_channel_pair.PassClientHandle());
+                platform_channel_pair.handle1.Pass());
     return slave_process_identifier;
   }
 
  private:
   embedder::SimplePlatformSupport platform_support_;
   std::unique_ptr<MessageLoop> message_loop_;
   MockMasterProcessDelegate master_process_delegate_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ConnectionManagerTest);
 };
@@ skipping 429 matching lines @@
 }
 
 TEST_F(ConnectionManagerTest, AddSlaveThenImmediateShutdown) {
   MasterConnectionManager master(platform_support());
   master.Init(task_runner().Clone(), &master_process_delegate());
 
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
   embedder::PlatformChannelPair platform_channel_pair;
   ProcessIdentifier slave_id = master.AddSlave(
-      new TestSlaveInfo("slave"), platform_channel_pair.PassServerHandle());
+      new TestSlaveInfo("slave"), platform_channel_pair.handle0.Pass());
   master.Shutdown();
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave_id));
   // Since we never initialized |slave|, we don't have to shut it down.
 }
 
 TEST_F(ConnectionManagerTest, AddSlaveAndBootstrap) {
   MasterConnectionManager master(platform_support());
   master.Init(task_runner().Clone(), &master_process_delegate());
 
   embedder::PlatformChannelPair platform_channel_pair;
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   ProcessIdentifier slave_id = master.AddSlaveAndBootstrap(
-      new TestSlaveInfo("slave"), platform_channel_pair.PassServerHandle(),
+      new TestSlaveInfo("slave"), platform_channel_pair.handle0.Pass(),
       connection_id);
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave_id));
 
   ScopedPlatformHandle h1;
   ProcessIdentifier master_peer = kInvalidProcessIdentifier;
   bool is_first = false;
   EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
             master.Connect(connection_id, &master_peer, &is_first, &h1));
   EXPECT_EQ(slave_id, master_peer);
   EXPECT_TRUE(is_first);
   EXPECT_TRUE(h1.is_valid());
 
   // We can delay creating/initializing |slave| for quite a while.
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
   slave.Init(task_runner().Clone(), &slave_process_delegate,
-             platform_channel_pair.PassClientHandle());
+             platform_channel_pair.handle1.Pass());
 
   ProcessIdentifier slave_peer = kInvalidProcessIdentifier;
   ScopedPlatformHandle h2;
   EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
             slave.Connect(connection_id, &slave_peer, &is_first, &h2));
   EXPECT_EQ(kMasterProcessIdentifier, slave_peer);
   EXPECT_FALSE(is_first);
 
   EXPECT_TRUE(ArePlatformHandlesConnected(h1.get(), h2.get()));
 
   slave.Shutdown();
   master.Shutdown();
 }
 
 // TODO(vtl): More shutdown cases for |AddSlaveAndBootstrap()|?
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo