EDK: Add Core::DuplicateHandleWithReducedRights().

mojo/edk/system/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.
 
 #include "mojo/edk/system/core.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 41 matching lines @@
 
   EXPECT_EQ(0u, info.GetCtorCallCount());
   MojoHandle h = CreateMockHandle(&info);
   EXPECT_EQ(1u, info.GetCtorCallCount());
   EXPECT_NE(h, MOJO_HANDLE_INVALID);
 
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h, MakeUserPointer(&rights)));
   EXPECT_EQ(kDefaultMockHandleRights, rights);
 
+  MojoHandle h_dup = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->DuplicateHandleWithReducedRights(
+                h, MOJO_HANDLE_RIGHT_DUPLICATE, MakeUserPointer(&h_dup)));
+  EXPECT_EQ(1u, info.GetDuplicateDispatcherCallCount());
+  EXPECT_NE(h_dup, MOJO_HANDLE_INVALID);
+  EXPECT_NE(h_dup, h);
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h_dup, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDefaultMockHandleRights & ~MOJO_HANDLE_RIGHT_DUPLICATE, rights);
+  MojoHandle h_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            core()->DuplicateHandleWithReducedRights(
+                h_dup, MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h_denied)));
+  EXPECT_EQ(1u, info.GetDuplicateDispatcherCallCount());
+  EXPECT_EQ(MOJO_HANDLE_INVALID, h_denied);
+
+  EXPECT_EQ(0u, info.GetDtorCallCount());
+  EXPECT_EQ(0u, info.GetCloseCallCount());
+  EXPECT_EQ(0u, info.GetCancelAllAwakablesCallCount());
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_dup));
+  EXPECT_EQ(1u, info.GetDtorCallCount());
+  EXPECT_EQ(1u, info.GetCloseCallCount());
+  EXPECT_EQ(1u, info.GetCancelAllAwakablesCallCount());
+
   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
   EXPECT_EQ(0u, info.GetReadMessageCallCount());
   uint32_t num_bytes = 0;
   EXPECT_EQ(
       MOJO_RESULT_OK,
@@ skipping 112 matching lines @@
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
                        MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
                        MakeUserPointer(&hss)));
   EXPECT_EQ(9u, info.GetAddAwakableCallCount());
   EXPECT_EQ(0u, result_index);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
-  EXPECT_EQ(0u, info.GetDtorCallCount());
-  EXPECT_EQ(0u, info.GetCloseCallCount());
-  EXPECT_EQ(0u, info.GetCancelAllAwakablesCallCount());
+  // |h| shares |info| with |h_dup|, which was closed above.
+  EXPECT_EQ(1u, info.GetDtorCallCount());
+  EXPECT_EQ(1u, info.GetCloseCallCount());
+  EXPECT_EQ(1u, info.GetCancelAllAwakablesCallCount());
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  EXPECT_EQ(1u, info.GetCancelAllAwakablesCallCount());
-  EXPECT_EQ(1u, info.GetCloseCallCount());
-  EXPECT_EQ(1u, info.GetDtorCallCount());
+  EXPECT_EQ(2u, info.GetDtorCallCount());
+  EXPECT_EQ(2u, info.GetCloseCallCount());
+  EXPECT_EQ(2u, info.GetCancelAllAwakablesCallCount());
 
   // No awakables should ever have ever been added.
   EXPECT_EQ(0u, info.GetRemoveAwakableCallCount());
 }
 
 TEST_F(CoreTest, InvalidArguments) {
   // |Close()|:
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
@@ skipping 12 matching lines @@
   {
     MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->GetRights(MOJO_HANDLE_INVALID, MakeUserPointer(&rights)));
     EXPECT_EQ(0u, rights);
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->GetRights(10, MakeUserPointer(&rights)));
     EXPECT_EQ(0u, rights);
   }
 
+  // |DuplicateHandleWithReducedRights()|:
+  {
+    MojoHandle h = MOJO_HANDLE_INVALID;
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->DuplicateHandleWithReducedRights(
+            MOJO_HANDLE_INVALID, MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h)));
+    EXPECT_EQ(MOJO_HANDLE_INVALID, h);
+    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+              core()->DuplicateHandleWithReducedRights(
+                  10, MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h)));
+    EXPECT_EQ(MOJO_HANDLE_INVALID, h);
+  }
+
   // |Wait()|:
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
                            MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
                            MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
 
     MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
@@ skipping 342 matching lines @@
   // |GetRights()|:
   {
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
     EXPECT_DEATH_IF_SUPPORTED(core()->GetRights(h, NullUserPointer()),
                               kMemoryCheckFailedRegex);
 
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   }
 
+  // |DuplicateHandleWithReducedRights()|:
+  {
+    MockHandleInfo info;
+    MojoHandle h = CreateMockHandle(&info);
+    EXPECT_DEATH_IF_SUPPORTED(core()->DuplicateHandleWithReducedRights(
+                                  h, MOJO_HANDLE_RIGHT_NONE, NullUserPointer()),
+                              kMemoryCheckFailedRegex);
+
+    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
+  }
+
   // |WaitMany()|:
   {
     MojoHandle handle = MOJO_HANDLE_INVALID;
     MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
     EXPECT_DEATH_IF_SUPPORTED(
         core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1,
                          MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
                          NullUserPointer()),
         kMemoryCheckFailedRegex);
     EXPECT_DEATH_IF_SUPPORTED(
@@ skipping 76 matching lines @@
   EXPECT_NE(h[0], h[1]);
 
   // Both should have the correct rights.
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h[0], MakeUserPointer(&rights)));
   EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h[1], MakeUserPointer(&rights)));
   EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
 
+  // Neither should be duplicatable.
+  MojoHandle h_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            core()->DuplicateHandleWithReducedRights(
+                h[0], MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h_denied)));
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            core()->DuplicateHandleWithReducedRights(
+                h[1], MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h_denied)));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, h_denied);
+
   // Neither should be readable.
   MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE,
                                   MOJO_HANDLE_SIGNAL_READABLE};
   result_index = static_cast<uint32_t>(-1);
   hss[0] = kEmptyMojoHandleSignalsState;
   hss[1] = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0,
                        MakeUserPointer(&result_index), MakeUserPointer(hss)));
@@ skipping 339 matching lines @@
   EXPECT_NE(ph, ch);
 
   // Both should have the correct rights.
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(ph, MakeUserPointer(&rights)));
   EXPECT_EQ(kDefaultDataPipeProducerHandleRights, rights);
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(ch, MakeUserPointer(&rights)));
   EXPECT_EQ(kDefaultDataPipeConsumerHandleRights, rights);
 
+  // Neither should be duplicatable.
+  MojoHandle h_denied = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            core()->DuplicateHandleWithReducedRights(
+                ph, MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h_denied)));
+  EXPECT_EQ(MOJO_RESULT_PERMISSION_DENIED,
+            core()->DuplicateHandleWithReducedRights(
+                ch, MOJO_HANDLE_RIGHT_NONE, MakeUserPointer(&h_denied)));
+  EXPECT_EQ(MOJO_HANDLE_INVALID, h_denied);
+
   // Producer should be never-readable, but already writable.
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
@@ skipping 692 matching lines @@
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |CreateSharedBuffer()|, |DuplicateBufferHandle()|, and
 // |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo