Mojo: Have |ProxyMessagePipeEndpoint|s constructed with a |ChannelEndpoint|.

mojo/system/message_pipe_dispatcher.cc

 // Copyright 2013 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/system/message_pipe_dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/channel_endpoint.h"
 #include "mojo/system/constants.h"
@@ skipping 65 matching lines @@
 
   message_pipe_ = message_pipe;
   port_ = port;
 }
 
 Dispatcher::Type MessagePipeDispatcher::GetType() const {
   return kTypeMessagePipe;
 }
 
 // static
-std::pair<scoped_refptr<MessagePipeDispatcher>, scoped_refptr<MessagePipe> >
-MessagePipeDispatcher::CreateRemoteMessagePipe() {
-  scoped_refptr<MessagePipe> message_pipe(MessagePipe::CreateLocalProxy());
+scoped_refptr<MessagePipeDispatcher>
+MessagePipeDispatcher::CreateRemoteMessagePipe(
+    scoped_refptr<ChannelEndpoint>* channel_endpoint) {
+  scoped_refptr<MessagePipe> message_pipe(
+      MessagePipe::CreateLocalProxy(channel_endpoint));
   scoped_refptr<MessagePipeDispatcher> dispatcher(
       new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions));
   dispatcher->Init(message_pipe, 0);
-
-  return std::make_pair(dispatcher, message_pipe);
+  return dispatcher;
 }
 
 // static
 scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size) {
   if (size != sizeof(SerializedMessagePipeDispatcher)) {
     LOG(ERROR) << "Invalid serialized message pipe dispatcher";
     return scoped_refptr<MessagePipeDispatcher>();
   }
 
-  std::pair<scoped_refptr<MessagePipeDispatcher>, scoped_refptr<MessagePipe> >
-      remote_message_pipe = CreateRemoteMessagePipe();
+  scoped_refptr<ChannelEndpoint> channel_endpoint;
+  scoped_refptr<MessagePipeDispatcher> dispatcher =
+      CreateRemoteMessagePipe(&channel_endpoint);
 
   MessageInTransit::EndpointId remote_id =
       static_cast<const SerializedMessagePipeDispatcher*>(source)->endpoint_id;
   if (remote_id == MessageInTransit::kInvalidEndpointId) {
     // This means that the other end was closed, and there were no messages
     // enqueued for us.
     // TODO(vtl): This is wrong. We should produce a "dead" message pipe
     // dispatcher.
     NOTIMPLEMENTED();
     return scoped_refptr<MessagePipeDispatcher>();
   }
   MessageInTransit::EndpointId local_id =
-      channel->AttachEndpoint(make_scoped_refptr(
-          new ChannelEndpoint(remote_message_pipe.second.get(), 1)));
+      channel->AttachEndpoint(channel_endpoint);
   if (local_id == MessageInTransit::kInvalidEndpointId) {
     LOG(ERROR) << "Failed to deserialize message pipe dispatcher (failed to "
                   "attach; remote ID = " << remote_id << ")";
     return scoped_refptr<MessagePipeDispatcher>();
   }
   DVLOG(2) << "Deserializing message pipe dispatcher (remote ID = " << remote_id
            << ", new local ID = " << local_id << ")";
 
   if (!channel->RunMessagePipeEndpoint(local_id, remote_id)) {
     // In general, this shouldn't fail, since we generated |local_id| locally.
     NOTREACHED();
     return scoped_refptr<MessagePipeDispatcher>();
   }
 
   // TODO(vtl): FIXME -- Need some error handling here.
   channel->RunRemoteMessagePipeEndpoint(local_id, remote_id);
-  return remote_message_pipe.first;
+  return dispatcher;
 }
 
 MessagePipeDispatcher::~MessagePipeDispatcher() {
   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
   DCHECK(!message_pipe_.get());
 }
 
 MessagePipe* MessagePipeDispatcher::GetMessagePipeNoLock() const {
   lock().AssertAcquired();
   return message_pipe_.get();
@@ skipping 125 matching lines @@
 // MessagePipeDispatcherTransport ----------------------------------------------
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport)
     : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(), Dispatcher::kTypeMessagePipe);
 }
 
 }  // namespace system
 }  // namespace mojo