EDK: Replace HandleTable::GetAndRemoveDispatcher() with GetAndRemoveHandle().

mojo/edk/system/core.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/core.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 80 matching lines @@
       handle_table_(GetConfiguration().max_handle_table_size) {}
 
 Core::~Core() {
 }
 
 MojoHandle Core::AddHandle(Handle&& handle) {
   MutexLocker locker(&handle_table_mutex_);
   return handle_table_.AddHandle(std::move(handle));
 }
 
-MojoResult Core::GetDispatcher(MojoHandle handle_value,
+MojoResult Core::GetDispatcher(MojoHandle handle,
                                RefPtr<Dispatcher>* dispatcher) {
-  if (handle_value == MOJO_HANDLE_INVALID)
+  if (handle == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   MutexLocker locker(&handle_table_mutex_);
-  Handle handle;
-  MojoResult rv = handle_table_.GetHandle(handle_value, &handle);
+  Handle h;
+  MojoResult rv = handle_table_.GetHandle(handle, &h);
   if (rv == MOJO_RESULT_OK)
-    *dispatcher = std::move(handle.dispatcher);
+    *dispatcher = std::move(h.dispatcher);
   return rv;
 }
 
-MojoResult Core::GetAndRemoveDispatcher(MojoHandle handle_value,
+MojoResult Core::GetAndRemoveDispatcher(MojoHandle handle,
                                         RefPtr<Dispatcher>* dispatcher) {
-  if (handle_value == MOJO_HANDLE_INVALID)
+  if (handle == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   MutexLocker locker(&handle_table_mutex_);
-  return handle_table_.GetAndRemoveDispatcher(handle_value, dispatcher);
+  Handle h;
+  MojoResult rv = handle_table_.GetAndRemoveHandle(handle, &h);
+  if (rv == MOJO_RESULT_OK)
+    *dispatcher = std::move(h.dispatcher);
+  return rv;
 }
 
 MojoResult Core::AsyncWait(MojoHandle handle,
                            MojoHandleSignals signals,
                            const std::function<void(MojoResult)>& callback) {
   RefPtr<Dispatcher> dispatcher;
   MojoResult result = GetDispatcher(handle, &dispatcher);
   if (result != MOJO_RESULT_OK)
     return result;
 
   std::unique_ptr<AsyncWaiter> waiter(new AsyncWaiter(callback));
   result = dispatcher->AddAwakable(waiter.get(), signals, 0, nullptr);
   if (result == MOJO_RESULT_OK)
     ignore_result(waiter.release());
   return result;
 }
 
 MojoTimeTicks Core::GetTimeTicksNow() {
   return GetTimeTicks();
 }
 
 MojoResult Core::Close(MojoHandle handle) {
   if (handle == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
-  RefPtr<Dispatcher> dispatcher;
+  Handle h;
   {
     MutexLocker locker(&handle_table_mutex_);
-    MojoResult result =
-        handle_table_.GetAndRemoveDispatcher(handle, &dispatcher);
+    MojoResult result = handle_table_.GetAndRemoveHandle(handle, &h);
     if (result != MOJO_RESULT_OK)
       return result;
   }
 
   // The dispatcher doesn't have a say in being closed, but gets notified of it.
   // Note: This is done outside of |handle_table_mutex_|. As a result, there's a
   // race condition that the dispatcher must handle; see the comment in
   // |Dispatcher| in dispatcher.h.
-  return dispatcher->Close();
+  return h.dispatcher->Close();
 }
 
 MojoResult Core::Wait(MojoHandle handle,
                       MojoHandleSignals signals,
                       MojoDeadline deadline,
                       UserPointer<MojoHandleSignalsState> signals_state) {
   uint32_t unused = static_cast<uint32_t>(-1);
   HandleSignalsState hss;
   MojoResult result = WaitManyInternal(&handle, &signals, 1, deadline, &unused,
                                        signals_state.IsNull() ? nullptr : &hss);
@@ skipping 527 matching lines @@
   if (signals_states) {
     for (; i < num_handles; i++)
       signals_states[i] = dispatchers[i]->GetHandleSignalsState();
   }
 
   return result;
 }
 
 }  // namespace system
 }  // namespace mojo