EDK: Rename DispatcherTransport to HandleTransport.

mojo/edk/system/dispatcher.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_DISPATCHER_H_
 #define MOJO_EDK_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 21 matching lines @@
 namespace platform {
 class PlatformSharedBufferMapping;
 }
 
 namespace system {
 
 class Awakable;
 class Channel;
 class Core;
 class Dispatcher;
-class DispatcherTransport;
 struct Handle;
 class HandleTable;
+class HandleTransport;
 class LocalMessagePipeEndpoint;
 class MessagePipe;
 class ProxyMessagePipeEndpoint;
 class TransportData;
 
 using DispatcherVector = std::vector<util::RefPtr<Dispatcher>>;
 
 namespace test {
 
 // Test helper. We need to declare it here so we can friend it.
-DispatcherTransport HandleTryStartTransport(const Handle& handle);
+HandleTransport HandleTryStartTransport(const Handle& handle);
 
 }  // namespace test
 
 // A |Dispatcher| implements Mojo primitives that are "attached" to a particular
 // handle. This includes most (all?) primitives except for |MojoWait...()|. This
 // object is thread-safe, with its state being protected by a single mutex
 // |mutex_|, which is also made available to implementation subclasses (via the
 // |mutex()| method).
 class Dispatcher : public util::RefCountedThreadSafe<Dispatcher> {
  public:
@@ skipping 33 matching lines @@
   // possible. If this becomes an issue, we can rethink this.
   MojoResult Close();
 
   // |EntrypointClass::MESSAGE_PIPE|:
   // |transports| may be non-null if and only if there are handles to be
   // written; not that |this| must not be in |transports|. On success, all the
   // dispatchers in |transports| must have been moved to a closed state; on
   // failure, they should remain in their original state.
   MojoResult WriteMessage(UserPointer<const void> bytes,
                           uint32_t num_bytes,
-                          std::vector<DispatcherTransport>* transports,
+                          std::vector<HandleTransport>* transports,
                           MojoWriteMessageFlags flags);
   // |dispatchers| must be non-null but empty, if |num_dispatchers| is non-null
   // and nonzero. On success, it will be set to the dispatchers to be received
   // (and assigned handles) as part of the message.
   MojoResult ReadMessage(UserPointer<void> bytes,
                          UserPointer<uint32_t> num_bytes,
                          DispatcherVector* dispatchers,
                          uint32_t* num_dispatchers,
                          MojoReadMessageFlags flags);
 
@@ skipping 68 matching lines @@
   // multiple times for the same |awakable| on the same object, so long as
   // |AddAwakable()| was called at most once.) If |signals_state| is non-null,
   // |*signals_state| will be set to the current handle signals state.
   void RemoveAwakable(Awakable* awakable, HandleSignalsState* signals_state);
 
   // A dispatcher must be put into a special state in order to be sent across a
   // message pipe. Outside of tests, only |HandleTableAccess| is allowed to do
   // this, since there are requirements on the handle table (see below).
   //
   // In this special state, only a restricted set of operations is allowed.
-  // These are the ones available as |DispatcherTransport| methods. Other
-  // |Dispatcher| methods must not be called until |DispatcherTransport::End()|
-  // has been called.
+  // These are the ones available as |HandleTransport| methods. Other
+  // |Dispatcher| methods must not be called until |HandleTransport::End()| has
+  // been called.
   class HandleTableAccess {
    private:
     friend class Core;
     friend class HandleTable;
     // Tests also need this, to avoid needing |Core|.
-    friend DispatcherTransport test::HandleTryStartTransport(const Handle&);
+    friend HandleTransport test::HandleTryStartTransport(const Handle&);
 
     // This must be called under the handle table lock and only if the handle
     // table entry is not marked busy. The caller must maintain a reference to
-    // |dispatcher| until |DispatcherTransport::End()| is called.
-    static DispatcherTransport TryStartTransport(const Handle& handle);
+    // |dispatcher| until |HandleTransport::End()| is called.
+    static HandleTransport TryStartTransport(const Handle& handle);
   };
 
   // A |TransportData| may serialize dispatchers that are given to it (and which
   // were previously attached to the |MessageInTransit| that is creating it) to
   // a given |Channel| and then (probably in a different process) deserialize.
   // Note that the |MessageInTransit| "owns" (i.e., has the only ref to) these
   // dispatchers, so there are no locking issues. (There's no lock ordering
   // issue, and in fact no need to take dispatcher locks at all.)
-  // TODO(vtl): Consider making another wrapper similar to |DispatcherTransport|
+  // TODO(vtl): Consider making another wrapper similar to |HandleTransport|
   // (but with an owning, unique reference), and having
   // |CreateEquivalentDispatcherAndCloseImplNoLock()| return that wrapper (and
   // |MessageInTransit|, etc. only holding on to such wrappers).
   class TransportDataAccess {
    private:
     friend class TransportData;
 
     // Serialization API. These functions may only be called on such
     // dispatchers. (|channel| is the |Channel| to which the dispatcher is to be
     // serialized.) See the |Dispatcher| methods of the same names for more
@@ skipping 39 matching lines @@
   virtual util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock(
       MessagePipe* message_pipe,
       unsigned port) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_) = 0;
 
   // These are to be overridden by subclasses (if necessary). They are never
   // called after the dispatcher has been closed. See the descriptions of the
   // methods without the "ImplNoLock" for more information.
   virtual MojoResult WriteMessageImplNoLock(
       UserPointer<const void> bytes,
       uint32_t num_bytes,
-      std::vector<DispatcherTransport>* transports,
+      std::vector<HandleTransport>* transports,
       MojoWriteMessageFlags flags) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult ReadMessageImplNoLock(UserPointer<void> bytes,
                                            UserPointer<uint32_t> num_bytes,
                                            DispatcherVector* dispatchers,
                                            uint32_t* num_dispatchers,
                                            MojoReadMessageFlags flags)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult SetDataPipeProducerOptionsImplNoLock(
       UserPointer<const MojoDataPipeProducerOptions> options)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
@@ skipping 77 matching lines @@
 
   // This should be overridden to return true if/when there's an ongoing
   // operation (e.g., two-phase read/writes on data pipes) that should prevent a
   // handle from being sent over a message pipe (with status "busy").
   virtual bool IsBusyNoLock() const MOJO_SHARED_LOCKS_REQUIRED(mutex_);
 
   util::Mutex& mutex() const MOJO_LOCK_RETURNED(mutex_) { return mutex_; }
 
  private:
   FRIEND_REF_COUNTED_THREAD_SAFE(Dispatcher);
-  friend class DispatcherTransport;
+  friend class HandleTransport;
 
   // Closes the dispatcher. This must be done under lock, and unlike |Close()|,
   // the dispatcher must not be closed already. (This is the "equivalent" of
   // |CreateEquivalentDispatcherAndCloseNoLock()|, for situations where the
   // dispatcher must be disposed of instead of "transferred".)
   void CloseNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // Creates an equivalent dispatcher -- representing the same resource as this
   // dispatcher -- and close (i.e., disable) this dispatcher. I.e., this
   // dispatcher will look as though it was closed, but the resource it
   // represents will be assigned to the new dispatcher. This must be called
   // under the dispatcher's lock. If the resulting dispatcher will be put into a
   // message on a message pipe, then |message_pipe| will be set appropriately
   // (otherwise, it may be null) and |port| will be set to the destination port.
   util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseNoLock(
       MessagePipe* message_pipe,
       unsigned port) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // API to serialize dispatchers to a |Channel|, exposed to only
   // |TransportData| (via |TransportData|). They may only be called on a
   // dispatcher attached to a |MessageInTransit| (and in particular not in
   // |CoreImpl|'s handle table).
   //
   // TODO(vtl): The serialization API (and related implementation methods,
-  // including |DispatcherTransport|'s methods) is marked
-  // |MOJO_NOT_THREAD_SAFE|. This is because the threading requirements are
-  // somewhat complicated (e.g., |HandleTableAccess::TryStartTransport()| is
-  // really a try-lock function, amongst other things). We could/should do a
-  // more careful job annotating these methods.
-  // https://github.com/domokit/mojo/issues/322
+  // including |HandleTransport|'s methods) is marked |MOJO_NOT_THREAD_SAFE|.
+  // This is because the threading requirements are somewhat complicated (e.g.,
+  // |HandleTableAccess::TryStartTransport()| is really a try-lock function,
+  // amongst other things). We could/should do a more careful job annotating
+  // these methods. https://github.com/domokit/mojo/issues/322
   //
   // Starts the serialization. Returns (via the two "out" parameters) the
   // maximum amount of space that may be needed to serialize this dispatcher to
   // the given |Channel| (no more than
   // |TransportData::kMaxSerializedDispatcherSize|) and the maximum number of
   // |PlatformHandle|s that may need to be attached (no more than
   // |TransportData::kMaxSerializedDispatcherPlatformHandles|). If this
   // dispatcher cannot be serialized to the given |Channel|, |*max_size| and
   // |*max_platform_handles| should be set to zero. A call to this method will
   // ALWAYS be followed by a call to |EndSerializeAndClose()| (even if this
@@ skipping 28 matching lines @@
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 inline std::ostream& operator<<(std::ostream& out, Dispatcher::Type type) {
   return out << static_cast<int>(type);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DISPATCHER_H_