Add thunks for MojoGetRights(), etc.

mojo/public/platform/native/system_impl_private_unittest.cc

 // Copyright 2015 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, but using the explicit MojoSystemImpl parameter.
 
 #include <string.h>
 
 #include "mojo/public/platform/native/system_impl_private.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 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 MojoHandleRights kDefaultSharedBufferHandleRights =
+    MOJO_HANDLE_RIGHT_DUPLICATE | MOJO_HANDLE_RIGHT_TRANSFER |
+    MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS |
+    MOJO_HANDLE_RIGHT_MAP_READABLE | MOJO_HANDLE_RIGHT_MAP_WRITABLE |
+    MOJO_HANDLE_RIGHT_MAP_EXECUTABLE;
+
 TEST(SystemImplTest, GetTimeTicksNow) {
   MojoSystemImpl system = MojoSystemImplCreateImpl();
   const MojoTimeTicks start = MojoSystemImplGetTimeTicksNow(system);
   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
       << "MojoGetTimeTicksNow should return nonzero value";
 
   // SystemImpl is leaked...
 }
 
 TEST(SystemImplTest, BasicMessagePipe) {
   MojoSystemImpl sys0 = MojoSystemImplCreateImpl();
   MojoSystemImpl sys1 = MojoSystemImplCreateImpl();
   EXPECT_NE(sys0, sys1);
 
   MojoHandle h0, h1;
   MojoHandleSignals sig;
   char buffer[10] = {0};
   uint32_t buffer_size;
 
   h0 = MOJO_HANDLE_INVALID;
   h1 = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplCreateMessagePipe(sys0, nullptr, &h0, &h1));
   EXPECT_NE(h0, MOJO_HANDLE_INVALID);
   EXPECT_NE(h1, MOJO_HANDLE_INVALID);
+  EXPECT_NE(h0, h1);
+
+  // Both handles should have the correct rights.
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplGetRights(sys0, h0, &rights));
+  EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplGetRights(sys0, h1, &rights));
+  EXPECT_EQ(kDefaultMessagePipeHandleRights, rights);
 
   // Move the other end of the pipe to a different SystemImpl.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplTransferHandle(sys0, h1, sys1, &h1));
   EXPECT_NE(h1, MOJO_HANDLE_INVALID);
 
   // Shouldn't be readable, we haven't written anything.
   MojoHandleSignalsState state;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       MojoSystemImplWait(sys0, h0, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
@@ skipping 90 matching lines @@
   uint32_t buffer_size;
   void* write_pointer;
   const void* read_pointer;
 
   hp = MOJO_HANDLE_INVALID;
   hc = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplCreateDataPipe(sys0, nullptr, &hp, &hc));
   EXPECT_NE(hp, MOJO_HANDLE_INVALID);
   EXPECT_NE(hc, MOJO_HANDLE_INVALID);
+  EXPECT_NE(hp, hc);
+
+  // Both handles should have the correct rights.
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplGetRights(sys0, hp, &rights));
+  EXPECT_EQ(kDefaultDataPipeProducerHandleRights, rights);
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplGetRights(sys0, hc, &rights));
+  EXPECT_EQ(kDefaultDataPipeConsumerHandleRights, rights);
 
   // Move the other end of the pipe to a different SystemImpl.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplTransferHandle(sys0, hc, sys1, &hc));
   EXPECT_NE(hc, MOJO_HANDLE_INVALID);
 
   // The consumer |hc| shouldn't be readable.
   MojoHandleSignalsState state;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       MojoSystemImplWait(sys1, hc, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
@@ skipping 407 matching lines @@
 
   MojoHandle h0, h1;
   void* pointer;
 
   // Create a shared buffer (|h0|).
   h0 = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplCreateSharedBuffer(sys0, nullptr, kSize, &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, MojoSystemImplGetRights(sys0, h0, &rights));
+  EXPECT_EQ(kDefaultSharedBufferHandleRights, rights);
+
   // Check the buffer information.
   {
     MojoBufferInformation info = {};
     EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplGetBufferInformation(
                                   sys0, h0, &info, sizeof(info)));
     EXPECT_EQ(sizeof(info), info.struct_size);
     EXPECT_EQ(MOJO_BUFFER_INFORMATION_FLAG_NONE, info.flags);
     EXPECT_EQ(kSize, info.num_bytes);
   }
 
   // Map everything.
   pointer = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplMapBuffer(sys0, h0, 0u, kSize, &pointer,
                                     MOJO_MAP_BUFFER_FLAG_NONE));
   ASSERT_TRUE(pointer);
   static_cast<char*>(pointer)[kSize / 2] = 'x';
 
   // Duplicate |h0| to |h1|.
   h1 = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoSystemImplDuplicateBufferHandle(sys0, h0, nullptr, &h1));
   EXPECT_NE(h1, MOJO_HANDLE_INVALID);
 
+  // The new handle should have the correct rights.
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplGetRights(sys0, h1, &rights));
+  EXPECT_EQ(kDefaultSharedBufferHandleRights, rights);
+
   // Move the other end of the pipe to a different SystemImpl.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplTransferHandle(sys0, h1, sys1, &h1));
   EXPECT_NE(h1, MOJO_HANDLE_INVALID);
 
   // Close |h0|.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplClose(sys0, h0));
 
   // The mapping should still be good.
   static_cast<char*>(pointer)[kSize / 2 + 1] = 'y';
 
@@ skipping 24 matching lines @@
   // Unmap it.
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplUnmapBuffer(sys1, pointer));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoSystemImplClose(sys1, h1));
 
   // 2 SystemImpls are leaked...
 }
 
 }  // namespace
 }  // namespace mojo