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 285 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 98 matching lines @@
     // 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()
 }
 
 enum class HandleType {
-  POSIX,

[Anand Mistry (off Chromium), 2016/04/16 01:27:54]

Please restore this. I changed the test so it no longer uses posix for shared
memory, but we still need to test mixing fds (regular files) with mach ports.

[erikchen, 2016/04/18 17:14:39]

Done.

   MACH,
   MACH_NULL,
 };
 
 const HandleType kTestHandleTypes[] = {
   HandleType::MACH,
   HandleType::MACH_NULL,
-  HandleType::POSIX,
-  HandleType::POSIX,
   HandleType::MACH,
 };
 
 // Test that we can mix file descriptors and mach port handles.
 TEST_F(EmbedderTest, MultiprocessMixMachAndFds) {
   const size_t kShmSize = 1234;
   RUN_CHILD_ON_PIPE(MultiprocessMixMachAndFdsClient, server_mp)
     // 1. Create fds or Mach 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];
       ScopedPlatformHandle scoped_handle;
-      if (type == HandleType::POSIX) {
-        // The easiest source of fds is opening /dev/null.
-        base::File file(base::FilePath("/dev/null"),
-                        base::File::FLAG_OPEN | base::File::FLAG_WRITE);
-        ASSERT_TRUE(file.IsValid());
-        scoped_handle.reset(PlatformHandle(file.TakePlatformFile()));
-        EXPECT_EQ(PlatformHandle::Type::POSIX, scoped_handle.get().type);
-      } else if (type == HandleType::MACH_NULL) {
+      if (type == HandleType::MACH_NULL) {
         scoped_handle.reset(PlatformHandle(
             static_cast<mach_port_t>(MACH_PORT_NULL)));
         EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type);
       } else {
         base::SharedMemoryCreateOptions options;
         options.size = kShmSize;
         options.type = base::SharedMemoryHandle::MACH;
         base::SharedMemory shared_memory;
         ASSERT_TRUE(shared_memory.Create(options));
         base::SharedMemoryHandle shm_handle =
@@ skipping 23 matching lines @@
   // |kNumHandles| handles.
   EXPECT_EQ("hello",
             ReadMessageWithHandles(client_mp, platform_handles, kNumHandles));
 
   // 2. Extract each handle, and verify the type.
   for (int i = 0; i < kNumHandles; i++) {
     const auto type = kTestHandleTypes[i];
     ScopedPlatformHandle scoped_handle;
     ASSERT_EQ(MOJO_RESULT_OK,
               PassWrappedPlatformHandle(platform_handles[i], &scoped_handle));
-    if (type == HandleType::POSIX) {
-      EXPECT_NE(0, scoped_handle.get().handle);
-      EXPECT_EQ(PlatformHandle::Type::POSIX, scoped_handle.get().type);
-    } else if (type == HandleType::MACH_NULL) {
+    if (type == HandleType::MACH_NULL) {
       EXPECT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL),
                 scoped_handle.get().port);
       EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type);
     } else {
       EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL),
                 scoped_handle.get().port);
       EXPECT_EQ(PlatformHandle::Type::MACH, scoped_handle.get().type);
     }
   }
 
   // 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