Convert mojo::system::Dispatcher 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"
@@ skipping 51 matching lines @@
 
   message_pipe_ = std::move(message_pipe);
   port_ = port;
 }
 
 Dispatcher::Type MessagePipeDispatcher::GetType() const {
   return Type::MESSAGE_PIPE;
 }
 
 // static
-scoped_refptr<MessagePipeDispatcher>
-MessagePipeDispatcher::CreateRemoteMessagePipe(
+RefPtr<MessagePipeDispatcher> MessagePipeDispatcher::CreateRemoteMessagePipe(
     RefPtr<ChannelEndpoint>* channel_endpoint) {
   auto message_pipe = MessagePipe::CreateLocalProxy(channel_endpoint);
-  scoped_refptr<MessagePipeDispatcher> dispatcher =
-      Create(kDefaultCreateOptions);
+  auto dispatcher = MessagePipeDispatcher::Create(kDefaultCreateOptions);
   dispatcher->Init(std::move(message_pipe), 0);
   return dispatcher;
 }
 
 // static
-scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
+RefPtr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size) {
   unsigned port = kInvalidPort;
   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);
+  auto dispatcher = MessagePipeDispatcher::Create(kDefaultCreateOptions);
   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 14 matching lines @@
   message_pipe_->CancelAllAwakables(port_);
 }
 
 void MessagePipeDispatcher::CloseImplNoLock() {
   mutex().AssertHeld();
   message_pipe_->Close(port_);
   message_pipe_ = nullptr;
   port_ = kInvalidPort;
 }
 
-scoped_refptr<Dispatcher>
+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(std::move(message_pipe_), port_);
+  auto dispatcher = MessagePipeDispatcher::Create(kDefaultCreateOptions);
+  dispatcher->Init(std::move(message_pipe_), port_);
   port_ = kInvalidPort;
-  return scoped_refptr<Dispatcher>(rv.get());
+  return dispatcher;
 }
 
 MojoResult MessagePipeDispatcher::WriteMessageImplNoLock(
     UserPointer<const void> bytes,
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
   DCHECK(!transports ||
          (transports->size() > 0 &&
           transports->size() <= GetConfiguration().max_message_num_handles));
@@ skipping 38 matching lines @@
     Awakable* awakable,
     HandleSignalsState* signals_state) {
   mutex().AssertHeld();
   message_pipe_->RemoveAwakable(port_, awakable, signals_state);
 }
 
 void MessagePipeDispatcher::StartSerializeImplNoLock(
     Channel* channel,
     size_t* max_size,
     size_t* max_platform_handles) {
-  DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
+  AssertHasOneRef();  // Only one ref => no need to take the lock.
   return message_pipe_->StartSerialize(port_, channel, max_size,
                                        max_platform_handles);
 }
 
 bool MessagePipeDispatcher::EndSerializeAndCloseImplNoLock(
     Channel* channel,
     void* destination,
     size_t* actual_size,
     embedder::PlatformHandleVector* platform_handles) {
-  DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
+  AssertHasOneRef();  // Only one ref => no need to take the lock.
 
   bool rv = message_pipe_->EndSerialize(port_, channel, destination,
                                         actual_size, platform_handles);
   message_pipe_ = nullptr;
   port_ = kInvalidPort;
   return rv;
 }
 
 // MessagePipeDispatcherTransport ----------------------------------------------
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport)
     : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(),
             Dispatcher::Type::MESSAGE_PIPE);
 }
 
 }  // namespace system
 }  // namespace mojo