EDK: Add Core::DuplicateHandleWithReducedRights().

mojo/edk/system/core.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/core.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 168 matching lines @@
                            UserPointer<MojoHandleRights> rights) {
   Handle h;
   MojoResult result = GetHandle(handle, &h);
   if (result != MOJO_RESULT_OK)
     return result;
 
   rights.Put(h.rights);
   return MOJO_RESULT_OK;
 }
 
+MojoResult Core::DuplicateHandleWithReducedRights(
+    MojoHandle handle,
+    MojoHandleRights rights_to_remove,
+    UserPointer<MojoHandle> new_handle) {
+  Handle h;
+  MojoResult result = GetHandle(handle, &h);
+  if (result != MOJO_RESULT_OK)
+    return result;
+
+  if (!h.has_all_rights(MOJO_HANDLE_RIGHT_DUPLICATE))
+    return MOJO_RESULT_PERMISSION_DENIED;
+
+  RefPtr<Dispatcher> new_dispatcher;
+  result = h.dispatcher->DuplicateDispatcher(&new_dispatcher);
+  if (result != MOJO_RESULT_OK)
+    return result;
+
+  MojoHandle new_handle_value =
+      AddHandle(Handle(new_dispatcher.Clone(), h.rights & ~rights_to_remove));
+  if (new_handle_value == MOJO_HANDLE_INVALID) {
+    LOG(ERROR) << "Handle table full";
+    new_dispatcher->Close();
+    return MOJO_RESULT_RESOURCE_EXHAUSTED;
+  }
+
+  new_handle.Put(new_handle_value);
+  return MOJO_RESULT_OK;
+}
+
 MojoResult Core::Wait(MojoHandle handle,
                       MojoHandleSignals signals,
                       MojoDeadline deadline,
                       UserPointer<MojoHandleSignalsState> signals_state) {
   uint32_t unused = static_cast<uint32_t>(-1);
   HandleSignalsState hss;
   MojoResult result = WaitManyInternal(&handle, &signals, 1, deadline, &unused,
                                        signals_state.IsNull() ? nullptr : &hss);
   if (result != MOJO_RESULT_INVALID_ARGUMENT && !signals_state.IsNull())
     signals_state.Put(hss);
@@ skipping 392 matching lines @@
   if (result != MOJO_RESULT_OK)
     return result;
 
   auto dispatcher = SharedBufferDispatcher::Create(
       platform_support_, validated_options, num_bytes, &result);
   if (result != MOJO_RESULT_OK) {
     DCHECK(!dispatcher);
     return result;
   }
 
-  MojoHandle h = AddHandle(
+  MojoHandle handle = AddHandle(
       Handle(dispatcher.Clone(), SharedBufferDispatcher::kDefaultHandleRights));
-  if (h == MOJO_HANDLE_INVALID) {
+  if (handle == MOJO_HANDLE_INVALID) {
     LOG(ERROR) << "Handle table full";
     dispatcher->Close();
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   }
 
-  shared_buffer_handle.Put(h);
+  shared_buffer_handle.Put(handle);
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::DuplicateBufferHandle(
     MojoHandle buffer_handle,
     UserPointer<const MojoDuplicateBufferHandleOptions> options,
     UserPointer<MojoHandle> new_buffer_handle) {
   // TODO(vtl): This is a big ugly and duplicates some code, but the plan is to
   // remove this method anyway.
   Handle h;
   MojoResult result = GetHandle(buffer_handle, &h);
   if (result != MOJO_RESULT_OK)
     return result;
 
   if (!h.has_all_rights(MOJO_HANDLE_RIGHT_DUPLICATE)) {
     return h.dispatcher->SupportsEntrypointClass(EntrypointClass::BUFFER)
                ? MOJO_RESULT_PERMISSION_DENIED
                : MOJO_RESULT_INVALID_ARGUMENT;
   }
 
   // Don't verify |options| here; that's the dispatcher's job.
   RefPtr<Dispatcher> new_dispatcher;
   result = h.dispatcher->DuplicateBufferHandle(options, &new_dispatcher);
   if (result != MOJO_RESULT_OK)
     return result;
 
-  MojoHandle new_handle = AddHandle(Handle(new_dispatcher.Clone(), h.rights));
-  if (new_handle == MOJO_HANDLE_INVALID) {
+  MojoHandle new_handle_value =
+      AddHandle(Handle(new_dispatcher.Clone(), h.rights));
+  if (new_handle_value == MOJO_HANDLE_INVALID) {
     LOG(ERROR) << "Handle table full";
     new_dispatcher->Close();
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   }
 
-  new_buffer_handle.Put(new_handle);
+  new_buffer_handle.Put(new_handle_value);
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::GetBufferInformation(MojoHandle buffer_handle,
                                       UserPointer<MojoBufferInformation> info,
                                       uint32_t info_num_bytes) {
   RefPtr<Dispatcher> dispatcher;
   MojoResult result =
       GetDispatcherAndCheckRights(buffer_handle, MOJO_HANDLE_RIGHT_GET_OPTIONS,
                                   EntrypointClass::BUFFER, &dispatcher);
@@ skipping 107 matching lines @@
   if (signals_states) {
     for (; i < num_handles; i++)
       signals_states[i] = dispatchers[i]->GetHandleSignalsState();
   }
 
   return result;
 }
 
 }  // namespace system
 }  // namespace mojo