Convert mojo::system::ChannelEndpointClient to use our new refcounting stuff (instead of base's).

mojo/edk/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/edk/system/message_pipe.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/incoming_endpoint.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/message_pipe_endpoint.h"
 #include "mojo/edk/system/proxy_message_pipe_endpoint.h"
 #include "mojo/edk/util/make_unique.h"
 
 namespace mojo {
 namespace system {
 
 // static
-MessagePipe* MessagePipe::CreateLocalLocal() MOJO_NO_THREAD_SAFETY_ANALYSIS {
-  MessagePipe* message_pipe = new MessagePipe();
+RefPtr<MessagePipe> MessagePipe::CreateLocalLocal()
+    MOJO_NO_THREAD_SAFETY_ANALYSIS {
+  RefPtr<MessagePipe> message_pipe = AdoptRef(new MessagePipe());
   message_pipe->endpoints_[0].reset(new LocalMessagePipeEndpoint());
   message_pipe->endpoints_[1].reset(new LocalMessagePipeEndpoint());
   return message_pipe;
 }
 
 // static
-MessagePipe* MessagePipe::CreateLocalProxy(
+RefPtr<MessagePipe> MessagePipe::CreateLocalProxy(
     RefPtr<ChannelEndpoint>* channel_endpoint) MOJO_NO_THREAD_SAFETY_ANALYSIS {
   DCHECK(!*channel_endpoint);  // Not technically wrong, but unlikely.
-  MessagePipe* message_pipe = new MessagePipe();
+  RefPtr<MessagePipe> message_pipe = AdoptRef(new MessagePipe());
   message_pipe->endpoints_[0].reset(new LocalMessagePipeEndpoint());
-  *channel_endpoint = MakeRefCounted<ChannelEndpoint>(message_pipe, 1);
+  *channel_endpoint = MakeRefCounted<ChannelEndpoint>(message_pipe.Clone(), 1);
   message_pipe->endpoints_[1].reset(
       new ProxyMessagePipeEndpoint(channel_endpoint->Clone()));
   return message_pipe;
 }
 
 // static
-MessagePipe* MessagePipe::CreateLocalProxyFromExisting(
+RefPtr<MessagePipe> MessagePipe::CreateLocalProxyFromExisting(
     MessageInTransitQueue* message_queue,
     RefPtr<ChannelEndpoint>&& channel_endpoint) MOJO_NO_THREAD_SAFETY_ANALYSIS {
   DCHECK(message_queue);
-  MessagePipe* message_pipe = new MessagePipe();
+  RefPtr<MessagePipe> message_pipe = AdoptRef(new MessagePipe());
   message_pipe->endpoints_[0].reset(
       new LocalMessagePipeEndpoint(message_queue));
   if (channel_endpoint) {
     bool attached_to_channel = channel_endpoint->ReplaceClient(message_pipe, 1);
     message_pipe->endpoints_[1].reset(
         new ProxyMessagePipeEndpoint(std::move(channel_endpoint)));
     if (!attached_to_channel)
       message_pipe->OnDetachFromChannel(1);
   } else {
     // This means that the proxy side was already closed; we only need to inform
     // the local side of this.
     // TODO(vtl): This is safe to do without locking (but perhaps slightly
     // dubious), since no other thread has access to |message_pipe| yet.
     message_pipe->endpoints_[0]->OnPeerClose();
   }
   return message_pipe;
 }
 
 // static
-MessagePipe* MessagePipe::CreateProxyLocal(
+RefPtr<MessagePipe> MessagePipe::CreateProxyLocal(
     RefPtr<ChannelEndpoint>* channel_endpoint) MOJO_NO_THREAD_SAFETY_ANALYSIS {
   DCHECK(!*channel_endpoint);  // Not technically wrong, but unlikely.
-  MessagePipe* message_pipe = new MessagePipe();
+  RefPtr<MessagePipe> message_pipe = AdoptRef(new MessagePipe());
   *channel_endpoint = MakeRefCounted<ChannelEndpoint>(message_pipe, 0);
   message_pipe->endpoints_[0].reset(
       new ProxyMessagePipeEndpoint(channel_endpoint->Clone()));
   message_pipe->endpoints_[1].reset(new LocalMessagePipeEndpoint());
   return message_pipe;
 }
 
 // static
 unsigned MessagePipe::GetPeerPort(unsigned port) {
   DCHECK(port == 0 || port == 1);
   return port ^ 1;
 }
 
 // static
 bool MessagePipe::Deserialize(Channel* channel,
                               const void* source,
                               size_t size,
-                              scoped_refptr<MessagePipe>* message_pipe,
+                              RefPtr<MessagePipe>* message_pipe,
                               unsigned* port) {
   DCHECK(!*message_pipe);  // Not technically wrong, but unlikely.
 
   if (size != channel->GetSerializedEndpointSize()) {
     LOG(ERROR) << "Invalid serialized message pipe";
     return false;
   }
 
-  scoped_refptr<IncomingEndpoint> incoming_endpoint =
+  RefPtr<IncomingEndpoint> incoming_endpoint =
       channel->DeserializeEndpoint(source);
   if (!incoming_endpoint)
     return false;
 
   *message_pipe = incoming_endpoint->ConvertToMessagePipe();
   DCHECK(*message_pipe);
   *port = 0;
   return true;
 }
 
@@ skipping 133 matching lines @@
   if (!endpoints_[peer_port]) {
     // Case 1: (known-)closed peer port. There's no reason for us to continue to
     // exist afterwards.
     channel->SerializeEndpointWithClosedPeer(destination, message_queue);
   } else if (endpoints_[peer_port]->GetType() ==
              MessagePipeEndpoint::kTypeLocal) {
     // Case 2: local peer port. We replace |port|'s |LocalMessagePipeEndpoint|
     // with a |ProxyMessagePipeEndpoint| hooked up to the |ChannelEndpoint| that
     // the |Channel| returns to us.
     RefPtr<ChannelEndpoint> channel_endpoint =
-        channel->SerializeEndpointWithLocalPeer(destination, message_queue,
-                                                this, port);
+        channel->SerializeEndpointWithLocalPeer(
+            destination, message_queue, RefPtr<ChannelEndpointClient>(this),
+            port);
     replacement_endpoint =
         new ProxyMessagePipeEndpoint(std::move(channel_endpoint));
   } else {
     // Case 3: remote peer port. We get the |peer_port|'s |ChannelEndpoint| and
     // pass it to the |Channel|. There's no reason for us to continue to exist
     // afterwards.
     DCHECK_EQ(endpoints_[peer_port]->GetType(),
               MessagePipeEndpoint::kTypeProxy);
     ProxyMessagePipeEndpoint* peer_endpoint =
         static_cast<ProxyMessagePipeEndpoint*>(endpoints_[peer_port].get());
@@ skipping 114 matching lines @@
       LOG(WARNING) << "Enqueueing null dispatcher";
       dispatchers->push_back(nullptr);
     }
   }
   message->SetDispatchers(std::move(dispatchers));
   return MOJO_RESULT_OK;
 }
 
 }  // namespace system
 }  // namespace mojo