Rename some variables platform_channel_pair -> platform_pipe.

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) {
-    PlatformPipe platform_channel_pair;
+    PlatformPipe platform_pipe;
     ProcessIdentifier slave_process_identifier = master->AddSlave(
-        new TestSlaveInfo(slave_name), platform_channel_pair.handle0.Pass());
+        new TestSlaveInfo(slave_name), platform_pipe.handle0.Pass());
     slave->Init(task_runner().Clone(), slave_process_delegate,
-                platform_channel_pair.handle1.Pass());
+                platform_pipe.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 427 matching lines @@
   slave.Shutdown();
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, AddSlaveThenImmediateShutdown) {
   MasterConnectionManager master(platform_support());
   master.Init(task_runner().Clone(), &master_process_delegate());
 
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
-  PlatformPipe platform_channel_pair;
-  ProcessIdentifier slave_id = master.AddSlave(
-      new TestSlaveInfo("slave"), platform_channel_pair.handle0.Pass());
+  PlatformPipe platform_pipe;
+  ProcessIdentifier slave_id =
+      master.AddSlave(new TestSlaveInfo("slave"), platform_pipe.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());
 
-  PlatformPipe platform_channel_pair;
+  PlatformPipe platform_pipe;
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   ProcessIdentifier slave_id = master.AddSlaveAndBootstrap(
-      new TestSlaveInfo("slave"), platform_channel_pair.handle0.Pass(),
-      connection_id);
+      new TestSlaveInfo("slave"), platform_pipe.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.handle1.Pass());
+             platform_pipe.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