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

mojo/edk/system/channel.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/channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 158 matching lines @@
 void Channel::SerializeEndpointWithClosedPeer(
     void* destination,
     MessageInTransitQueue* message_queue) {
   // We can actually just pass no client to |SerializeEndpointWithLocalPeer()|.
   SerializeEndpointWithLocalPeer(destination, message_queue, nullptr, 0);
 }
 
 RefPtr<ChannelEndpoint> Channel::SerializeEndpointWithLocalPeer(
     void* destination,
     MessageInTransitQueue* message_queue,
-    ChannelEndpointClient* endpoint_client,
+    RefPtr<ChannelEndpointClient>&& endpoint_client,
     unsigned endpoint_client_port) {
   DCHECK(destination);
   // Allow |endpoint_client| to be null, for use by
   // |SerializeEndpointWithClosedPeer()|.
 
   auto endpoint = MakeRefCounted<ChannelEndpoint>(
-      endpoint_client, endpoint_client_port, message_queue);
+      std::move(endpoint_client), endpoint_client_port, message_queue);
 
   SerializedEndpoint* s = static_cast<SerializedEndpoint*>(destination);
   s->receiver_endpoint_id = AttachAndRunEndpoint(endpoint.Clone());
   DVLOG(2) << "Serializing endpoint with local or closed peer (remote ID = "
            << s->receiver_endpoint_id << ")";
 
   return endpoint;
 }
 
 void Channel::SerializeEndpointWithRemotePeer(
     void* destination,
     MessageInTransitQueue* message_queue,
     RefPtr<ChannelEndpoint>&& peer_endpoint) {
   DCHECK(destination);
   DCHECK(peer_endpoint);
 
   DLOG(WARNING) << "Direct message pipe passing across multiple channels not "
                    "yet implemented; will proxy";
   // Create and set up an |EndpointRelayer| to proxy.
   // TODO(vtl): If we were to own/track the relayer directly (rather than owning
   // it via its |ChannelEndpoint|s), then we might be able to make
   // |ChannelEndpoint|'s |client_| pointer a raw pointer.
-  scoped_refptr<EndpointRelayer> relayer(new EndpointRelayer());
+  auto relayer = MakeRefCounted<EndpointRelayer>();
   auto endpoint =
-      MakeRefCounted<ChannelEndpoint>(relayer.get(), 0, message_queue);
+      MakeRefCounted<ChannelEndpoint>(relayer.Clone(), 0, message_queue);
   relayer->Init(endpoint.Clone(), peer_endpoint.Clone());
-  peer_endpoint->ReplaceClient(relayer.get(), 1);
+  peer_endpoint->ReplaceClient(std::move(relayer), 1);
 
   SerializedEndpoint* s = static_cast<SerializedEndpoint*>(destination);
   s->receiver_endpoint_id = AttachAndRunEndpoint(std::move(endpoint));
   DVLOG(2) << "Serializing endpoint with remote peer (remote ID = "
            << s->receiver_endpoint_id << ")";
 }
 
-scoped_refptr<IncomingEndpoint> Channel::DeserializeEndpoint(
-    const void* source) {
+RefPtr<IncomingEndpoint> Channel::DeserializeEndpoint(const void* source) {
   const SerializedEndpoint* s = static_cast<const SerializedEndpoint*>(source);
   ChannelEndpointId local_id = s->receiver_endpoint_id;
   // No need to check the validity of |local_id| -- if it's not valid, it simply
   // won't be in |incoming_endpoints_|.
   DVLOG_IF(2, !local_id.is_valid() || !local_id.is_remote())
       << "Attempt to get incoming endpoint for invalid ID " << local_id;
 
   MutexLocker locker(&mutex_);
 
   auto it = incoming_endpoints_.find(local_id);
   if (it == incoming_endpoints_.end()) {
     LOG(ERROR) << "Failed to deserialize endpoint (ID = " << local_id << ")";
     return nullptr;
   }
 
   DVLOG(2) << "Deserializing endpoint (new local ID = " << local_id << ")";
 
-  scoped_refptr<IncomingEndpoint> rv;
-  rv.swap(it->second);
+  RefPtr<IncomingEndpoint> rv = std::move(it->second);
   incoming_endpoints_.erase(it);
   return rv;
 }
 
 size_t Channel::GetSerializedPlatformHandleSize() const {
   // TODO(vtl): Having to lock |mutex_| here is a bit unfortunate. Maybe we
   // should get the size in |Init()| and cache it?
   MutexLocker locker(&mutex_);
   return raw_channel_->GetSerializedPlatformHandleSize();
 }
@@ skipping 210 matching lines @@
   }
 
   // Conversely, the remote end should be "local".
   if (!remote_id.is_valid() || remote_id.is_remote()) {
     DVLOG(2) << "Received attach and run endpoint with invalid remote ID";
     return false;
   }
 
   // Create/initialize an |IncomingEndpoint| and thus an endpoint (outside the
   // lock).
-  scoped_refptr<IncomingEndpoint> incoming_endpoint(new IncomingEndpoint());
+  auto incoming_endpoint = MakeRefCounted<IncomingEndpoint>();
   RefPtr<ChannelEndpoint> endpoint = incoming_endpoint->Init();
 
   bool success = true;
   {
     MutexLocker locker(&mutex_);
 
     if (local_id_to_endpoint_map_.find(local_id) ==
         local_id_to_endpoint_map_.end()) {
       DCHECK(incoming_endpoints_.find(local_id) == incoming_endpoints_.end());
 
@@ skipping 139 matching lines @@
            << ", local ID " << local_id << ", remote ID " << remote_id;
   std::unique_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::Type::CHANNEL, subtype, num_bytes, bytes));
   message->set_source_id(local_id);
   message->set_destination_id(remote_id);
   return WriteMessage(std::move(message));
 }
 
 }  // namespace system
 }  // namespace mojo