EDK: Rename DispatcherTransport to HandleTransport.

mojo/edk/system/message_pipe.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/message_pipe.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 131 matching lines @@
 
   endpoints_[port]->Close();
   if (endpoints_[peer_port]) {
     if (!endpoints_[peer_port]->OnPeerClose())
       endpoints_[peer_port].reset();
   }
   endpoints_[port].reset();
 }
 
 // TODO(vtl): Handle flags.
-MojoResult MessagePipe::WriteMessage(
-    unsigned port,
-    UserPointer<const void> bytes,
-    uint32_t num_bytes,
-    std::vector<DispatcherTransport>* transports,
-    MojoWriteMessageFlags flags) {
+MojoResult MessagePipe::WriteMessage(unsigned port,
+                                     UserPointer<const void> bytes,
+                                     uint32_t num_bytes,
+                                     std::vector<HandleTransport>* transports,
+                                     MojoWriteMessageFlags flags) {
   DCHECK(port == 0 || port == 1);
 
   MutexLocker locker(&mutex_);
   return EnqueueMessageNoLock(
       GetPeerPort(port),
       MakeUnique<MessageInTransit>(
           MessageInTransit::Type::ENDPOINT_CLIENT,
           MessageInTransit::Subtype::ENDPOINT_CLIENT_DATA, num_bytes, bytes),
       transports);
 }
@@ skipping 156 matching lines @@
   // Owned by the dispatchers. The owning dispatchers should only release us via
   // their |Close()| method, which should inform us of being closed via our
   // |Close()|. Thus these should already be null.
   DCHECK(!endpoints_[0]);
   DCHECK(!endpoints_[1]);
 }
 
 MojoResult MessagePipe::EnqueueMessageNoLock(
     unsigned port,
     std::unique_ptr<MessageInTransit> message,
-    std::vector<DispatcherTransport>* transports) {
+    std::vector<HandleTransport>* transports) {
   DCHECK(port == 0 || port == 1);
   DCHECK(message);
 
   DCHECK_EQ(message->type(), MessageInTransit::Type::ENDPOINT_CLIENT);
   DCHECK(endpoints_[GetPeerPort(port)]);
 
   // The destination port need not be open, unlike the source port.
   if (!endpoints_[port])
     return MOJO_RESULT_FAILED_PRECONDITION;
 
   if (transports) {
     MojoResult result = AttachTransportsNoLock(port, message.get(), transports);
     if (result != MOJO_RESULT_OK)
       return result;
   }
 
   // The endpoint's |EnqueueMessage()| may not report failure.
   endpoints_[port]->EnqueueMessage(std::move(message));
   return MOJO_RESULT_OK;
 }
 
 MojoResult MessagePipe::AttachTransportsNoLock(
     unsigned port,
     MessageInTransit* message,
-    std::vector<DispatcherTransport>* transports) {
+    std::vector<HandleTransport>* transports) {
   DCHECK(!message->has_dispatchers());
 
   // Clone the dispatchers and attach them to the message. (This must be done as
   // a separate loop, since we want to leave the dispatchers alone on failure.)
   std::unique_ptr<DispatcherVector> dispatchers(new DispatcherVector());
   dispatchers->reserve(transports->size());
   for (size_t i = 0; i < transports->size(); i++) {
     if ((*transports)[i].is_valid()) {
       dispatchers->push_back(
           (*transports)[i].CreateEquivalentDispatcherAndClose(this, port));
     } else {
       LOG(WARNING) << "Enqueueing null dispatcher";
       dispatchers->push_back(nullptr);
     }
   }
   message->SetDispatchers(std::move(dispatchers));
   return MOJO_RESULT_OK;
 }
 
 }  // namespace system
 }  // namespace mojo