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 276 matching lines @@
     // avoid deadlock when freeing it below.
     std::swap(message_reader_, reader);
 
     // We might Close() before we Connect().
     waiting_connect_ = false;
   }
 
   reader.reset();
 }
 
+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));
+}
+
 // MojoBootstrap::Delegate implementation
 void ChannelMojo::OnPipesAvailable(
     mojom::ChannelAssociatedPtrInfo send_channel,
     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 142 matching lines @@
     DCHECK(ok);
     if (!ok) {
       LOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
   return MOJO_RESULT_OK;
 }
 
 }  // namespace IPC