Adds associated interface support to IPC::Channel

ipc/ipc_channel_mojo.cc

 // Copyright 2014 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 "ipc/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 289 matching lines @@
     mojom::ChannelAssociatedRequest receive_channel,
     int32_t peer_pid) {
   InitMessageReader(std::move(send_channel), std::move(receive_channel),
                     peer_pid);
 }
 
 void ChannelMojo::OnBootstrapError() {
   listener_->OnChannelError();
 }
 
+void ChannelMojo::OnAssociatedInterfaceRequest(
+    const std::string& name,
+    mojo::ScopedInterfaceEndpointHandle handle) {
+  auto iter = associated_interfaces_.find(name);
+  if (iter != associated_interfaces_.end())
+    iter->second.Run(std::move(handle));
+}
+
 void ChannelMojo::InitMessageReader(mojom::ChannelAssociatedPtrInfo sender,
                                     mojom::ChannelAssociatedRequest receiver,
                                     base::ProcessId peer_pid) {
   mojom::ChannelAssociatedPtr sender_ptr;
   sender_ptr.Bind(std::move(sender));
   std::unique_ptr<internal::MessagePipeReader, ChannelMojo::ReaderDeleter>
       reader(new internal::MessagePipeReader(
           pipe_, std::move(sender_ptr), std::move(receiver), peer_pid, this));
 
   bool connected = true;
@@ skipping 65 matching lines @@
   if (!message_reader_)
     return base::kNullProcessId;
 
   return message_reader_->GetPeerPid();
 }
 
 base::ProcessId ChannelMojo::GetSelfPID() const {
   return bootstrap_->GetSelfPID();
 }
 
+Channel::AssociatedInterfaceSupport*
+ChannelMojo::GetAssociatedInterfaceSupport() { return this; }
+
 void ChannelMojo::OnMessageReceived(const Message& message) {
   TRACE_EVENT2("ipc,toplevel", "ChannelMojo::OnMessageReceived",
                "class", IPC_MESSAGE_ID_CLASS(message.type()),
                "line", IPC_MESSAGE_ID_LINE(message.type()));
   if (AttachmentBroker* broker = AttachmentBroker::GetGlobal()) {
     if (broker->OnMessageReceived(message))
       return;
   }
   listener_->OnMessageReceived(message);
   if (message.dispatch_error())
@@ skipping 56 matching lines @@
         std::move(unwrapped_attachment));
     DCHECK(ok);
     if (!ok) {
       LOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
   return MOJO_RESULT_OK;
 }
 
+mojo::AssociatedGroup* ChannelMojo::GetAssociatedGroup() {
+  DCHECK(bootstrap_);
+  return bootstrap_->GetAssociatedGroup();
+}
+
+void ChannelMojo::AddGenericAssociatedInterface(
+    const std::string& name,
+    const GenericAssociatedInterfaceFactory& factory) {
+  auto result = associated_interfaces_.insert({ name, factory });
+  DCHECK(result.second);
+}
+
+void ChannelMojo::GetGenericRemoteAssociatedInterface(
+    const std::string& name,
+    mojo::ScopedInterfaceEndpointHandle handle) {
+  DCHECK(message_reader_);
+  message_reader_->GetRemoteInterface(name, std::move(handle));
+}
+
 }  // namespace IPC