Add POSIX shared memory support for Mac

base/memory/shared_memory.h

 // 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.
 
 #ifndef BASE_MEMORY_SHARED_MEMORY_H_
 #define BASE_MEMORY_SHARED_MEMORY_H_
 
 #include <stddef.h>
 
 #include <string>
@@ skipping 16 matching lines @@
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 namespace base {
 
 class FilePath;
 
 // Options for creating a shared memory object.
 struct BASE_EXPORT SharedMemoryCreateOptions {
-#if !(defined(OS_MACOSX) && !defined(OS_IOS))
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // The type of OS primitive that should back the SharedMemory object.
+  SharedMemoryHandle::Type type = SharedMemoryHandle::MACH;
+#else
   // DEPRECATED (crbug.com/345734):
   // If NULL, the object is anonymous.  This pointer is owned by the caller
   // and must live through the call to Create().
   const std::string* name_deprecated = nullptr;
 
   // DEPRECATED (crbug.com/345734):
   // If true, and the shared memory already exists, Create() will open the
   // existing shared memory and ignore the size parameter.  If false,
   // shared memory must not exist.  This flag is meaningless unless
   // name_deprecated is non-NULL.
   bool open_existing_deprecated = false;
-#endif  // !(defined(OS_MACOSX) && !defined(OS_IOS))
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
   // Size of the shared memory object to be created.
   // When opening an existing object, this has no effect.
   size_t size = 0;
 
   // If true, mappings might need to be made executable later.
   bool executable = false;
 
   // If true, the file can be shared read-only to a process.
   bool share_read_only = false;
@@ skipping 34 matching lines @@
   // Closes a shared memory handle.
   static void CloseHandle(const SharedMemoryHandle& handle);
 
   // Returns the maximum number of handles that can be open at once per process.
   static size_t GetHandleLimit();
 
   // Duplicates The underlying OS primitive. Returns NULLHandle() on failure.
   // The caller is responsible for destroying the duplicated OS primitive.
   static SharedMemoryHandle DuplicateHandle(const SharedMemoryHandle& handle);
 
-#if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
+#if defined(OS_POSIX)
   // This method requires that the SharedMemoryHandle is backed by a POSIX fd.
   static int GetFdFromSharedMemoryHandle(const SharedMemoryHandle& handle);
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_ANDROID)
   // Gets the size of the shared memory region referred to by |handle|.
   // Returns false on a failure to determine the size. On success, populates the
   // output variable |size|.
   static bool GetSizeFromSharedMemoryHandle(const SharedMemoryHandle& handle,
                                             size_t* size);
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
 
   // Creates a shared memory object as described by the options struct.
   // Returns true on success and false on failure.
   bool Create(const SharedMemoryCreateOptions& options);
 
   // Creates and maps an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
   bool CreateAndMapAnonymous(size_t size);
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // These two methods are analogs of CreateAndMapAnonymous and CreateAnonymous
+  // that force the underlying OS primitive to be a POSIX fd. Do not add new
+  // uses of these methods unless absolutely necessary, since constructing a
+  // fd-backed SharedMemory object frequently takes 100ms+.
+  // http://crbug.com/466437.
+  bool CreateAndMapAnonymousPosix(size_t size);

[erikchen, 2016/12/06 19:00:41]

Do you need both these methods? 

Please only add back the minimum functionality needed to support your desired
use case, both here and in the rest of the CL.

[lawrencewu, 2016/12/06 21:04:40]

Removed.

+  bool CreateAnonymousPosix(size_t size);
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
   // Creates an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
   bool CreateAnonymous(size_t size) {
     SharedMemoryCreateOptions options;
     options.size = size;
     return Create(options);
   }
 
 #if !defined(OS_MACOSX) || defined(OS_IOS)
   // DEPRECATED (crbug.com/345734):
@@ skipping 111 matching lines @@
   //   Close();
   //   return ok;
   // Note that the memory is unmapped by calling this method, regardless of the
   // return value.
   bool GiveToProcess(ProcessHandle process,
                      SharedMemoryHandle* new_handle) {
     return ShareToProcessCommon(process, new_handle, true, SHARE_CURRENT_MODE);
   }
 
  private:
-#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID) && \
-    !(defined(OS_MACOSX) && !defined(OS_IOS))
+#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID)
   bool PrepareMapFile(ScopedFILE fp, ScopedFD readonly);
+#if !(defined(OS_MACOSX) && !defined(OS_IOS))
   bool FilePathForMemoryName(const std::string& mem_name, FilePath* path);
 #endif
+#endif  // defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID)
   enum ShareMode {
     SHARE_READONLY,
     SHARE_CURRENT_MODE,
   };
   bool ShareToProcessCommon(ProcessHandle process,
                             SharedMemoryHandle* new_handle,
                             bool close_self,
                             ShareMode);
 
 #if defined(OS_WIN)
   // If true indicates this came from an external source so needs extra checks
   // before being mapped.
   bool external_section_;
   std::wstring       name_;
   win::ScopedHandle  mapped_file_;
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   // The OS primitive that backs the shared memory region.
   SharedMemoryHandle shm_;
+
+  // The mechanism by which the memory is mapped. Only valid if |memory_| is not
+  // |nullptr|.
+  SharedMemoryHandle::Type mapped_memory_mechanism_;
+
+  int readonly_mapped_file_;
 #elif defined(OS_POSIX)
   int                mapped_file_;
   int                readonly_mapped_file_;
 #endif
   size_t             mapped_size_;
   void*              memory_;
   bool               read_only_;
   size_t             requested_size_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemory);
 };
 }  // namespace base
 
 #endif  // BASE_MEMORY_SHARED_MEMORY_H_