EDK: Rename DispatcherTransport to HandleTransport.

mojo/edk/system/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/dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
 #include "mojo/edk/system/handle.h"
 #include "mojo/edk/system/handle_transport.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
 
 using mojo::platform::PlatformSharedBufferMapping;
 using mojo::platform::ScopedPlatformHandle;
 using mojo::util::MutexLocker;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
 namespace test {
 
 // TODO(vtl): Maybe this should be defined in a test-only file instead.
-DispatcherTransport HandleTryStartTransport(const Handle& handle) {
+HandleTransport HandleTryStartTransport(const Handle& handle) {
   return Dispatcher::HandleTableAccess::TryStartTransport(handle);
 }
 
 }  // namespace test
 
 // TODO(vtl): The thread-safety analyzer isn't smart enough to deal with the
 // fact that we give up if |TryLock()| fails.
 // static
-DispatcherTransport Dispatcher::HandleTableAccess::TryStartTransport(
+HandleTransport Dispatcher::HandleTableAccess::TryStartTransport(
     const Handle& handle) MOJO_NO_THREAD_SAFETY_ANALYSIS {
   DCHECK(handle.dispatcher);
 
   if (!handle.dispatcher->mutex_.TryLock())
-    return DispatcherTransport();
+    return HandleTransport();
 
   // We shouldn't race with things that close dispatchers, since closing can
   // only take place either under |handle_table_mutex_| or when the handle is
   // marked as busy.
   DCHECK(!handle.dispatcher->is_closed_);
 
-  return DispatcherTransport(handle);
+  return HandleTransport(handle);
 }
 
 // static
 void Dispatcher::TransportDataAccess::StartSerialize(
     Dispatcher* dispatcher,
     Channel* channel,
     size_t* max_size,
     size_t* max_platform_handles) {
   DCHECK(dispatcher);
   dispatcher->StartSerialize(channel, max_size, max_platform_handles);
@@ skipping 41 matching lines @@
 
 MojoResult Dispatcher::Close() {
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   CloseNoLock();
   return MOJO_RESULT_OK;
 }
 
-MojoResult Dispatcher::WriteMessage(
-    UserPointer<const void> bytes,
-    uint32_t num_bytes,
-    std::vector<DispatcherTransport>* transports,
-    MojoWriteMessageFlags flags) {
+MojoResult Dispatcher::WriteMessage(UserPointer<const void> bytes,
+                                    uint32_t num_bytes,
+                                    std::vector<HandleTransport>* transports,
+                                    MojoWriteMessageFlags flags) {
   DCHECK(!transports ||
          (transports->size() > 0 &&
           transports->size() < GetConfiguration().max_message_num_handles));
 
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return WriteMessageImplNoLock(bytes, num_bytes, transports, flags);
 }
@@ skipping 191 matching lines @@
 void Dispatcher::CloseImplNoLock() {
   mutex_.AssertHeld();
   DCHECK(is_closed_);
   // This may not need to do anything. Dispatchers should override this to do
   // any actual close-time cleanup necessary.
 }
 
 MojoResult Dispatcher::WriteMessageImplNoLock(
     UserPointer<const void> /*bytes*/,
     uint32_t /*num_bytes*/,
-    std::vector<DispatcherTransport>* /*transports*/,
+    std::vector<HandleTransport>* /*transports*/,
     MojoWriteMessageFlags /*flags*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
   // By default, not supported. Only needed for message pipe dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::ReadMessageImplNoLock(
     UserPointer<void> /*bytes*/,
     UserPointer<uint32_t> /*num_bytes*/,
@@ skipping 229 matching lines @@
   // want to remove or weaken).
   MutexLocker locker(&mutex_);
 #endif
 
   return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
                                         platform_handles);
 }
 
 }  // namespace system
 }  // namespace mojo