Add thunks for MojoGetRights(), etc.

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>
 
 #include "mojo/edk/platform/thread_utils.h"
 #include "mojo/edk/system/awakable.h"
 #include "mojo/edk/system/core_test_base.h"
 #include "mojo/edk/system/test/timeouts.h"
 #include "mojo/public/cpp/system/macros.h"
 
 using mojo::platform::ThreadSleep;
 
 namespace mojo {
 namespace system {
 namespace {
 
+const MojoHandleRights kDefaultMessagePipeHandleRights =
+    MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
+    MOJO_HANDLE_RIGHT_WRITE | MOJO_HANDLE_RIGHT_GET_OPTIONS |
+    MOJO_HANDLE_RIGHT_SET_OPTIONS;
+const MojoHandleRights kDefaultDataPipeProducerHandleRights =
+    MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_WRITE |
+    MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS;
+const MojoHandleRights kDefaultDataPipeConsumerHandleRights =
+    MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
+    MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS;
+
 const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u};
 const MojoHandleSignalsState kFullMojoHandleSignalsState = {~0u, ~0u};
 
 using CoreTest = test::CoreTestBase;
 
 TEST_F(CoreTest, GetTimeTicksNow) {
   const MojoTimeTicks start = core()->GetTimeTicksNow();
   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
       << "GetTimeTicksNow should return nonzero value";
   ThreadSleep(test::DeadlineFromMilliseconds(15u));
   const MojoTimeTicks finish = core()->GetTimeTicksNow();
   // Allow for some fuzz in sleep.
   EXPECT_GE((finish - start), static_cast<MojoTimeTicks>(8000))
       << "Sleeping should result in increasing time ticks";
 }
 
 TEST_F(CoreTest, Basic) {
   MockHandleInfo info;
 
   EXPECT_EQ(0u, info.GetCtorCallCount());
   MojoHandle h = CreateMockHandle(&info);
   EXPECT_EQ(1u, info.GetCtorCallCount());
   EXPECT_NE(h, MOJO_HANDLE_INVALID);
 
-  MojoHandleRights rights = 0;
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h, MakeUserPointer(&rights)));
   EXPECT_EQ(kDefaultMockHandleRights, rights);
 
   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());
@@ skipping 145 matching lines @@
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
     EXPECT_EQ(1u, info.GetCloseCallCount());
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
     EXPECT_EQ(1u, info.GetCloseCallCount());
   }
 
   // |GetRights()|:
   {
-    MojoHandleRights rights = 0;
+    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);
   }
 
   // |Wait()|:
   {
@@ skipping 439 matching lines @@
 
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]),
                                       MakeUserPointer(&h[1])));
   // Should get two distinct, valid handles.
   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[0], h[1]);
 
   // Both should have the correct rights.
-  static const MojoHandleRights kMessagePipeHandleRights =
-      MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
-      MOJO_HANDLE_RIGHT_WRITE | MOJO_HANDLE_RIGHT_GET_OPTIONS |
-      MOJO_HANDLE_RIGHT_SET_OPTIONS;
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h[0], MakeUserPointer(&rights)));
-  EXPECT_EQ(kMessagePipeHandleRights, rights);
+  EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h[1], MakeUserPointer(&rights)));
-  EXPECT_EQ(kMessagePipeHandleRights, rights);
+  EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
 
   // 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,
@@ skipping 281 matching lines @@
   EXPECT_NE(h_received, h_passing[1]);
   EXPECT_NE(h_received, h_passed[0]);
 
   // Note: We rely on the Mojo system not re-using handle values very often.
   EXPECT_NE(h_received, h_passed[1]);
 
   // |h_passed[1]| should no longer be valid; check that trying to close it
   // fails. See above note.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1]));
 
+  // Check that |h_received| still has the expected rights.
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->GetRights(h_received, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
+
   // Write to |h_passed[0]|. Should receive on |h_received|.
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
                                  kHelloSize, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ skipping 26 matching lines @@
 
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
                                    MakeUserPointer(&ch)));
   // Should get two distinct, valid handles.
   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
   EXPECT_NE(ph, ch);
 
   // Both should have the correct rights.
-  static const MojoHandleRights kDataPipeProducerHandleRights =
-      MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_WRITE |
-      MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS;
-  static const MojoHandleRights kDataPipeConsumerHandleRights =
-      MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
-      MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS;
   MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(ph, MakeUserPointer(&rights)));
-  EXPECT_EQ(kDataPipeProducerHandleRights, rights);
+  EXPECT_EQ(kDefaultDataPipeProducerHandleRights, rights);
   rights = MOJO_HANDLE_RIGHT_NONE;
   EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(ch, MakeUserPointer(&rights)));
-  EXPECT_EQ(kDataPipeConsumerHandleRights, rights);
+  EXPECT_EQ(kDefaultDataPipeConsumerHandleRights, rights);
 
   // 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,
@@ skipping 405 matching lines @@
   EXPECT_NE(ch_received, h_passing[1]);
   EXPECT_NE(ch_received, ph);
 
   // Note: We rely on the Mojo system not re-using handle values very often.
   EXPECT_NE(ch_received, ch);
 
   // |ch| should no longer be valid; check that trying to close it fails. See
   // above note.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch));
 
+  // Check that |ch_received| still has the expected rights.
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->GetRights(ch_received, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDefaultDataPipeConsumerHandleRights, rights);
+
   // Write to |ph|. Should receive on |ch_received|.
   num_bytes = kWorldSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph, UserPointer<const void>(kWorld),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
@@ skipping 40 matching lines @@
   EXPECT_NE(ph_received, h_passing[1]);
   EXPECT_NE(ph_received, ch_received);
 
   // Again, rely on the Mojo system not re-using handle values very often.
   EXPECT_NE(ph_received, ph);
 
   // |ph| should no longer be valid; check that trying to close it fails. See
   // above note.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph));
 
+  // Check that |ph_received| still has the expected rights.
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->GetRights(ph_received, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDefaultDataPipeProducerHandleRights, rights);
+
   // Write to |ph_received|. Should receive on |ch_received|.
   num_bytes = kHelloSize;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteData(ph_received, UserPointer<const void>(kHello),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
@@ skipping 196 matching lines @@
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |CreateSharedBuffer()|, |DuplicateBufferHandle()|, and
 // |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo