EDK: Add Core::DuplicateHandleWithReducedRights().

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"
@@ skipping 90 matching lines @@
 
 MojoResult Dispatcher::Close() {
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   CloseNoLock();
   return MOJO_RESULT_OK;
 }
 
+MojoResult Dispatcher::DuplicateDispatcher(
+    util::RefPtr<Dispatcher>* new_dispatcher) {
+  MutexLocker locker(&mutex_);
+  if (is_closed_)
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  return DuplicateDispatcherImplNoLock(new_dispatcher);
+}
+
 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_)
@@ skipping 190 matching lines @@
   // will do something nontrivial.
 }
 
 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::DuplicateDispatcherImplNoLock(
+    util::RefPtr<Dispatcher>* new_dispatcher) {
+  mutex_.AssertHeld();
+  DCHECK(!is_closed_);
+  // By default, this is not supported. However, this should only be reachable
+  // if a handle has the |MOJO_HANDLE_RIGHT_DUPLICATE| right, which it should
+  // only have if it is supported.
+  NOTREACHED();
+  return MOJO_RESULT_INTERNAL;
+}
+
 MojoResult Dispatcher::WriteMessageImplNoLock(
     UserPointer<const void> /*bytes*/,
     uint32_t /*num_bytes*/,
     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;
 }
@@ skipping 233 matching lines @@
   // want to remove or weaken).
   MutexLocker locker(&mutex_);
 #endif
 
   return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
                                         platform_handles);
 }
 
 }  // namespace system
 }  // namespace mojo