EDK: Replace HandleTable::GetDispatcher() with GetHandle().

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 21 matching lines @@
 using mojo::platform::PlatformSharedBufferMapping;
 using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
 // Implementation notes
 //
 // Mojo primitives are implemented by the singleton |Core| object. Most calls
-// are for a "primary" handle (the first argument). |Core::GetDispatcher()| is
-// used to look up a |Dispatcher| object for a given handle. That object
-// implements most primitives for that object. The wait primitives are not
-// attached to objects and are implemented by |Core| itself.
+// are for a "primary" handle (the first argument). |Core::GetHandle()| is used
+// to look up a |Handle| (in particular, a |Dispatcher| object) for a given
+// handle value. The |Dispatcher| object implements most primitives for that
+// (conceptual/logical) object. The wait primitives are not attached to objects
+// and are implemented by |Core| itself.
 //
 // Some objects have multiple handles associated to them, e.g., message pipes
 // (which have two). In such a case, there is still a |Dispatcher| (e.g.,
 // |MessagePipeDispatcher|) for each handle, with each handle having a strong
 // reference to the common "secondary" object (e.g., |MessagePipe|). This
 // secondary object does NOT have any references to the |Dispatcher|s (even if
 // it did, it wouldn't be able to do anything with them due to lock order
 // requirements -- see below).
 //
 // Waiting is implemented by having the thread that wants to wait call the
@@ skipping 34 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,
+MojoResult Core::GetDispatcher(MojoHandle handle_value,
                                RefPtr<Dispatcher>* dispatcher) {
-  if (handle == MOJO_HANDLE_INVALID)
+  if (handle_value == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   MutexLocker locker(&handle_table_mutex_);
-  return handle_table_.GetDispatcher(handle, dispatcher);
+  Handle handle;
+  MojoResult rv = handle_table_.GetHandle(handle_value, &handle);
+  if (rv == MOJO_RESULT_OK)
+    *dispatcher = std::move(handle.dispatcher);
+  return rv;
 }
 
-MojoResult Core::GetAndRemoveDispatcher(MojoHandle handle,
+MojoResult Core::GetAndRemoveDispatcher(MojoHandle handle_value,
                                         RefPtr<Dispatcher>* dispatcher) {
-  if (handle == MOJO_HANDLE_INVALID)
+  if (handle_value == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   MutexLocker locker(&handle_table_mutex_);
-  return handle_table_.GetAndRemoveDispatcher(handle, dispatcher);
+  return handle_table_.GetAndRemoveDispatcher(handle_value, dispatcher);
 }
 
 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;
 
@@ skipping 518 matching lines @@
   dispatchers.reserve(num_handles);
 
   {
     MutexLocker locker(&handle_table_mutex_);
     for (uint32_t i = 0; i < num_handles; i++) {
       if (handles[i] == MOJO_HANDLE_INVALID) {
         *result_index = i;
         return MOJO_RESULT_INVALID_ARGUMENT;
       }
 
-      RefPtr<Dispatcher> dispatcher;
-      MojoResult result = handle_table_.GetDispatcher(handles[i], &dispatcher);
+      Handle handle;
+      MojoResult result = handle_table_.GetHandle(handles[i], &handle);
       if (result != MOJO_RESULT_OK) {
         *result_index = i;
         return result;
       }
-      dispatchers.push_back(std::move(dispatcher));
+      dispatchers.push_back(std::move(handle.dispatcher));
     }
   }
 
   // TODO(vtl): Should make the waiter live (permanently) in TLS.
   Waiter waiter;
   waiter.Init();
 
   uint32_t i;
   MojoResult result = MOJO_RESULT_OK;
   for (i = 0; i < num_handles; i++) {
@@ skipping 21 matching lines @@
   if (signals_states) {
     for (; i < num_handles; i++)
       signals_states[i] = dispatchers[i]->GetHandleSignalsState();
   }
 
   return result;
 }
 
 }  // namespace system
 }  // namespace mojo