Support mojo connections between unrelated peer processes.

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 29 matching lines @@
   REQUEST_PORT_MERGE,
   REQUEST_INTRODUCTION,
   INTRODUCE,
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
   RELAY_PORTS_MESSAGE,
 #endif
   BROADCAST,
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
   PORTS_MESSAGE_FROM_RELAY,
 #endif
+  ACCEPT_PEER,
 };
 
 struct Header {
   MessageType type;
   uint32_t padding;
 };
 
 static_assert(sizeof(Header) % kChannelMessageAlignment == 0,
     "Invalid header size.");
 
 struct AcceptChildData {
   ports::NodeName parent_name;
   ports::NodeName token;
 };
 
 struct AcceptParentData {
   ports::NodeName token;
   ports::NodeName child_name;
 };
 
+struct AcceptPeerData {
+  ports::NodeName token;
+  ports::NodeName peer_name;
+  ports::PortName port_name;
+};
+
 // This message may include a process handle on plaforms that require it.
 struct AddBrokerClientData {
   ports::NodeName client_name;
 #if !defined(OS_WIN)
   uint32_t process_handle;
   uint32_t padding;
 #endif
 };
 
 #if !defined(OS_WIN)
@@ skipping 195 matching lines @@
 void NodeChannel::AcceptParent(const ports::NodeName& token,
                                const ports::NodeName& child_name) {
   AcceptParentData* data;
   Channel::MessagePtr message = CreateMessage(
       MessageType::ACCEPT_PARENT, sizeof(AcceptParentData), 0, &data);
   data->token = token;
   data->child_name = child_name;
   WriteChannelMessage(std::move(message));
 }
 
+void NodeChannel::AcceptPeer(const ports::NodeName& sender_name,
+                             const ports::NodeName& token,
+                             const ports::PortName& port_name) {
+  AcceptPeerData* data;
+  Channel::MessagePtr message =
+      CreateMessage(MessageType::ACCEPT_PEER, sizeof(AcceptPeerData), 0, &data);
+  data->token = token;
+  data->peer_name = sender_name;
+  data->port_name = port_name;
+  WriteChannelMessage(std::move(message));
+}
+
 void NodeChannel::AddBrokerClient(const ports::NodeName& client_name,
                                   base::ProcessHandle process_handle) {
   AddBrokerClientData* data;
   ScopedPlatformHandleVectorPtr handles(new PlatformHandleVector());
 #if defined(OS_WIN)
   handles->push_back(PlatformHandle(process_handle));
 #endif
   Channel::MessagePtr message = CreateMessage(
       MessageType::ADD_BROKER_CLIENT, sizeof(AddBrokerClientData),
       handles->size(), &data);
@@ skipping 426 matching lines @@
         if (num_bytes)
           memcpy(message->mutable_payload(), data + 1, num_bytes);
         delegate_->OnPortsMessageFromRelay(
             remote_node_name_, data->source, std::move(message));
         return;
       }
       break;
 
 #endif  // defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
 
+    case MessageType::ACCEPT_PEER: {
+      const AcceptPeerData* data;
+      if (GetMessagePayload(payload, payload_size, &data)) {
+        delegate_->OnAcceptPeer(remote_node_name_, data->token, data->peer_name,
+                                data->port_name);
+        return;
+      }
+      break;
+    }
+
     default:
       break;
   }
 
   DLOG(ERROR) << "Received invalid message. Closing channel.";
   delegate_->OnChannelError(remote_node_name_, this);
 }
 
 void NodeChannel::OnChannelError() {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 125 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