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

mojo/edk/system/channel_endpoint.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 "mojo/edk/system/channel_endpoint.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
@@ skipping 17 matching lines @@
     case State::RUNNING:
       return WriteMessageNoLock(std::move(message));
     case State::DEAD:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
-bool ChannelEndpoint::ReplaceClient(ChannelEndpointClient* client,
+bool ChannelEndpoint::ReplaceClient(RefPtr<ChannelEndpointClient>&& client,
                                     unsigned client_port) {
   DCHECK(client);
 
   MutexLocker locker(&mutex_);
   DCHECK(client_);
-  DCHECK(client != client_.get() || client_port != client_port_);
-  client_ = client;
+  DCHECK(client != client_ || client_port != client_port_);
+  client_ = std::move(client);
   client_port_ = client_port;
   return state_ != State::DEAD;
 }
 
 void ChannelEndpoint::DetachFromClient() {
   MutexLocker locker(&mutex_);
   DCHECK(client_);
   client_ = nullptr;
 
   if (!channel_)
@@ skipping 39 matching lines @@
   DCHECK_EQ(message->type(), MessageInTransit::Type::ENDPOINT);
 
   // TODO(vtl)
   // Note that this won't crash on Release builds, which is important (since the
   // other side may be malicious). Doing nothing is safe and will dispose of the
   // message.
   NOTREACHED();
 }
 
 void ChannelEndpoint::DetachFromChannel() {
-  scoped_refptr<ChannelEndpointClient> client;
+  RefPtr<ChannelEndpointClient> client;
   unsigned client_port = 0;
   {
     MutexLocker locker(&mutex_);
 
     if (client_) {
       // Take a ref, and call |OnDetachFromChannel()| outside the lock.
       client = client_;
       client_port = client_port_;
     }
 
     // |channel_| may already be null if we already detached from the channel in
     // |DetachFromClient()| by calling |Channel::DetachEndpoint()| (and there
     // are racing detaches).
     if (channel_)
       DieNoLock();
     else
       DCHECK(state_ == State::DEAD);
   }
 
   // If |ReplaceClient()| is called (from another thread) after the above locked
   // section but before we call |OnDetachFromChannel()|, |ReplaceClient()|
   // returns false to notify the caller that the channel was already detached.
   // (The old client has to accept the arguably-spurious call to
   // |OnDetachFromChannel()|.)
   if (client)
     client->OnDetachFromChannel(client_port);
 }
 
-ChannelEndpoint::ChannelEndpoint(ChannelEndpointClient* client,
+ChannelEndpoint::ChannelEndpoint(RefPtr<ChannelEndpointClient>&& client,
                                  unsigned client_port,
                                  MessageInTransitQueue* message_queue)
     : state_(State::PAUSED),
-      client_(client),
+      client_(std::move(client)),
       client_port_(client_port),
       channel_(nullptr) {
   DCHECK(client_ || message_queue);
 
   if (message_queue)
     channel_message_queue_.Swap(message_queue);
 }
 
 ChannelEndpoint::~ChannelEndpoint() {
   DCHECK(!client_);
@@ skipping 15 matching lines @@
   message->SerializeAndCloseDispatchers(channel_);
   message->set_source_id(local_id_);
   message->set_destination_id(remote_id_);
   return channel_->WriteMessage(std::move(message));
 }
 
 void ChannelEndpoint::OnReadMessageForClient(
     std::unique_ptr<MessageInTransit> message) {
   DCHECK_EQ(message->type(), MessageInTransit::Type::ENDPOINT_CLIENT);
 
-  scoped_refptr<ChannelEndpointClient> client;
+  RefPtr<ChannelEndpointClient> client;
   unsigned client_port = 0;
 
   // This loop is to make |ReplaceClient()| work. We can't call the client's
   // |OnReadMessage()| under our lock, so by the time we do that, |client| may
   // no longer be our client.
   //
   // In that case, |client| must return false. We'll then yield, and retry with
   // the new client. (Theoretically, the client could be replaced again.)
   //
   // This solution isn't terribly elegant, but it's the least costly way of
@@ skipping 34 matching lines @@
   DCHECK(remote_id_.is_valid());
 
   state_ = State::DEAD;
   channel_ = nullptr;
   local_id_ = ChannelEndpointId();
   remote_id_ = ChannelEndpointId();
 }
 
 }  // namespace system
 }  // namespace mojo