Adds associated interface support to IPC::Channel

ipc/ipc_message_pipe_reader.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_message_pipe_reader.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 97 matching lines @@
   DCHECK_LE(num_handles, std::numeric_limits<uint32_t>::max());
 
   mojo_message->set_interface_id(sender_interface_id_);
   result = mojo::WriteMessageNew(sender_pipe_, mojo_message->TakeMojoMessage(),
                                  MOJO_WRITE_MESSAGE_FLAG_NONE);
 
   DVLOG(4) << "Send " << message->type() << ": " << message->size();
   return result == MOJO_RESULT_OK;
 }
 
+void MessagePipeReader::GetRemoteInterface(
+    const std::string& name,
+    mojo::ScopedInterfaceEndpointHandle handle) {
+  mojom::GenericInterfaceAssociatedRequest request;
+  request.Bind(std::move(handle));
+  sender_->GetAssociatedInterface(name, std::move(request));
+}
+
 void MessagePipeReader::Receive(
     mojo::Array<uint8_t> data,
     mojo::Array<mojom::SerializedHandlePtr> handles) {
   Message message(
       data.size() == 0 ? "" : reinterpret_cast<const char*>(&data[0]),
       static_cast<uint32_t>(data.size()));
   message.set_sender_pid(peer_pid_);
 
   DVLOG(4) << "Receive " << message.type() << ": " << message.size();
   MojoResult write_result =
       ChannelMojo::WriteToMessageAttachmentSet(std::move(handles), &message);
   if (write_result != MOJO_RESULT_OK) {
     OnPipeError(write_result);
     return;
   }
 
   TRACE_EVENT_WITH_FLOW0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
                          "MessagePipeReader::Receive",
                          message.flags(),
                          TRACE_EVENT_FLAG_FLOW_IN);
   delegate_->OnMessageReceived(message);
 }
 
+void MessagePipeReader::GetAssociatedInterface(
+    const mojo::String& name,
+    mojom::GenericInterfaceAssociatedRequest request) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (delegate_)
+    delegate_->OnAssociatedInterfaceRequest(name, request.PassHandle());
+}
+
 void MessagePipeReader::OnPipeError(MojoResult error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (delegate_)
     delegate_->OnPipeError();
   Close();
 }
 
 void MessagePipeReader::DelayedDeleter::operator()(
     MessagePipeReader* ptr) const {
   ptr->Close();
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(&DeleteNow, ptr));
 }
 
 }  // namespace internal
 }  // namespace IPC