[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 64 matching lines @@
 
   // Closes a port. Use this in lieu of calling Node::ClosePort() directly, as
   // it ensures the port's observer has also been removed.
   void ClosePort(const ports::PortRef& port);
 
   // Sends a message on a port to its peer. If message send fails, |message|
   // is left intact. Otherwise ownership is transferred and it's reset.
   int SendMessage(const ports::PortRef& port_ref,
                   scoped_ptr<PortsMessage>* message);
 
-  using ReservePortCallback = base::Callback<void(const ports::PortRef& port)>;
+  // Reserves a local port |port| associated with |token|. A peer holding a copy
+  // of |token| can merge one of its own ports into this one.
+  void ReservePort(const std::string& token, const ports::PortRef& port);
 
-  // Reserves a port associated with |token|. A peer may associate one of their
-  // own ports with this one by sending us a RequestPortConnection message with
-  // the same token value.
-  //
-  // Note that the reservation is made synchronously. In order to avoid races,
-  // reservations should be acquired before |token| is communicated to any
-  // potential peer.
-  //
-  // |callback| must be runnable on any thread and will be run with a reference
-  // to the new local port once connected.
-  void ReservePort(const std::string& token,
-                   const ReservePortCallback& callback);
-
-  // Eventually initializes a local port with a parent port peer identified by
-  // |token|. The parent should also have |token| and should alrady have
-  // reserved a port for it. |callback| must be runnable on any thread and will
-  // be run if and when the local port is connected.
-  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);
+  // Merges a local port |port| into a port reserved by |token| in the parent.
+  void MergePortIntoParent(const std::string& token,
+                           const ports::PortRef& port);
 
   // 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.
   void RequestShutdown(const base::Closure& callback);
 
  private:
   friend Core;
 
   using NodeMap = std::unordered_map<ports::NodeName,
                                      scoped_refptr<NodeChannel>>;
   using OutgoingMessageQueue = std::queue<Channel::MessagePtr>;
 
-  // Tracks a pending token-based connection to a parent port.
-  struct PendingPortRequest {
-    PendingPortRequest();
-    ~PendingPortRequest();
-
-    std::string token;
-    ports::PortRef local_port;
-    base::Closure callback;
-  };
-
-  // 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();
   scoped_refptr<NodeChannel> GetBrokerChannel();
 
   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,
@@ skipping 19 matching lines @@
   void OnAddBrokerClient(const ports::NodeName& from_node,
                          const ports::NodeName& client_name,
                          ScopedPlatformHandle process_handle) override;
   void OnBrokerClientAdded(const ports::NodeName& from_node,
                            const ports::NodeName& client_name,
                            ScopedPlatformHandle broker_channel) override;
   void OnAcceptBrokerClient(const ports::NodeName& from_node,
                             const ports::NodeName& broker_name,
                             ScopedPlatformHandle broker_channel) override;
   void OnPortsMessage(Channel::MessagePtr message) override;
-  void OnRequestPortConnection(const ports::NodeName& from_node,
-                               const ports::PortName& connector_port_name,
-                               const std::string& token) override;
-  void OnConnectToPort(const ports::NodeName& from_node,
-                       const ports::PortName& connector_port_name,
-                       const ports::PortName& connectee_port_name) override;
+  void OnRequestPortMerge(const ports::NodeName& from_node,
+                          const ports::PortName& connector_port_name,
+                          const std::string& token) override;
   void OnRequestIntroduction(const ports::NodeName& from_node,
                              const ports::NodeName& name) override;
   void OnIntroduce(const ports::NodeName& from_node,
                    const ports::NodeName& name,
                    ScopedPlatformHandle channel_handle) override;
 #if defined(OS_WIN)
   void OnRelayPortsMessage(const ports::NodeName& from_node,
                            base::ProcessHandle from_process,
                            const ports::NodeName& destination,
                            Channel::MessagePtr message) override;
@@ skipping 23 matching lines @@
   NodeMap peers_;
 
   // Outgoing message queues for peers we've heard of but can't yet talk to.
   std::unordered_map<ports::NodeName, OutgoingMessageQueue>
       pending_peer_messages_;
 
   // Guards |reserved_ports_|.
   base::Lock reserved_ports_lock_;
 
   // Ports reserved by token.
-  base::hash_map<std::string, ReservedPort> reserved_ports_;
+  base::hash_map<std::string, ports::PortRef> reserved_ports_;
+
+  // Guards |pending_port_merges_|.
+  base::Lock pending_port_merges_lock_;
+
+  // A set of port merge requests awaiting parent connection.
+  std::vector<std::pair<std::string, ports::PortRef>> pending_port_merges_;
 
   // Guards |parent_name_| and |bootstrap_parent_channel_|.
   base::Lock parent_lock_;
 
   // The name of our parent node, if any.
   ports::NodeName parent_name_;
 
   // A temporary reference to the parent channel before we know their name.
   scoped_refptr<NodeChannel> bootstrap_parent_channel_;
 
@@ skipping 22 matching lines @@
   // begin polling the Node to see if clean shutdown is possible any time the
   // Node's state is modified by the controller.
   base::Closure shutdown_callback_;
 
   // All other fields below must only be accessed on the I/O thread, i.e., the
   // thread on which core_->io_task_runner() runs tasks.
 
   // 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;
 
 #if defined(OS_POSIX)
   // Broker for sync shared buffer creation (posix-only) in children.
   scoped_ptr<Broker> broker_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(NodeController);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_