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

mojo/edk/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/edk/system/message_pipe_dispatcher.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/options_validation.h"
 #include "mojo/edk/system/proxy_message_pipe_endpoint.h"
 
 namespace mojo {
 namespace system {
@@ skipping 29 matching lines @@
     return MOJO_RESULT_UNIMPLEMENTED;
   out_options->flags = reader.options().flags;
 
   // Checks for fields beyond |flags|:
 
   // (Nothing here yet.)
 
   return MOJO_RESULT_OK;
 }
 
-void MessagePipeDispatcher::Init(scoped_refptr<MessagePipe> message_pipe,
+void MessagePipeDispatcher::Init(RefPtr<MessagePipe>&& message_pipe,
                                  unsigned port) {
   DCHECK(message_pipe);
   DCHECK(port == 0 || port == 1);
 
-  message_pipe_ = message_pipe;
+  message_pipe_ = std::move(message_pipe);
   port_ = port;
 }
 
 Dispatcher::Type MessagePipeDispatcher::GetType() const {
   return Type::MESSAGE_PIPE;
 }
 
 // static
 scoped_refptr<MessagePipeDispatcher>
 MessagePipeDispatcher::CreateRemoteMessagePipe(
     RefPtr<ChannelEndpoint>* channel_endpoint) {
-  scoped_refptr<MessagePipe> message_pipe(
-      MessagePipe::CreateLocalProxy(channel_endpoint));
+  auto message_pipe = MessagePipe::CreateLocalProxy(channel_endpoint);
   scoped_refptr<MessagePipeDispatcher> dispatcher =
       Create(kDefaultCreateOptions);
-  dispatcher->Init(message_pipe, 0);
+  dispatcher->Init(std::move(message_pipe), 0);
   return dispatcher;
 }
 
 // static
 scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size) {
   unsigned port = kInvalidPort;
-  scoped_refptr<MessagePipe> message_pipe;
+  RefPtr<MessagePipe> message_pipe;
   if (!MessagePipe::Deserialize(channel, source, size, &message_pipe, &port))
     return nullptr;
   DCHECK(message_pipe);
   DCHECK(port == 0 || port == 1);
 
   scoped_refptr<MessagePipeDispatcher> dispatcher =
       Create(kDefaultCreateOptions);
-  dispatcher->Init(message_pipe, port);
+  dispatcher->Init(std::move(message_pipe), port);
   return dispatcher;
 }
 
 MessagePipeDispatcher::MessagePipeDispatcher() : port_(kInvalidPort) {
 }
 
 MessagePipeDispatcher::~MessagePipeDispatcher() {
   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
   DCHECK(!message_pipe_);
 }
@@ skipping 21 matching lines @@
 }
 
 scoped_refptr<Dispatcher>
 MessagePipeDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   mutex().AssertHeld();
 
   // TODO(vtl): Currently, there are no options, so we just use
   // |kDefaultCreateOptions|. Eventually, we'll have to duplicate the options
   // too.
   scoped_refptr<MessagePipeDispatcher> rv = Create(kDefaultCreateOptions);
-  rv->Init(message_pipe_, port_);
-  message_pipe_ = nullptr;
+  rv->Init(std::move(message_pipe_), port_);
   port_ = kInvalidPort;
   return scoped_refptr<Dispatcher>(rv.get());
 }
 
 MojoResult MessagePipeDispatcher::WriteMessageImplNoLock(
     UserPointer<const void> bytes,
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
   DCHECK(!transports ||
@@ skipping 70 matching lines @@
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport)
     : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(),
             Dispatcher::Type::MESSAGE_PIPE);
 }
 
 }  // namespace system
 }  // namespace mojo