[mojo-edk] Simplify multiprocess pipe bootstrap

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 <queue>
 #include <unordered_map>
 #include <unordered_set>
@@ skipping 92 matching lines @@
   void ConnectToParentPort(const ports::PortRef& local_port,
                            const std::string& token,
                            const base::Closure& callback);
 
   // Connects two reserved ports to each other. Useful when two independent
   // systems in the same (parent) process need to establish a port pair without
   // any direct knowledge of each other.
   void ConnectReservedPorts(const std::string& token1,
                             const std::string& token2);
 
-  // Connects a local port to a port on a remote node. Note that a connection to
-  // the remote node need not be established yet. The port will be connected
-  // ASAP, at which point |callback| will be run.
-  void ConnectToRemotePort(const ports::PortRef& local_port,
-                           const ports::NodeName& remote_node_name,
-                           const ports::PortName& remote_port_name,
-                           const base::Closure& callback);
-
   // Creates a new shared buffer for use in the current process.
   scoped_refptr<PlatformSharedBuffer> CreateSharedBuffer(size_t num_bytes);
 
   // Request that the Node be shut down cleanly. This may take an arbitrarily
   // long time to complete, at which point |callback| will be called.
   //
   // Note that while it is safe to continue using the NodeController's public
   // interface after requesting shutdown, you do so at your own risk and there
   // is NO guarantee that new messages will be sent or ports will complete
   // transfer.
@@ skipping 18 matching lines @@
 
   // Tracks a reserved port.
   struct ReservedPort {
     ReservedPort();
     ~ReservedPort();
 
     ports::PortRef local_port;
     ReservePortCallback callback;
   };
 
-  // Tracks a pending connection to a remote port on any peer.
-  struct PendingRemotePortConnection {
-    PendingRemotePortConnection();
-    ~PendingRemotePortConnection();
-
-    ports::PortRef local_port;
-    ports::NodeName remote_node_name;
-    ports::PortName remote_port_name;
-    base::Closure callback;
-  };
-
   void ConnectToChildOnIOThread(base::ProcessHandle process_handle,
                                 ScopedPlatformHandle platform_handle);
   void ConnectToParentOnIOThread(ScopedPlatformHandle platform_handle);
   void RequestParentPortConnectionOnIOThread(const ports::PortRef& local_port,
                                              const std::string& token,
                                              const base::Closure& callback);
-  void ConnectToRemotePortOnIOThread(
-      const PendingRemotePortConnection& connection);
 
   scoped_refptr<NodeChannel> GetPeerChannel(const ports::NodeName& name);
   scoped_refptr<NodeChannel> GetParentChannel();
 
   void AddPeer(const ports::NodeName& name,
                scoped_refptr<NodeChannel> channel,
                bool start_channel);
   void DropPeer(const ports::NodeName& name);
   void SendPeerMessage(const ports::NodeName& name,
                        ports::ScopedMessage message);
@@ skipping 94 matching lines @@
   // Channels to children during handshake.
   NodeMap pending_children_;
 
   // Port connection requests which have been deferred until we have a parent.
   std::vector<PendingPortRequest> pending_port_requests_;
 
   // Port connection requests awaiting a response from the parent.
   std::unordered_map<ports::PortName, base::Closure>
       pending_parent_port_connections_;
 
-  // Port connections pending the availability of a remote peer node.
-  std::unordered_map<ports::NodeName, std::vector<PendingRemotePortConnection>>
-      pending_remote_port_connections_;
-
   // Indicates whether this object should delete itself on IO thread shutdown.
   // Must only be accessed from the IO thread.
   bool destroy_on_io_thread_shutdown_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(NodeController);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_