Add thunks for MojoDuplicateHandle[WithReducedRights]().

mojo/public/c/system/tests/core_unittest.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.
 
 // This file tests the C API.
 
 #include <string.h>
 
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
@@ skipping 45 matching lines @@
   const void* read_pointer;
 
   // Close:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(MOJO_HANDLE_INVALID));
 
   // GetRights:
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoGetRights(MOJO_HANDLE_INVALID, &rights));
 
+  // DuplicateHandleWithReducedRights:
+  MojoHandle new_handle = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoDuplicateHandleWithReducedRights(
+                MOJO_HANDLE_INVALID, MOJO_HANDLE_RIGHT_DUPLICATE, &new_handle));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, new_handle);
+
+  // DuplicateHandle:
+  new_handle = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoDuplicateHandle(MOJO_HANDLE_INVALID, &new_handle));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, new_handle);
+
   // Wait:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoWait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, 1000000u,
                      nullptr));
 
   const MojoHandle h = MOJO_HANDLE_INVALID;
   sig = ~MOJO_HANDLE_SIGNAL_NONE;
   EXPECT_EQ(
       MOJO_RESULT_INVALID_ARGUMENT,
       MojoWaitMany(&h, &sig, 1u, MOJO_DEADLINE_INDEFINITE, nullptr, nullptr));
@@ skipping 77 matching lines @@
   EXPECT_NE(h0, h1);
 
   // Both handles should have the correct rights.
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h0, &rights));
   EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h1, &rights));
   EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
 
+  // Shouldn't be able to duplicate either handle (just test "with reduced
+  // rights" on one, and without on the other).
+  MojoHandle handle_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            MojoDuplicateHandleWithReducedRights(
+                h0, MOJO_HANDLE_RIGHT_DUPLICATE, &handle_denied));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, handle_denied);
+  handle_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            MojoDuplicateHandle(h1, &handle_denied));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, handle_denied);
+
   // Shouldn't be readable, we haven't written anything.
   MojoHandleSignalsState state;
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE |
                 MOJO_HANDLE_SIGNAL_PEER_CLOSED,
             state.satisfiable_signals);
 
   // Should be writable.
@@ skipping 85 matching lines @@
   EXPECT_NE(hp, hc);
 
   // Both handles should have the correct rights.
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(hp, &rights));
   EXPECT_EQ(kDefaultDataPipeProducerHandleRights, rights);
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(hc, &rights));
   EXPECT_EQ(kDefaultDataPipeConsumerHandleRights, rights);
 
+  // Shouldn't be able to duplicate either handle (just test "with reduced
+  // rights" on one, and without on the other).
+  MojoHandle handle_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            MojoDuplicateHandleWithReducedRights(
+                hp, MOJO_HANDLE_RIGHT_DUPLICATE, &handle_denied));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, handle_denied);
+  handle_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            MojoDuplicateHandle(hc, &handle_denied));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, handle_denied);
+
   // The consumer |hc| shouldn't be readable.
   MojoHandleSignalsState state;
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             state.satisfiable_signals);
 
   // The producer |hp| should be writable.
@@ skipping 329 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc));
 }
 
 // TODO(ncbray): enable this test once NaCl supports the corresponding APIs.
 #ifdef __native_client__
 #define MAYBE_BasicSharedBuffer DISABLED_BasicSharedBuffer
 #else
 #define MAYBE_BasicSharedBuffer BasicSharedBuffer
 #endif
 TEST(CoreTest, MAYBE_BasicSharedBuffer) {
-  MojoHandle h0, h1;
-  void* pointer;
 
   // Create a shared buffer (|h0|).
-  h0 = MOJO_HANDLE_INVALID;
+  MojoHandle h0 = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK, MojoCreateSharedBuffer(nullptr, 100, &h0));
   EXPECT_NE(h0, MOJO_HANDLE_INVALID);
 
   // The handle should have the correct rights.
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h0, &rights));
   EXPECT_EQ(kDefaultSharedBufferHandleRights, rights);
 
   // Check information about the buffer from |h0|.
   MojoBufferInformation info = {};
   static const uint32_t kInfoSize = static_cast<uint32_t>(sizeof(info));
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetBufferInformation(h0, &info, kInfoSize));
   EXPECT_EQ(kInfoSize, info.struct_size);
   EXPECT_EQ(MOJO_BUFFER_INFORMATION_FLAG_NONE, info.flags);
   EXPECT_EQ(100u, info.num_bytes);
 
   // Map everything.
-  pointer = nullptr;
+  void* pointer = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoMapBuffer(h0, 0, 100, &pointer, MOJO_MAP_BUFFER_FLAG_NONE));
   ASSERT_TRUE(pointer);
   static_cast<char*>(pointer)[50] = 'x';
 
   // Duplicate |h0| to |h1|.
-  h1 = MOJO_HANDLE_INVALID;
-  EXPECT_EQ(MOJO_RESULT_OK, MojoDuplicateBufferHandle(h0, nullptr, &h1));
+  MojoHandle h1 = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoDuplicateHandle(h0, &h1));
   EXPECT_NE(h1, MOJO_HANDLE_INVALID);
+  EXPECT_NE(h1, h0);
 
   // The new handle should have the correct rights.
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h1, &rights));
   EXPECT_EQ(kDefaultSharedBufferHandleRights, rights);
 
   // Check information about the buffer from |h1|.
   info = MojoBufferInformation();
   EXPECT_EQ(MOJO_RESULT_OK, MojoGetBufferInformation(h1, &info, kInfoSize));
   EXPECT_EQ(kInfoSize, info.struct_size);
@@ skipping 15 matching lines @@
             MojoMapBuffer(h1, 50, 50, &pointer, MOJO_MAP_BUFFER_FLAG_NONE));
   ASSERT_TRUE(pointer);
 
   // It should have what we wrote.
   EXPECT_EQ('x', static_cast<char*>(pointer)[0]);
   EXPECT_EQ('y', static_cast<char*>(pointer)[1]);
 
   // Unmap it.
   EXPECT_EQ(MOJO_RESULT_OK, MojoUnmapBuffer(pointer));
 
+  // Test duplication with reduced rights.
+  MojoHandle h2 = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoDuplicateHandleWithReducedRights(
+                                h1, MOJO_HANDLE_RIGHT_DUPLICATE, &h2));
+  EXPECT_NE(h2, MOJO_HANDLE_INVALID);
+  EXPECT_NE(h2, h1);
+  // |h2| should have the correct rights.
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoGetRights(h2, &rights));
+  EXPECT_EQ(kDefaultSharedBufferHandleRights & ~MOJO_HANDLE_RIGHT_DUPLICATE,
+            rights);
+  // Trying to duplicate |h2| should fail.
+  MojoHandle h3 = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED, MojoDuplicateHandle(h2, &h3));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, h3);
+
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2));
 }
 
 // This checks that things actually work in C (not C++).
 TEST(CoreTest, MinimalCTest) {
   const char* failure = MinimalCTest();
   EXPECT_FALSE(failure) << failure;
 }
 
 TEST(CoreTest, MinimalCppTest) {
   const char* failure = MinimalCppTest();
   EXPECT_FALSE(failure) << failure;
 }
 
 // TODO(vtl): Add multi-threaded tests.
 
 }  // namespace
 }  // namespace mojo