EDK: Add MojoHandleRights to DispatcherTransport.

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 22 matching lines @@
 class PlatformSharedBufferMapping;
 }
 
 namespace system {
 
 class Awakable;
 class Channel;
 class Core;
 class Dispatcher;
 class DispatcherTransport;
+struct Handle;
 class HandleTable;
 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 DispatcherTryStartTransport(Dispatcher* dispatcher);
+DispatcherTransport 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 130 matching lines @@
   //
   // 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.
   class HandleTableAccess {
    private:
     friend class Core;
     friend class HandleTable;
     // Tests also need this, to avoid needing |Core|.
-    friend DispatcherTransport test::DispatcherTryStartTransport(Dispatcher*);
+    friend DispatcherTransport 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(Dispatcher* dispatcher);
+    static DispatcherTransport 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|
   // (but with an owning, unique reference), and having
@@ skipping 225 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_