Support read-only duplicates of Mojo shared buffers.

mojo/edk/system/shared_buffer_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.
 
 #include <string.h>
 
 #include <string>
 #include <utility>
 
 #include "base/logging.h"
+#include "base/memory/shared_memory.h"
 #include "base/strings/string_piece.h"
 #include "mojo/edk/test/mojo_test_base.h"
 #include "mojo/public/c/system/types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace edk {
 namespace {
 
 using SharedBufferTest = test::MojoTestBase;
 
 TEST_F(SharedBufferTest, CreateSharedBuffer) {
   const std::string message = "hello";
   MojoHandle h = CreateBuffer(message.size());
   WriteToBuffer(h, 0, message);
   ExpectBufferContents(h, 0, message);
 }
 
 TEST_F(SharedBufferTest, DuplicateSharedBuffer) {
   const std::string message = "hello";
   MojoHandle h = CreateBuffer(message.size());
   WriteToBuffer(h, 0, message);
 
-  MojoHandle dupe = DuplicateBuffer(h);
+  MojoHandle dupe = DuplicateBuffer(h, false);
   ExpectBufferContents(dupe, 0, message);
 }
 
 TEST_F(SharedBufferTest, PassSharedBufferLocal) {
   const std::string message = "hello";
   MojoHandle h = CreateBuffer(message.size());
   WriteToBuffer(h, 0, message);
 
-  MojoHandle dupe = DuplicateBuffer(h);
+  MojoHandle dupe = DuplicateBuffer(h, false);
   MojoHandle p0, p1;
   CreateMessagePipe(&p0, &p1);
 
   WriteMessageWithHandles(p0, "...", &dupe, 1);
   EXPECT_EQ("...", ReadMessageWithHandles(p1, &dupe, 1));
 
   ExpectBufferContents(dupe, 0, message);
 }
 
 #if !defined(OS_IOS)
@@ skipping 12 matching lines @@
 // Android multi-process tests are not executing the new process. This is flaky.
 #define MAYBE_PassSharedBufferCrossProcess DISABLED_PassSharedBufferCrossProcess
 #else
 #define MAYBE_PassSharedBufferCrossProcess PassSharedBufferCrossProcess
 #endif
 TEST_F(SharedBufferTest, MAYBE_PassSharedBufferCrossProcess) {
   const std::string message = "hello";
   MojoHandle b = CreateBuffer(message.size());
 
   RUN_CHILD_ON_PIPE(CopyToBufferClient, h)
-    MojoHandle dupe = DuplicateBuffer(b);
+    MojoHandle dupe = DuplicateBuffer(b, false);
     WriteMessageWithHandles(h, message, &dupe, 1);
     WriteMessage(h, "quit");
   END_CHILD()
 
   ExpectBufferContents(b, 0, message);
 }
 
 // Creates a new buffer, maps it, writes a message contents to it, unmaps it,
 // and finally passes it back to the parent.
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(CreateBufferClient, SharedBufferTest, h) {
@@ skipping 26 matching lines @@
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(CreateAndPassBuffer, SharedBufferTest, h) {
   // Receive a pipe handle over the primordial pipe. This will be connected to
   // another child process.
   MojoHandle other_child;
   std::string message = ReadMessageWithHandles(h, &other_child, 1);
 
   // Create a new shared buffer.
   MojoHandle b = CreateBuffer(message.size());
 
   // Send a copy of the buffer to the parent and the other child.
-  MojoHandle dupe = DuplicateBuffer(b);
+  MojoHandle dupe = DuplicateBuffer(b, false);
   WriteMessageWithHandles(h, "", &b, 1);
   WriteMessageWithHandles(other_child, "", &dupe, 1);
 
   EXPECT_EQ("quit", ReadMessage(h));
   WriteMessage(h, "ok");
 }
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReceiveAndEditBuffer, SharedBufferTest, h) {
   // Receive a pipe handle over the primordial pipe. This will be connected to
   // another child process (running CreateAndPassBuffer).
@@ skipping 113 matching lines @@
       EXPECT_EQ("ok", ReadMessage(child2));
     END_CHILD()
     WriteMessage(child1, "quit");
     EXPECT_EQ("ok", ReadMessage(child1));
   END_CHILD()
 
   // The second grandchild should have written this message.
   ExpectBufferContents(b, 0, message);
 }
 
+DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadAndMapWriteSharedBuffer,
+                                  SharedBufferTest, h) {
+  // Receive the shared buffer.
+  MojoHandle b;
+  EXPECT_EQ("hello", ReadMessageWithHandles(h, &b, 1));
+
+  // Read from the bufer.
+  ExpectBufferContents(b, 0, "hello");
+
+  // Extract the shared memory handle and try to map it writable.
+  base::SharedMemoryHandle shm_handle;
+  bool read_only = false;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            PassSharedMemoryHandle(b, &shm_handle, nullptr, &read_only));
+  base::SharedMemory shared_memory(shm_handle, false);
+  EXPECT_TRUE(read_only);
+  EXPECT_FALSE(shared_memory.Map(1234));
+
+  EXPECT_EQ("quit", ReadMessage(h));
+  WriteMessage(h, "ok");
+}
+
+#if defined(OS_ANDROID)
+// Android multi-process tests are not executing the new process. This is flaky.
+#define MAYBE_CreateAndPassReadOnlyBuffer DISABLED_CreateAndPassReadOnlyBuffer
+#else
+#define MAYBE_CreateAndPassReadOnlyBuffer CreateAndPassReadOnlyBuffer
+#endif
+TEST_F(SharedBufferTest, MAYBE_CreateAndPassReadOnlyBuffer) {
+  RUN_CHILD_ON_PIPE(ReadAndMapWriteSharedBuffer, h)
+    // Create a new shared buffer.
+    MojoHandle b = CreateBuffer(1234);
+    WriteToBuffer(b, 0, "hello");
+
+    // Send a read-only copy of the buffer to the child.
+    MojoHandle dupe = DuplicateBuffer(b, true /* read_only */);
+    WriteMessageWithHandles(h, "hello", &dupe, 1);
+
+    WriteMessage(h, "quit");
+    EXPECT_EQ("ok", ReadMessage(h));
+  END_CHILD()
+}
+
+DEFINE_TEST_CLIENT_TEST_WITH_PIPE(CreateAndPassReadOnlyBuffer,
+                                  SharedBufferTest, h) {
+  // Create a new shared buffer.
+  MojoHandle b = CreateBuffer(1234);
+  WriteToBuffer(b, 0, "hello");
+
+  // Send a read-only copy of the buffer to the parent.
+  MojoHandle dupe = DuplicateBuffer(b, true /* read_only */);
+  WriteMessageWithHandles(h, "", &dupe, 1);
+
+  EXPECT_EQ("quit", ReadMessage(h));
+  WriteMessage(h, "ok");
+}
+
+#if defined(OS_ANDROID) || (defined(OS_POSIX) && !defined(OS_MACOSX))
+// Android multi-process tests are not executing the new process. This is flaky.
+// Non-OSX posix uses a sync broker to create shared memory. Creating read-only
+// duplicates in child processes is not currently supported via the sync broker.
+#define MAYBE_CreateAndPassFromChildReadOnlyBuffer \
+    DISABLED_CreateAndPassFromChildReadOnlyBuffer
+#else
+#define MAYBE_CreateAndPassFromChildReadOnlyBuffer \
+    CreateAndPassFromChildReadOnlyBuffer
+#endif
+TEST_F(SharedBufferTest, MAYBE_CreateAndPassFromChildReadOnlyBuffer) {
+  RUN_CHILD_ON_PIPE(CreateAndPassReadOnlyBuffer, h)
+    MojoHandle b;
+    EXPECT_EQ("", ReadMessageWithHandles(h, &b, 1));
+    ExpectBufferContents(b, 0, "hello");
+
+    // Extract the shared memory handle and try to map it writable.
+    base::SharedMemoryHandle shm_handle;
+    bool read_only = false;
+    ASSERT_EQ(MOJO_RESULT_OK,
+              PassSharedMemoryHandle(b, &shm_handle, nullptr, &read_only));
+    base::SharedMemory shared_memory(shm_handle, false);
+    EXPECT_TRUE(read_only);
+    EXPECT_FALSE(shared_memory.Map(1234));
+
+    WriteMessage(h, "quit");
+    EXPECT_EQ("ok", ReadMessage(h));
+  END_CHILD()
+}
+
 #endif  // !defined(OS_IOS)
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo