Connections now take a ConnectionParams instead of a pipe handle.

mojo/edk/system/node_controller.h

 // Copyright 2016 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.
 
 #ifndef MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_
 #define MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_
 
 #include <memory>
 #include <queue>
 #include <unordered_map>
@@ skipping 55 matching lines @@
   // Create the relay used to transfer mach ports between processes.
   void CreateMachPortRelay(base::PortProvider* port_provider);
 #endif
 
   // Called exactly once, shortly after construction, and before any other
   // methods are called on this object.
   void SetIOTaskRunner(scoped_refptr<base::TaskRunner> io_task_runner);
 
   // Connects this node to a child node. This node will initiate a handshake.
   void ConnectToChild(base::ProcessHandle process_handle,
-                      ScopedPlatformHandle platform_handle,
+                      ConnectionParam connection_param,
                       const std::string& child_token,
                       const ProcessErrorCallback& process_error_callback);
 
   // Closes all reserved ports which associated with the child process
   // |child_token|.
   void CloseChildPorts(const std::string& child_token);
 
   // Close a connection to a peer associated with |peer_token|.
   void ClosePeerConnection(const std::string& peer_token);
 
   // Connects this node to a parent node. The parent node will initiate a
   // handshake.
-  void ConnectToParent(ScopedPlatformHandle platform_handle);
+  void ConnectToParent(ConnectionParam connection_param);
 
   // Connects this node to a peer node. On success, |port| will be merged with
   // the corresponding port in the peer node.
-  void ConnectToPeer(ScopedPlatformHandle handle,
+  void ConnectToPeer(ConnectionParam connection_param,
                      const ports::PortRef& port,
                      const std::string& peer_token);
 
   // Sets a port's observer. If |observer| is null the port's current observer
   // is removed.
   void SetPortObserver(const ports::PortRef& port,
                        scoped_refptr<PortObserver> observer);
 
   // Closes a port. Use this in lieu of calling Node::ClosePort() directly, as
   // it ensures the port's observer has also been removed.
@@ skipping 57 matching lines @@
     PeerConnection& operator=(PeerConnection&& other);
 
 
     scoped_refptr<NodeChannel> channel;
     ports::PortRef local_port;
     std::string peer_token;
   };
 
   void ConnectToChildOnIOThread(
       base::ProcessHandle process_handle,
-      ScopedPlatformHandle platform_handle,
+      ConnectionParam connection_param,
       ports::NodeName token,
       const ProcessErrorCallback& process_error_callback);
-  void ConnectToParentOnIOThread(ScopedPlatformHandle platform_handle);
+  void ConnectToParentOnIOThread(ConnectionParam connection_param);
 
-  void ConnectToPeerOnIOThread(ScopedPlatformHandle handle,
+  void ConnectToPeerOnIOThread(ConnectionParam connection_param,
                                ports::NodeName token,
                                ports::PortRef port,
                                const std::string& peer_token);
   void ClosePeerConnectionOnIOThread(const std::string& node_name);
 
   scoped_refptr<NodeChannel> GetPeerChannel(const ports::NodeName& name);
   scoped_refptr<NodeChannel> GetParentChannel();
   scoped_refptr<NodeChannel> GetBrokerChannel();
 
   void AddPeer(const ports::NodeName& name,
@@ skipping 182 matching lines @@
   std::unique_ptr<MachPortRelay> mach_port_relay_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(NodeController);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_