mac: Remove POSIX shared memory.

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 14 matching lines @@
 #endif
 
 namespace base {
 
 class FilePath;
 
 // Options for creating a shared memory object.
 struct BASE_EXPORT SharedMemoryCreateOptions {
   SharedMemoryCreateOptions();
 
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // The type of OS primitive that should back the SharedMemory object.
-  SharedMemoryHandle::Type type;
-#else
+#if !(defined(OS_MACOSX) && !defined(OS_IOS))

[Avi (use Gerrit), 2016/04/09 00:13:40]

OMG

Does iOS use this? Can we just say #if !defined(OS_MACOSX)? Or do we leave this,
and when we remove the two deprecated fields guarded by the #if, the problem
goes away?

[erikchen, 2016/04/09 00:20:50]

iOS still uses the POSIX implementation for shared memory, as well as all the
POSIX shared memory tests, which require these fields.

   // 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;
 
   // 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;
-#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;
 
   // If true, mappings might need to be made executable later.
   bool executable;
 
   // If true, the file can be shared read-only to a process.
   bool share_read_only;
@@ 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)
+#if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
   // 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);
-  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 104 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)
+#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID) && \
+    !(defined(OS_MACOSX) && !defined(OS_IOS))
   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_;
   HANDLE             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_