EDK: Add Core::DuplicateHandleWithReducedRights().

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 80 matching lines @@
   virtual bool SupportsEntrypointClass(
       EntrypointClass entrypoint_class) const = 0;
 
   // These methods implement the various primitives named |Mojo...()|. These
   // take |mutex_| and handle races with |Close()|. Then they call out to
   // subclasses' |...ImplNoLock()| methods (still under |mutex_|), which
   // actually implement the primitives.
   // NOTE(vtl): This puts a big lock around each dispatcher (i.e., handle), and
   // prevents the various |...ImplNoLock()|s from releasing the lock as soon as
   // possible. If this becomes an issue, we can rethink this.
+
+  // No |EntrypointClass|:
+  // All dispatchers must support this.
   MojoResult Close();
+  // This actually supports |MojoDuplicateHandle[WithReducedRights]()|; rights
+  // are handled by |Core|.
+  MojoResult DuplicateDispatcher(util::RefPtr<Dispatcher>* new_dispatcher);
 
   // |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<HandleTransport>* transports,
                           MojoWriteMessageFlags flags);
@@ skipping 143 matching lines @@
  protected:
   Dispatcher();
   virtual ~Dispatcher();
 
   // These are to be overridden by subclasses (if necessary). They are called
   // exactly once (first |CancelAllAwakablesNoLock()|, then |CloseImplNoLock()|)
   // when the dispatcher is being closed.
   virtual void CancelAllAwakablesNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual void CloseImplNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
+  //  All dispatcher types whose handles may ever have the
+  // |MOJO_HANDLE_RIGHT_DUPLICATE| right must override this.
+  virtual MojoResult DuplicateDispatcherImplNoLock(
+      util::RefPtr<Dispatcher>* new_dispatcher)
+      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
   // This is called by |CreateEquivalentDispatcherAndCloseNoLock()|. It should
   // "close" this dispatcher and return a new one equivalent to it. Note:
   // Probably the first thing an implementation should do is call
   // |CancelAllAwakablesNoLock()| (or equivalent); unlike |CloseNoLock()|,
   // |CreateEquivalentDispatcherAndCloseNoLock()| does not do this
   // automatically.
   virtual util::RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock(
       MessagePipe* message_pipe,
       unsigned port) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_) = 0;
 
@@ skipping 172 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_