Remove named SharedMemory usage on Mac.

base/memory/shared_memory_unittest.cc

 // Copyright (c) 2012 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 "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/multiprocess_test.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
-#if defined(OS_MACOSX)
-#include "base/mac/scoped_nsautorelease_pool.h"
-#endif
-
 #if defined(OS_POSIX)
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
-static const int kNumThreads = 5;
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-static const int kNumTasks = 5;
-#endif
-
 namespace base {
 
 namespace {
 
+#if !defined(OS_MACOSX)
 // Each thread will open the shared memory.  Each thread will take a different 4
 // byte int pointer, and keep changing it, with some small pauses in between.
 // Verify that each thread's value in the shared memory is always correct.
 class MultipleThreadMain : public PlatformThread::Delegate {
  public:
   explicit MultipleThreadMain(int16 id) : id_(id) {}
   ~MultipleThreadMain() override {}
 
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   // PlatformThread::Delegate interface.
   void ThreadMain() override {
-#if defined(OS_MACOSX)
-    mac::ScopedNSAutoreleasePool pool;
-#endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
-    int *ptr = static_cast<int*>(memory.memory()) + id_;
+    int* ptr = static_cast<int*>(memory.memory()) + id_;
     EXPECT_EQ(0, *ptr);
 
     for (int idx = 0; idx < 100; idx++) {
       *ptr = idx;
-      PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
+      PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
       EXPECT_EQ(*ptr, idx);
     }
     // Reset back to 0 for the next test that uses the same name.
     *ptr = 0;
 
     memory.Close();
   }
 
  private:
   int16 id_;
 
   static const char* const s_test_name_;
 
   DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
 };
 
 const char* const MultipleThreadMain::s_test_name_ =
     "SharedMemoryOpenThreadTest";
+#endif  // !defined(OS_MACOSX)
 
 }  // namespace
 
-// Android doesn't support SharedMemory::Open/Delete/
+// Android/Mac doesn't support SharedMemory::Open/Delete/
 // CreateNamedDeprecated(openExisting=true)
-#if !defined(OS_ANDROID)
+#if !defined(OS_ANDROID) && !defined(OS_MACOSX)
 TEST(SharedMemoryTest, OpenClose) {
   const uint32 kDataSize = 1024;
   std::string test_name = "SharedMemoryOpenCloseTest";
 
   // Open two handles to a memory segment, confirm that they are mapped
   // separately yet point to the same space.
   SharedMemory memory1;
   bool rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Delete(test_name);
@@ skipping 14 matching lines @@
   // Make sure we don't segfault. (it actually happened!)
   ASSERT_NE(memory1.memory(), static_cast<void*>(NULL));
   ASSERT_NE(memory2.memory(), static_cast<void*>(NULL));
 
   // Write data to the first memory segment, verify contents of second.
   memset(memory1.memory(), '1', kDataSize);
   EXPECT_EQ(memcmp(memory1.memory(), memory2.memory(), kDataSize), 0);
 
   // Close the first memory segment, and verify the second has the right data.
   memory1.Close();
-  char *start_ptr = static_cast<char *>(memory2.memory());
-  char *end_ptr = start_ptr + kDataSize;
+  char* start_ptr = static_cast<char*>(memory2.memory());
+  char* end_ptr = start_ptr + kDataSize;
   for (char* ptr = start_ptr; ptr < end_ptr; ptr++)
     EXPECT_EQ(*ptr, '1');
 
   // Close the second memory segment.
   memory2.Close();
 
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory2.Delete(test_name);
   EXPECT_TRUE(rv);
@@ skipping 17 matching lines @@
   EXPECT_EQ(memory1.requested_size(), kDataSize);
 
   rv = memory1.Map(kDataSize);
   EXPECT_TRUE(rv);
 
   // The mapped memory1 must be at least the size we asked for.
   EXPECT_GE(memory1.mapped_size(), kDataSize);
 
   // The mapped memory1 shouldn't exceed rounding for allocation granularity.
   EXPECT_LT(memory1.mapped_size(),
-            kDataSize + base::SysInfo::VMAllocationGranularity());
+            kDataSize + SysInfo::VMAllocationGranularity());
 
   memset(memory1.memory(), 'G', kDataSize);
 
   SharedMemory memory2;
   // Should not be able to create if openExisting is false.
   rv = memory2.CreateNamedDeprecated(test_name, false, kDataSize2);
   EXPECT_FALSE(rv);
 
   // Should be able to create with openExisting true.
   rv = memory2.CreateNamedDeprecated(test_name, true, kDataSize2);
   EXPECT_TRUE(rv);
 
   // Memory2 shouldn't know the size because we didn't create it.
   EXPECT_EQ(memory2.requested_size(), 0U);
 
   // We should be able to map the original size.
   rv = memory2.Map(kDataSize);
   EXPECT_TRUE(rv);
 
   // The mapped memory2 must be at least the size of the original.
   EXPECT_GE(memory2.mapped_size(), kDataSize);
 
   // The mapped memory2 shouldn't exceed rounding for allocation granularity.
   EXPECT_LT(memory2.mapped_size(),
-            kDataSize2 + base::SysInfo::VMAllocationGranularity());
+            kDataSize2 + SysInfo::VMAllocationGranularity());
 
   // Verify that opening memory2 didn't truncate or delete memory 1.
-  char *start_ptr = static_cast<char *>(memory2.memory());
-  char *end_ptr = start_ptr + kDataSize;
+  char* start_ptr = static_cast<char*>(memory2.memory());
+  char* end_ptr = start_ptr + kDataSize;
   for (char* ptr = start_ptr; ptr < end_ptr; ptr++) {
     EXPECT_EQ(*ptr, 'G');
   }
 
   memory1.Close();
   memory2.Close();
 
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
 }
-#endif
+#endif  // !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 // Check that memory is still mapped after its closed.
 TEST(SharedMemoryTest, CloseNoUnmap) {
   const size_t kDataSize = 4096;
 
   SharedMemory memory;
   ASSERT_TRUE(memory.CreateAndMapAnonymous(kDataSize));
   char* ptr = static_cast<char*>(memory.memory());
   ASSERT_NE(ptr, static_cast<void*>(NULL));
   memset(ptr, 'G', kDataSize);
 
   memory.Close();
 
   EXPECT_EQ(ptr, memory.memory());
   EXPECT_EQ(SharedMemory::NULLHandle(), memory.handle());
 
   for (size_t i = 0; i < kDataSize; i++) {
     EXPECT_EQ('G', ptr[i]);
   }
 
   memory.Unmap();
   EXPECT_EQ(nullptr, memory.memory());
 }
 
+#if !defined(OS_MACOSX)
 // Create a set of N threads to each open a shared memory segment and write to
 // it. Verify that they are always reading/writing consistent data.
 TEST(SharedMemoryTest, MultipleThreads) {
+  const int kNumThreads = 5;
+
   MultipleThreadMain::CleanUp();
   // On POSIX we have a problem when 2 threads try to create the shmem
   // (a file) at exactly the same time, since create both creates the
   // file and zerofills it.  We solve the problem for this unit test
   // (make it not flaky) by starting with 1 thread, then
   // intentionally don't clean up its shmem before running with
   // kNumThreads.
 
   int threadcounts[] = { 1, kNumThreads };
   for (size_t i = 0; i < arraysize(threadcounts); i++) {
@@ skipping 13 matching lines @@
     }
 
     // Wait for the threads to finish.
     for (int index = 0; index < numthreads; index++) {
       PlatformThread::Join(thread_handles[index]);
       delete thread_delegates[index];
     }
   }
   MultipleThreadMain::CleanUp();
 }
+#endif
 
 // Allocate private (unique) shared memory with an empty string for a
 // name.  Make sure several of them don't point to the same thing as
 // we might expect if the names are equal.
 TEST(SharedMemoryTest, AnonymousPrivate) {
   int i, j;
   int count = 4;
   bool rv;
   const uint32 kDataSize = 8192;
 
   scoped_ptr<SharedMemory[]> memories(new SharedMemory[count]);
   scoped_ptr<int*[]> pointers(new int*[count]);
   ASSERT_TRUE(memories.get());
   ASSERT_TRUE(pointers.get());
 
   for (i = 0; i < count; i++) {
     rv = memories[i].CreateAndMapAnonymous(kDataSize);
     EXPECT_TRUE(rv);
-    int *ptr = static_cast<int*>(memories[i].memory());
+    int* ptr = static_cast<int*>(memories[i].memory());
     EXPECT_TRUE(ptr);
     pointers[i] = ptr;
   }
 
   for (i = 0; i < count; i++) {
     // zero out the first int in each except for i; for that one, make it 100.
     for (j = 0; j < count; j++) {
       if (i == j)
         pointers[j][0] = 100;
       else
@@ skipping 80 matching lines @@
   BOOL rv = ::DuplicateHandle(GetCurrentProcess(),
                               handle,
                               GetCurrentProcess(),
                               &temp_handle,
                               FILE_MAP_ALL_ACCESS,
                               false,
                               0);
   EXPECT_EQ(FALSE, rv)
       << "Shouldn't be able to duplicate the handle into a writable one.";
   if (rv)
-    base::win::ScopedHandle writable_handle(temp_handle);
+    win::ScopedHandle writable_handle(temp_handle);
   rv = ::DuplicateHandle(GetCurrentProcess(),
                          handle,
                          GetCurrentProcess(),
                          &temp_handle,
                          FILE_MAP_READ,
                          false,
                          0);
   EXPECT_EQ(TRUE, rv)
       << "Should be able to duplicate the handle into a readable one.";
   if (rv)
-    base::win::ScopedHandle writable_handle(temp_handle);
+    win::ScopedHandle writable_handle(temp_handle);
 #else
 #error Unexpected platform; write a test that tries to make 'handle' writable.
 #endif  // defined(OS_POSIX) || defined(OS_WIN)
 }
 
 TEST(SharedMemoryTest, ShareToSelf) {
   StringPiece contents = "Hello World";
 
   SharedMemory shmem;
   ASSERT_TRUE(shmem.CreateAndMapAnonymous(contents.size()));
@@ skipping 111 matching lines @@
   struct stat shm_stat;
   EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
   // Neither the group, nor others should be able to read the shared memory
   // file.
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
 }
 
 // Create a shared memory object, check its permissions.
 TEST(SharedMemoryTest, FilePermissionsNamed) {
-  const uint32 kTestSize = 1 << 8;
+  const uint32_t kTestSize = 1 << 8;
 
   SharedMemory shared_memory;
   SharedMemoryCreateOptions options;
   options.size = kTestSize;
-  std::string shared_mem_name = "shared_perm_test-" + IntToString(getpid()) +
-      "-" + Uint64ToString(RandUint64());
-  options.name_deprecated = &shared_mem_name;
+
   // Set a file mode creation mask that gives all permissions.
   ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
 
   EXPECT_TRUE(shared_memory.Create(options));
-  // Clean-up the backing file name immediately, we don't need it.
-  EXPECT_TRUE(shared_memory.Delete(shared_mem_name));
 
-  int shm_fd =
-      SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
+  int fd = SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
   struct stat shm_stat;
-  EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
+  EXPECT_EQ(0, fstat(fd, &shm_stat));
   // Neither the group, nor others should have been able to open the shared
   // memory file while its name existed.
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
   EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
 }
 #endif  // !defined(OS_ANDROID)
 
 #endif  // defined(OS_POSIX)
 
 // Map() will return addresses which are aligned to the platform page size, this
 // varies from platform to platform though.  Since we'd like to advertise a
 // minimum alignment that callers can count on, test for it here.
 TEST(SharedMemoryTest, MapMinimumAlignment) {
   static const int kDataSize = 8192;
 
   SharedMemory shared_memory;
   ASSERT_TRUE(shared_memory.CreateAndMapAnonymous(kDataSize));
   EXPECT_EQ(0U, reinterpret_cast<uintptr_t>(
       shared_memory.memory()) & (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
   shared_memory.Close();
 }
 
 // iOS does not allow multiple processes.
-// Android ashmem doesn't support named shared memory.
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-
+// Android ashmem does not support named shared memory.
+// Mac SharedMemory does not support named shared memory. crbug.com/345734
+#if !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 // 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 {
  public:
-
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   static int TaskTestMain() {
     int errors = 0;
-#if defined(OS_MACOSX)
-    mac::ScopedNSAutoreleasePool pool;
-#endif
     SharedMemory memory;
     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
     rv = memory.Map(s_data_size_);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
-    int *ptr = static_cast<int*>(memory.memory());
+    int* ptr = static_cast<int*>(memory.memory());
 
     // This runs concurrently in multiple processes. Writes need to be atomic.
-    base::subtle::Barrier_AtomicIncrement(ptr, 1);
+    subtle::Barrier_AtomicIncrement(ptr, 1);
     memory.Close();
     return errors;
   }
 
   static const char* const s_test_name_;
   static const uint32 s_data_size_;
 };
 
 const char* const SharedMemoryProcessTest::s_test_name_ = "MPMem";
 const uint32 SharedMemoryProcessTest::s_data_size_ = 1024;
 
 TEST_F(SharedMemoryProcessTest, SharedMemoryAcrossProcesses) {
+  const int kNumTasks = 5;
+
   SharedMemoryProcessTest::CleanUp();
 
   // Create a shared memory region. Set the first word to 0.
   SharedMemory memory;
   bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
   ASSERT_TRUE(rv);
   rv = memory.Map(s_data_size_);
   ASSERT_TRUE(rv);
   int* ptr = static_cast<int*>(memory.memory());
   *ptr = 0;
@@ skipping 16 matching lines @@
   // Check that the shared memory region reflects |kNumTasks| increments.
   ASSERT_EQ(kNumTasks, *ptr);
 
   memory.Close();
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
-
-#endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
+#endif  // !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 }  // namespace base