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

mojo/edk/system/handle_table.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/handle_table.h"
 
 #include <limits>
+#include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/dispatcher.h"
 
 namespace mojo {
 namespace system {
 
 HandleTable::Entry::Entry() : busy(false) {
 }
 
-HandleTable::Entry::Entry(const scoped_refptr<Dispatcher>& dispatcher)
-    : dispatcher(dispatcher), busy(false) {
-}
+HandleTable::Entry::Entry(RefPtr<Dispatcher>&& dispatcher)
+    : dispatcher(std::move(dispatcher)), busy(false) {}
 
 HandleTable::Entry::~Entry() {
   DCHECK(!busy);
 }
 
 HandleTable::HandleTable() : next_handle_(MOJO_HANDLE_INVALID + 1) {
 }
 
 HandleTable::~HandleTable() {
   // This should usually not be reached (the only instance should be owned by
   // the singleton |Core|, which lives forever), except in tests.
 }
 
 Dispatcher* HandleTable::GetDispatcher(MojoHandle handle) {
   DCHECK_NE(handle, MOJO_HANDLE_INVALID);
 
   HandleToEntryMap::iterator it = handle_to_entry_map_.find(handle);
   if (it == handle_to_entry_map_.end())
     return nullptr;
   return it->second.dispatcher.get();
 }
 
-MojoResult HandleTable::GetAndRemoveDispatcher(
-    MojoHandle handle,
-    scoped_refptr<Dispatcher>* dispatcher) {
+MojoResult HandleTable::GetAndRemoveDispatcher(MojoHandle handle,
+                                               RefPtr<Dispatcher>* dispatcher) {
   DCHECK_NE(handle, MOJO_HANDLE_INVALID);
   DCHECK(dispatcher);
 
   HandleToEntryMap::iterator it = handle_to_entry_map_.find(handle);
   if (it == handle_to_entry_map_.end())
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (it->second.busy)
     return MOJO_RESULT_BUSY;
-  *dispatcher = it->second.dispatcher;
+  *dispatcher = std::move(it->second.dispatcher);
   handle_to_entry_map_.erase(it);
 
   return MOJO_RESULT_OK;
 }
 
-MojoHandle HandleTable::AddDispatcher(
-    const scoped_refptr<Dispatcher>& dispatcher) {
+MojoHandle HandleTable::AddDispatcher(Dispatcher* dispatcher) {
   if (handle_to_entry_map_.size() >= GetConfiguration().max_handle_table_size)
     return MOJO_HANDLE_INVALID;
-  return AddDispatcherNoSizeCheck(dispatcher);
+  return AddDispatcherNoSizeCheck(RefPtr<Dispatcher>(dispatcher));
 }
 
 std::pair<MojoHandle, MojoHandle> HandleTable::AddDispatcherPair(
-    const scoped_refptr<Dispatcher>& dispatcher0,
-    const scoped_refptr<Dispatcher>& dispatcher1) {
+    Dispatcher* dispatcher0,
+    Dispatcher* dispatcher1) {
   if (handle_to_entry_map_.size() + 1 >=
       GetConfiguration().max_handle_table_size)
     return std::make_pair(MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID);
-  return std::make_pair(AddDispatcherNoSizeCheck(dispatcher0),
-                        AddDispatcherNoSizeCheck(dispatcher1));
+  return std::make_pair(
+      AddDispatcherNoSizeCheck(RefPtr<Dispatcher>(dispatcher0)),
+      AddDispatcherNoSizeCheck(RefPtr<Dispatcher>(dispatcher1)));
 }
 
 bool HandleTable::AddDispatcherVector(const DispatcherVector& dispatchers,
                                       MojoHandle* handles) {
   size_t max_message_num_handles = GetConfiguration().max_message_num_handles;
   size_t max_handle_table_size = GetConfiguration().max_handle_table_size;
 
   DCHECK_LE(dispatchers.size(), max_message_num_handles);
   DCHECK(handles);
   DCHECK_LT(
       static_cast<uint64_t>(max_handle_table_size) + max_message_num_handles,
       std::numeric_limits<size_t>::max())
       << "Addition may overflow";
 
   if (handle_to_entry_map_.size() + dispatchers.size() > max_handle_table_size)
     return false;
 
   for (size_t i = 0; i < dispatchers.size(); i++) {
     if (dispatchers[i]) {
-      handles[i] = AddDispatcherNoSizeCheck(dispatchers[i]);
+      handles[i] = AddDispatcherNoSizeCheck(dispatchers[i].Clone());
     } else {
       LOG(WARNING) << "Invalid dispatcher at index " << i;
       handles[i] = MOJO_HANDLE_INVALID;
     }
   }
   return true;
 }
 
 MojoResult HandleTable::MarkBusyAndStartTransport(
     MojoHandle disallowed_handle,
@@ skipping 74 matching lines @@
       entries[j]->busy = false;
       (*transports)[j].End();
     }
     return error_result;
   }
 
   return MOJO_RESULT_OK;
 }
 
 MojoHandle HandleTable::AddDispatcherNoSizeCheck(
-    const scoped_refptr<Dispatcher>& dispatcher) {
+    RefPtr<Dispatcher>&& dispatcher) {
   DCHECK(dispatcher);
   DCHECK_LT(handle_to_entry_map_.size(),
             GetConfiguration().max_handle_table_size);
   DCHECK_NE(next_handle_, MOJO_HANDLE_INVALID);
 
   // TODO(vtl): Maybe we want to do something different/smarter. (Or maybe try
   // assigning randomly?)
   while (handle_to_entry_map_.find(next_handle_) !=
          handle_to_entry_map_.end()) {
     next_handle_++;
     if (next_handle_ == MOJO_HANDLE_INVALID)
       next_handle_++;
   }
 
   MojoHandle new_handle = next_handle_;
-  handle_to_entry_map_[new_handle] = Entry(dispatcher);
+  handle_to_entry_map_[new_handle] = Entry(std::move(dispatcher));
 
   next_handle_++;
   if (next_handle_ == MOJO_HANDLE_INVALID)
     next_handle_++;
 
   return new_handle;
 }
 
 void HandleTable::RemoveBusyHandles(const MojoHandle* handles,
                                     uint32_t num_handles) {
@@ skipping 17 matching lines @@
   for (uint32_t i = 0; i < num_handles; i++) {
     HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]);
     DCHECK(it != handle_to_entry_map_.end());
     DCHECK(it->second.busy);
     it->second.busy = false;
   }
 }
 
 }  // namespace system
 }  // namespace mojo