Give base::SharedMemory::CreateAnonymous an executable flag

base/shared_memory_unittest.cc

Index: base/shared_memory_unittest.cc
diff --git a/base/shared_memory_unittest.cc b/base/shared_memory_unittest.cc
index 9f69a5d7a942b4951d6ec76591913bfb2b15b149..def4a607b112d81bc17fa5e2b253efa0cfbb95e5 100644
--- a/base/shared_memory_unittest.cc
+++ b/base/shared_memory_unittest.cc
@@ -15,6 +15,10 @@
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
+#if defined(OS_POSIX)
+#include <sys/mman.h>
+#endif
+
 static const int kNumThreads = 5;
 static const int kNumTasks = 5;
 
@@ -42,7 +46,7 @@ class MultipleThreadMain : public PlatformThread::Delegate {
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
-    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize);
+    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize, false);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
@@ -91,7 +95,7 @@ class MultipleLockThread : public PlatformThread::Delegate {
     {
       SharedMemory memory1;
       EXPECT_TRUE(memory1.CreateNamed("SharedMemoryMultipleLockThreadTest",
-                                 true, kDataSize));
+                                      true, kDataSize, false));
       EXPECT_TRUE(memory1.ShareToProcess(GetCurrentProcess(), &handle));
       // TODO(paulg): Implement this once we have a posix version of
       // SharedMemory::ShareToProcess.
@@ -136,7 +140,7 @@ TEST(SharedMemoryTest, OpenClose) {
   EXPECT_TRUE(rv);
   rv = memory1.Open(test_name, false);
   EXPECT_FALSE(rv);
-  rv = memory1.CreateNamed(test_name, false, kDataSize);
+  rv = memory1.CreateNamed(test_name, false, kDataSize, false);
   EXPECT_TRUE(rv);
   rv = memory1.Map(kDataSize);
   EXPECT_TRUE(rv);
@@ -182,7 +186,7 @@ TEST(SharedMemoryTest, OpenExclusive) {
   // Open two handles to a memory segment and check that open_existing works
   // as expected.
   SharedMemory memory1;
-  bool rv = memory1.CreateNamed(test_name, false, kDataSize);
+  bool rv = memory1.CreateNamed(test_name, false, kDataSize, false);
   EXPECT_TRUE(rv);
 
   // Memory1 knows it's size because it created it.
@@ -195,11 +199,11 @@ TEST(SharedMemoryTest, OpenExclusive) {
 
   SharedMemory memory2;
   // Should not be able to create if openExisting is false.
-  rv = memory2.CreateNamed(test_name, false, kDataSize2);
+  rv = memory2.CreateNamed(test_name, false, kDataSize2, false);
   EXPECT_FALSE(rv);
 
   // Should be able to create with openExisting true.
-  rv = memory2.CreateNamed(test_name, true, kDataSize2);
+  rv = memory2.CreateNamed(test_name, true, kDataSize2, false);
   EXPECT_TRUE(rv);
 
   // Memory2 shouldn't know the size because we didn't create it.
@@ -332,6 +336,21 @@ TEST(SharedMemoryTest, AnonymousPrivate) {
   }
 }
 
+#if defined(OS_POSIX)
+// Create a shared memory object, mmap it, and mprotect it to PROT_EXEC.
+TEST(SharedMemoryTest, AnonymousExecutable) {
+  const uint32 kTestSize = 1 << 16;
+
+  SharedMemory shared_memory;
+
+  EXPECT_TRUE(shared_memory.CreateAnonymous(kTestSize, true));
+  EXPECT_TRUE(shared_memory.Map(shared_memory.created_size()));
+
+  EXPECT_EQ(0, mprotect(shared_memory.memory(), shared_memory.created_size(),
+                        PROT_READ | PROT_EXEC));
+}
+#endif
+
 // On POSIX it is especially important we test shmem across processes,
 // not just across threads.  But the test is enabled on all platforms.
 class SharedMemoryProcessTest : public MultiProcessTest {
@@ -349,7 +368,7 @@ class SharedMemoryProcessTest : public MultiProcessTest {
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
-    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize);
+    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize, false);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;