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

mojo/system/message_pipe.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.h"
 
 #include "base/logging.h"
 #include "mojo/system/channel_endpoint.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/message_in_transit.h"
 #include "mojo/system/message_pipe_dispatcher.h"
 #include "mojo/system/message_pipe_endpoint.h"
 #include "mojo/system/proxy_message_pipe_endpoint.h"
 
 namespace mojo {
 namespace system {
 
-MessagePipe::MessagePipe(scoped_ptr<MessagePipeEndpoint> endpoint0,
-                         scoped_ptr<MessagePipeEndpoint> endpoint1) {
-  endpoints_[0].reset(endpoint0.release());
-  endpoints_[1].reset(endpoint1.release());
+// static
+MessagePipe* MessagePipe::CreateLocalLocal() {
+  MessagePipe* message_pipe = new MessagePipe();
+  message_pipe->endpoints_[0].reset(new LocalMessagePipeEndpoint());
+  message_pipe->endpoints_[1].reset(new LocalMessagePipeEndpoint());
+  return message_pipe;
 }
 
 // static
-MessagePipe* MessagePipe::CreateLocalLocal() {
-  return new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint));
+MessagePipe* MessagePipe::CreateLocalProxy(
+    scoped_refptr<ChannelEndpoint>* channel_endpoint) {
+  DCHECK(!channel_endpoint->get());  // Not technically wrong, but unlikely.
+  MessagePipe* message_pipe = new MessagePipe();
+  message_pipe->endpoints_[0].reset(new LocalMessagePipeEndpoint());
+  *channel_endpoint = new ChannelEndpoint(message_pipe, 1);
+  message_pipe->endpoints_[1].reset(
+      new ProxyMessagePipeEndpoint(channel_endpoint->get()));
+  return message_pipe;
 }
 
 // static
-MessagePipe* MessagePipe::CreateLocalProxy() {
-  return new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint));
+MessagePipe* MessagePipe::CreateProxyLocal(
+    scoped_refptr<ChannelEndpoint>* channel_endpoint) {
+  DCHECK(!channel_endpoint->get());  // Not technically wrong, but unlikely.
+  MessagePipe* message_pipe = new MessagePipe();
+  *channel_endpoint = new ChannelEndpoint(message_pipe, 0);
+  message_pipe->endpoints_[0].reset(
+      new ProxyMessagePipeEndpoint(channel_endpoint->get()));
+  message_pipe->endpoints_[1].reset(new LocalMessagePipeEndpoint());
+  return message_pipe;
 }
 
 // static
-MessagePipe* MessagePipe::CreateProxyLocal() {
-  return new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint));
-}
-
-// static
 unsigned MessagePipe::GetPeerPort(unsigned port) {
   DCHECK(port == 0 || port == 1);
   return port ^ 1;
 }
 
 MessagePipeEndpoint::Type MessagePipe::GetType(unsigned port) {
   DCHECK(port == 0 || port == 1);
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port]);
 
@@ skipping 102 matching lines @@
   // TODO(vtl): Allowing this case is a temporary hack. It'll set up a
   // |MessagePipe| with two proxy endpoints, which will then act as a proxy
   // (rather than trying to connect the two ends directly).
   DLOG_IF(WARNING,
           is_peer_open &&
               endpoints_[GetPeerPort(port)]->GetType() !=
                   MessagePipeEndpoint::kTypeLocal)
       << "Direct message pipe passing across multiple channels not yet "
          "implemented; will proxy";
 
+  scoped_refptr<ChannelEndpoint> channel_endpoint(
+      new ChannelEndpoint(this, port));
   scoped_ptr<MessagePipeEndpoint> replacement_endpoint(
       new ProxyMessagePipeEndpoint(
+          channel_endpoint.get(),
           static_cast<LocalMessagePipeEndpoint*>(endpoints_[port].get()),
           is_peer_open));
   endpoints_[port].swap(replacement_endpoint);
 
-  return make_scoped_refptr(new ChannelEndpoint(this, port));
+  return channel_endpoint;
 }
 
 MojoResult MessagePipe::EnqueueMessage(unsigned port,
                                        scoped_ptr<MessageInTransit> message) {
   return EnqueueMessageInternal(port, message.Pass(), NULL);
 }
 
 bool MessagePipe::Attach(unsigned port, ChannelEndpoint* channel_endpoint) {
   DCHECK(port == 0 || port == 1);
   DCHECK(channel_endpoint);
 
   base::AutoLock locker(lock_);
   if (!endpoints_[port])
     return false;
 
   DCHECK_EQ(endpoints_[port]->GetType(), MessagePipeEndpoint::kTypeProxy);
-  endpoints_[port]->Attach(channel_endpoint);
   return true;
 }
 
 void MessagePipe::Run(unsigned port) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port]);
   if (!endpoints_[port]->Run())
     endpoints_[port].reset();
 }
 
 void MessagePipe::OnRemove(unsigned port) {
   unsigned destination_port = GetPeerPort(port);
 
   base::AutoLock locker(lock_);
   // A |OnPeerClose()| can come in first, before |OnRemove()| gets called.
   if (!endpoints_[port])
     return;
 
   endpoints_[port]->OnRemove();
   if (endpoints_[destination_port]) {
     if (!endpoints_[destination_port]->OnPeerClose())
       endpoints_[destination_port].reset();
   }
   endpoints_[port].reset();
 }
 
+MessagePipe::MessagePipe() {
+}
+
 MessagePipe::~MessagePipe() {
   // Owned by the dispatchers. The owning dispatchers should only release us via
   // their |Close()| method, which should inform us of being closed via our
   // |Close()|. Thus these should already be null.
   DCHECK(!endpoints_[0]);
   DCHECK(!endpoints_[1]);
 }
 
 MojoResult MessagePipe::EnqueueMessageInternal(
     unsigned port,
@@ skipping 74 matching lines @@
 MojoResult MessagePipe::HandleControlMessage(
     unsigned /*port*/,
     scoped_ptr<MessageInTransit> message) {
   LOG(WARNING) << "Unrecognized MessagePipe control message subtype "
                << message->subtype();
   return MOJO_RESULT_UNKNOWN;
 }
 
 }  // namespace system
 }  // namespace mojo