Revert of [mojo-edk] Simplify multiprocess pipe bootstrap

mojo/edk/system/node_channel.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_channel.h"
 
 #include <cstring>
 #include <limits>
 #include <sstream>
 
@@ skipping 11 matching lines @@
   return t + (k - (t % k)) % k;
 }
 
 enum class MessageType : uint32_t {
   ACCEPT_CHILD,
   ACCEPT_PARENT,
   ADD_BROKER_CLIENT,
   BROKER_CLIENT_ADDED,
   ACCEPT_BROKER_CLIENT,
   PORTS_MESSAGE,
-  REQUEST_PORT_MERGE,
+  REQUEST_PORT_CONNECTION,
+  CONNECT_TO_PORT,
   REQUEST_INTRODUCTION,
   INTRODUCE,
 #if defined(OS_WIN)
   RELAY_PORTS_MESSAGE,
 #endif
 };
 
 struct Header {
   MessageType type;
   uint32_t padding;
@@ skipping 23 matching lines @@
 };
 
 // This data may be followed by a platform channel handle to the broker. If not,
 // then the parent is the broker and its channel should be used as such.
 struct AcceptBrokerClientData {
   ports::NodeName broker_name;
 };
 
 // This is followed by arbitrary payload data which is interpreted as a token
 // string for port location.
-struct RequestPortMergeData {
+struct RequestPortConnectionData {
   ports::PortName connector_port_name;
 };
 
+struct ConnectToPortData {
+  ports::PortName connector_port_name;
+  ports::PortName connectee_port_name;
+};
+
 // Used for both REQUEST_INTRODUCTION and INTRODUCE.
 //
 // For INTRODUCE the message also includes a valid platform handle for a channel
 // the receiver may use to communicate with the named node directly, or an
 // invalid platform handle if the node is unknown to the sender or otherwise
 // cannot be introduced.
 struct IntroductionData {
   ports::NodeName name;
 };
 
@@ skipping 164 matching lines @@
       handles->size(), &data);
   message->SetHandles(std::move(handles));
   data->broker_name = broker_name;
   WriteChannelMessage(std::move(message));
 }
 
 void NodeChannel::PortsMessage(Channel::MessagePtr message) {
   WriteChannelMessage(std::move(message));
 }
 
-void NodeChannel::RequestPortMerge(const ports::PortName& connector_port_name,
-                                   const std::string& token) {
-  RequestPortMergeData* data;
+void NodeChannel::RequestPortConnection(
+    const ports::PortName& connector_port_name,
+    const std::string& token) {
+  RequestPortConnectionData* data;
   Channel::MessagePtr message = CreateMessage(
-      MessageType::REQUEST_PORT_MERGE,
-      sizeof(RequestPortMergeData) + token.size(), 0, &data);
+      MessageType::REQUEST_PORT_CONNECTION,
+      sizeof(RequestPortConnectionData) + token.size(), 0, &data);
   data->connector_port_name = connector_port_name;
   memcpy(data + 1, token.data(), token.size());
   WriteChannelMessage(std::move(message));
 }
 
+void NodeChannel::ConnectToPort(const ports::PortName& connector_port_name,
+                                const ports::PortName& connectee_port_name) {
+  ConnectToPortData* data;
+  Channel::MessagePtr message = CreateMessage(
+      MessageType::CONNECT_TO_PORT, sizeof(ConnectToPortData), 0, &data);
+  data->connector_port_name = connector_port_name;
+  data->connectee_port_name = connectee_port_name;
+  WriteChannelMessage(std::move(message));
+}
+
 void NodeChannel::RequestIntroduction(const ports::NodeName& name) {
   IntroductionData* data;
   Channel::MessagePtr message = CreateMessage(
       MessageType::REQUEST_INTRODUCTION, sizeof(IntroductionData), 0, &data);
   data->name = name;
   WriteChannelMessage(std::move(message));
 }
 
 void NodeChannel::Introduce(const ports::NodeName& name,
                             ScopedPlatformHandle channel_handle) {
@@ skipping 143 matching lines @@
     case MessageType::PORTS_MESSAGE: {
       size_t num_handles = handles ? handles->size() : 0;
       Channel::MessagePtr message(
           new Channel::Message(payload_size, num_handles));
       message->SetHandles(std::move(handles));
       memcpy(message->mutable_payload(), payload, payload_size);
       delegate_->OnPortsMessage(std::move(message));
       break;
     }
 
-    case MessageType::REQUEST_PORT_MERGE: {
-      const RequestPortMergeData* data;
+    case MessageType::REQUEST_PORT_CONNECTION: {
+      const RequestPortConnectionData* data;
       GetMessagePayload(payload, &data);
 
       const char* token_data = reinterpret_cast<const char*>(data + 1);
       const size_t token_size = payload_size - sizeof(*data) - sizeof(Header);
       std::string token(token_data, token_size);
 
-      delegate_->OnRequestPortMerge(remote_node_name_,
-                                    data->connector_port_name, token);
+      delegate_->OnRequestPortConnection(remote_node_name_,
+                                         data->connector_port_name, token);
       break;
     }
 
+    case MessageType::CONNECT_TO_PORT: {
+      const ConnectToPortData* data;
+      GetMessagePayload(payload, &data);
+      delegate_->OnConnectToPort(remote_node_name_, data->connector_port_name,
+                                 data->connectee_port_name);
+      break;
+    }
+
     case MessageType::REQUEST_INTRODUCTION: {
       const IntroductionData* data;
       GetMessagePayload(payload, &data);
       delegate_->OnRequestIntroduction(remote_node_name_, data->name);
       break;
     }
 
     case MessageType::INTRODUCE: {
       const IntroductionData* data;
       GetMessagePayload(payload, &data);
@@ skipping 81 matching lines @@
 
   base::AutoLock lock(channel_lock_);
   if (!channel_)
     DLOG(ERROR) << "Dropping message on closed channel.";
   else
     channel_->Write(std::move(message));
 }
 
 }  // namespace edk
 }  // namespace mojo