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

mojo/edk/system/shared_buffer_dispatcher.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/shared_buffer_dispatcher.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/platform_support.h"
@@ skipping 43 matching lines @@
   out_options->flags = reader.options().flags;
 
   // Checks for fields beyond |flags|:
 
   // (Nothing here yet.)
 
   return MOJO_RESULT_OK;
 }
 
 // static
-MojoResult SharedBufferDispatcher::Create(
+RefPtr<SharedBufferDispatcher> SharedBufferDispatcher::Create(
     embedder::PlatformSupport* platform_support,
     const MojoCreateSharedBufferOptions& /*validated_options*/,
     uint64_t num_bytes,
-    scoped_refptr<SharedBufferDispatcher>* result) {
-  if (!num_bytes)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-  if (num_bytes > GetConfiguration().max_shared_memory_num_bytes)
-    return MOJO_RESULT_RESOURCE_EXHAUSTED;
+    MojoResult* result) {
+  if (!num_bytes) {
+    *result = MOJO_RESULT_INVALID_ARGUMENT;
+    return nullptr;
+  }
+  if (num_bytes > GetConfiguration().max_shared_memory_num_bytes) {
+    *result = MOJO_RESULT_RESOURCE_EXHAUSTED;
+    return nullptr;
+  }
 
   scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer(
       platform_support->CreateSharedBuffer(static_cast<size_t>(num_bytes)));
-  if (!shared_buffer)
-    return MOJO_RESULT_RESOURCE_EXHAUSTED;
+  if (!shared_buffer) {
+    *result = MOJO_RESULT_RESOURCE_EXHAUSTED;
+    return nullptr;
+  }
 
-  *result = CreateInternal(shared_buffer.Pass());
-  return MOJO_RESULT_OK;
+  *result = MOJO_RESULT_OK;
+  return CreateInternal(shared_buffer.Pass());
 }
 
 Dispatcher::Type SharedBufferDispatcher::GetType() const {
   return Type::SHARED_BUFFER;
 }
 
 // static
-scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
+RefPtr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size,
     embedder::PlatformHandleVector* platform_handles) {
   DCHECK(channel);
 
   if (size != sizeof(SerializedSharedBufferDispatcher)) {
     LOG(ERROR) << "Invalid serialized shared buffer dispatcher (bad size)";
     return nullptr;
   }
@@ skipping 75 matching lines @@
 
   return MOJO_RESULT_OK;
 }
 
 void SharedBufferDispatcher::CloseImplNoLock() {
   mutex().AssertHeld();
   DCHECK(shared_buffer_);
   shared_buffer_ = nullptr;
 }
 
-scoped_refptr<Dispatcher>
+RefPtr<Dispatcher>
 SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   mutex().AssertHeld();
   DCHECK(shared_buffer_);
   return CreateInternal(shared_buffer_.Pass());
 }
 
 MojoResult SharedBufferDispatcher::DuplicateBufferHandleImplNoLock(
     UserPointer<const MojoDuplicateBufferHandleOptions> options,
-    scoped_refptr<Dispatcher>* new_dispatcher) {
+    RefPtr<Dispatcher>* new_dispatcher) {
   mutex().AssertHeld();
 
   MojoDuplicateBufferHandleOptions validated_options;
   MojoResult result = ValidateDuplicateOptions(options, &validated_options);
   if (result != MOJO_RESULT_OK)
     return result;
 
   // Note: Since this is "duplicate", we keep our ref to |shared_buffer_|.
   *new_dispatcher = CreateInternal(shared_buffer_);
   return MOJO_RESULT_OK;
@@ skipping 22 matching lines @@
   if (!*mapping)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   return MOJO_RESULT_OK;
 }
 
 void SharedBufferDispatcher::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.
   *max_size = sizeof(SerializedSharedBufferDispatcher);
   *max_platform_handles = 1;
 }
 
 bool SharedBufferDispatcher::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.
   DCHECK(shared_buffer_);
 
   SerializedSharedBufferDispatcher* serialization =
       static_cast<SerializedSharedBufferDispatcher*>(destination);
   // If there's only one reference to |shared_buffer_|, then it's ours (and no
   // one else can make any more references to it), so we can just take its
   // handle.
   embedder::ScopedPlatformHandle platform_handle(
       shared_buffer_->HasOneRef() ? shared_buffer_->PassPlatformHandle()
                                   : shared_buffer_->DuplicatePlatformHandle());
   if (!platform_handle.is_valid()) {
     shared_buffer_ = nullptr;
     return false;
   }
 
   serialization->num_bytes = shared_buffer_->GetNumBytes();
   serialization->platform_handle_index = platform_handles->size();
   platform_handles->push_back(platform_handle.release());
   *actual_size = sizeof(SerializedSharedBufferDispatcher);
 
   shared_buffer_ = nullptr;
 
   return true;
 }
 
 }  // namespace system
 }  // namespace mojo