mac: Remove POSIX shared memory.

mojo/edk/embedder/embedder_unittest.cc

 // Copyright 2014 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/embedder/embedder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 284 matching lines @@
 #define MAYBE_MultiprocessBaseSharedMemory DISABLED_MultiprocessBaseSharedMemory
 #else
 #define MAYBE_MultiprocessBaseSharedMemory MultiprocessBaseSharedMemory
 #endif  // defined(OS_ANDROID)
 TEST_F(EmbedderTest, MAYBE_MultiprocessBaseSharedMemory) {
   RUN_CHILD_ON_PIPE(MultiprocessSharedMemoryClient, server_mp)
     // 1. Create a base::SharedMemory object and create a mojo shared buffer
     // from it.
     base::SharedMemoryCreateOptions options;
     options.size = 123;
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-    options.type = base::SharedMemoryHandle::POSIX;
-#endif
     base::SharedMemory shared_memory;
     ASSERT_TRUE(shared_memory.Create(options));
     base::SharedMemoryHandle shm_handle = base::SharedMemory::DuplicateHandle(
         shared_memory.handle());
     MojoHandle sb1;
     ASSERT_EQ(MOJO_RESULT_OK,
               CreateSharedBufferWrapper(shm_handle, 123, false, &sb1));
 
     // 2. Map |sb1| and write something into it.
     char* buffer = nullptr;
@@ skipping 53 matching lines @@
   ASSERT_TRUE(shared_memory.Map(123));
   EXPECT_NE(buffer, shared_memory.memory());
   EXPECT_EQ(kByeWorld, std::string(static_cast<char*>(shared_memory.memory())));
 
   // 6. Close |sb1|. Should fail because |PassSharedMemoryHandle()| should have
   // closed the handle.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(sb1));
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 TEST_F(EmbedderTest, MultiprocessMachSharedMemory) {

[Anand Mistry (off Chromium), 2016/04/09 00:44:59]

Delete this test. It only exists because OSX had two options for shm and this
test tested the Mach one. Since OSX always uses Mach now, this test is identical
to the once above.

[erikchen, 2016/04/09 01:19:53]

Done.

   RUN_CHILD_ON_PIPE(MultiprocessSharedMemoryClient, server_mp)
     // 1. Create a Mach base::SharedMemory object and create a mojo shared
     // buffer from it.
     base::SharedMemoryCreateOptions options;
     options.size = 123;
-    options.type = base::SharedMemoryHandle::MACH;
     base::SharedMemory shared_memory;
     ASSERT_TRUE(shared_memory.Create(options));
     base::SharedMemoryHandle shm_handle = base::SharedMemory::DuplicateHandle(
         shared_memory.handle());
     MojoHandle sb1;
     ASSERT_EQ(MOJO_RESULT_OK,
               CreateSharedBufferWrapper(shm_handle, 123, false, &sb1));
 
     // 2. Map |sb1| and write something into it.
     char* buffer = nullptr;
@@ skipping 17 matching lines @@
     // 6. Map the original base::SharedMemory and expect it contains the
     // expected value.
     ASSERT_TRUE(shared_memory.Map(123));
     EXPECT_EQ(kByeWorld,
               std::string(static_cast<char*>(shared_memory.memory())));
 
     ASSERT_EQ(MOJO_RESULT_OK, MojoClose(sb1));
   END_CHILD()
 }
 
-const base::SharedMemoryHandle::Type kTestHandleTypes[] = {
-  base::SharedMemoryHandle::MACH,
-  base::SharedMemoryHandle::POSIX,
-  base::SharedMemoryHandle::POSIX,
-  base::SharedMemoryHandle::MACH,
-};
-
-// Test that we can mix file descriptor and mach port handles.
-TEST_F(EmbedderTest, MultiprocessMixMachAndFds) {
-  const size_t kShmSize = 1234;
-  RUN_CHILD_ON_PIPE(MultiprocessMixMachAndFdsClient, server_mp)
-    // 1. Create the base::SharedMemory objects and mojo handles from them.
-    MojoHandle platform_handles[arraysize(kTestHandleTypes)];
-    for (size_t i = 0; i < arraysize(kTestHandleTypes); i++) {
-      const auto type = kTestHandleTypes[i];
-      base::SharedMemoryCreateOptions options;
-      options.size = kShmSize;
-      options.type = type;
-      base::SharedMemory shared_memory;
-      ASSERT_TRUE(shared_memory.Create(options));
-      base::SharedMemoryHandle shm_handle = base::SharedMemory::DuplicateHandle(
-          shared_memory.handle());
-      ScopedPlatformHandle scoped_handle;
-      if (type == base::SharedMemoryHandle::POSIX)
-        scoped_handle.reset(PlatformHandle(shm_handle.GetFileDescriptor().fd));
-      else
-        scoped_handle.reset(PlatformHandle(shm_handle.GetMemoryObject()));
-      ASSERT_EQ(MOJO_RESULT_OK, CreatePlatformHandleWrapper(
-          std::move(scoped_handle), platform_handles + i));
-
-      // Map the shared memory object and write the type into it. 'P' for POSIX,
-      // and 'M' for Mach.
-      ASSERT_TRUE(shared_memory.Map(kShmSize));
-      static_cast<char*>(shared_memory.memory())[0] =
-          type == base::SharedMemoryHandle::POSIX ? 'P' : 'M';
-    }
-
-    // 2. Send all the handles to the child.
-    WriteMessageWithHandles(server_mp, "hello", platform_handles,
-                            arraysize(kTestHandleTypes));
-
-    // 3. Read a message from |server_mp|.
-    EXPECT_EQ("bye", ReadMessage(server_mp));
-  END_CHILD()
-}
-
-DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessMixMachAndFdsClient, EmbedderTest,
-                                  client_mp) {
-  const int kNumHandles = 4;
-  const size_t kShmSize = 1234;
-  MojoHandle platform_handles[kNumHandles];
-
-  // 1. Read from |client_mp|, which should have a message containing
-  // |kNumHandles| handles.
-  EXPECT_EQ("hello",
-            ReadMessageWithHandles(client_mp, platform_handles, kNumHandles));
-
-  // 2. Extract each handle, map it, and verify the type.
-  for (int i = 0; i < kNumHandles; i++) {
-    ScopedPlatformHandle scoped_handle;
-    ASSERT_EQ(MOJO_RESULT_OK,
-              PassWrappedPlatformHandle(platform_handles[i], &scoped_handle));
-    base::SharedMemoryHandle shm_handle;
-    char type = 0;
-    if (scoped_handle.get().type == PlatformHandle::Type::POSIX) {
-      shm_handle = base::SharedMemoryHandle(scoped_handle.release().handle,
-                                            false);
-      type = 'P';
-    } else {
-      shm_handle = base::SharedMemoryHandle(scoped_handle.release().port,
-                                            kShmSize, base::GetCurrentProcId());
-      type = 'M';
-    }
-
-    // Verify the type order.
-    EXPECT_EQ(kTestHandleTypes[i], shm_handle.GetType());
-
-    base::SharedMemory shared_memory(shm_handle, false);
-    ASSERT_TRUE(shared_memory.Map(kShmSize));
-    EXPECT_EQ(type, static_cast<char*>(shared_memory.memory())[0]);
-  }
-
-  // 3. Say bye!
-  WriteMessage(client_mp, "bye");
-}
-
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 #endif  // !defined(OS_IOS)
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo