[mojo-edk] Simplify multiprocess pipe bootstrap

mojo/edk/system/node_controller.cc

 // 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.
 
 #include "mojo/edk/system/node_controller.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 86 matching lines @@
 }  // namespace
 
 NodeController::PendingPortRequest::PendingPortRequest() {}
 
 NodeController::PendingPortRequest::~PendingPortRequest() {}
 
 NodeController::ReservedPort::ReservedPort() {}
 
 NodeController::ReservedPort::~ReservedPort() {}
 
-NodeController::PendingRemotePortConnection::PendingRemotePortConnection() {}
-
-NodeController::PendingRemotePortConnection::~PendingRemotePortConnection() {}
-
 NodeController::~NodeController() {}
 
 NodeController::NodeController(Core* core)
     : core_(core),
       name_(GetRandomNodeName()),
       node_(new ports::Node(name_, this)) {
   DVLOG(1) << "Initializing node " << name_;
 }
 
 void NodeController::SetIOTaskRunner(
@@ skipping 72 matching lines @@
 
 void NodeController::ConnectToParentPort(const ports::PortRef& local_port,
                                          const std::string& token,
                                          const base::Closure& callback) {
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NodeController::RequestParentPortConnectionOnIOThread,
                  base::Unretained(this), local_port, token, callback));
 }
 
-void NodeController::ConnectToRemotePort(
-    const ports::PortRef& local_port,
-    const ports::NodeName& remote_node_name,
-    const ports::PortName& remote_port_name,
-    const base::Closure& callback) {
-  if (remote_node_name == name_) {
-    // It's possible that two different code paths on the node are trying to
-    // bootstrap ports to each other (e.g. in Chrome single-process mode)
-    // without being aware of the fact. In this case we can initialize the port
-    // immediately (which can fail silently if it's already been initialized by
-    // the request on the other side), and invoke |callback|.
-    node_->InitializePort(local_port, name_, remote_port_name);
-    callback.Run();
-    return;
-  }
-
-  PendingRemotePortConnection connection;
-  connection.local_port = local_port;
-  connection.remote_node_name = remote_node_name;
-  connection.remote_port_name = remote_port_name;
-  connection.callback = callback;
-  io_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&NodeController::ConnectToRemotePortOnIOThread,
-                 base::Unretained(this), connection));
-}
-
 void NodeController::RequestShutdown(const base::Closure& callback) {
   {
     base::AutoLock lock(shutdown_lock_);
     shutdown_callback_ = callback;
   }
 
   AttemptShutdownIfRequested();
 }
 
 void NodeController::ConnectToChildOnIOThread(
@@ skipping 46 matching lines @@
     request.callback = callback;
     pending_port_requests_.push_back(request);
     return;
   }
 
   pending_parent_port_connections_.insert(
       std::make_pair(local_port.name(), callback));
   parent->RequestPortConnection(local_port.name(), token);
 }
 
-void NodeController::ConnectToRemotePortOnIOThread(
-    const PendingRemotePortConnection& connection) {
-  scoped_refptr<NodeChannel> peer = GetPeerChannel(connection.remote_node_name);
-  if (peer) {
-    // It's safe to initialize the port since we already have a channel to its
-    // peer. No need to actually send them a message.
-    int rv = node_->InitializePort(connection.local_port,
-                                   connection.remote_node_name,
-                                   connection.remote_port_name);
-    DCHECK_EQ(rv, ports::OK);
-    connection.callback.Run();
-    return;
-  }
-
-  // Save this for later. We'll initialize the port once this:: peer is added.
-  pending_remote_port_connections_[connection.remote_node_name].push_back(
-      connection);
-}
-
 scoped_refptr<NodeChannel> NodeController::GetPeerChannel(
     const ports::NodeName& name) {
   base::AutoLock lock(peers_lock_);
   auto it = peers_.find(name);
   if (it == peers_.end())
     return nullptr;
   return it->second;
 }
 
 scoped_refptr<NodeChannel> NodeController::GetParentChannel() {
@@ skipping 43 matching lines @@
   if (start_channel)
     channel->Start();
 
   // Flush any queued message we need to deliver to this node.
   while (!pending_messages.empty()) {
     ports::ScopedMessage message = std::move(pending_messages.front());
     channel->PortsMessage(
         static_cast<PortsMessage*>(message.get())->TakeChannelMessage());
     pending_messages.pop();
   }
-
-  // Complete any pending port connections to this peer.
-  auto connections_it = pending_remote_port_connections_.find(name);
-  if (connections_it != pending_remote_port_connections_.end()) {
-    for (const auto& connection : connections_it->second) {
-      int rv = node_->InitializePort(connection.local_port,
-                                     connection.remote_node_name,
-                                     connection.remote_port_name);
-      DCHECK_EQ(rv, ports::OK);
-      connection.callback.Run();
-    }
-    pending_remote_port_connections_.erase(connections_it);
-  }
 }
 
 void NodeController::DropPeer(const ports::NodeName& name) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   {
     base::AutoLock lock(peers_lock_);
     auto it = peers_.find(name);
 
     if (it != peers_.end()) {
@@ skipping 439 matching lines @@
     shutdown_callback_.Reset();
   }
 
   DCHECK(!callback.is_null());
 
   callback.Run();
 }
 
 }  // namespace edk
 }  // namespace mojo