Remove named SharedMemory usage on 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 "build/build_config.h"
 
 #include <string>
@@ skipping 15 matching lines @@
 #include "base/files/scoped_file.h"
 #endif
 
 namespace base {
 
 class FilePath;
 
 // Options for creating a shared memory object.
 struct SharedMemoryCreateOptions {
   SharedMemoryCreateOptions()
-      : name_deprecated(NULL),
-        size(0),
-        open_existing_deprecated(false),
+      : size(0),
         executable(false),
-        share_read_only(false) {}
+        share_read_only(false) {
+#if !defined(OS_MACOSX)
+    name_deprecated = nullptr;
+    open_existing_deprecated = false;
+#endif
+  }
 
+#if !defined(OS_MACOSX)
   // 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;
+#endif
 
   // Size of the shared memory object to be created.
   // When opening an existing object, this has no effect.
   size_t size;
 
+#if !defined(OS_MACOSX)
   // 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
 
   // 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;
 };
 
 // Platform abstraction for shared memory.  Provides a C++ wrapper
 // around the OS primitive for a memory mapped file.
@@ skipping 64 matching lines @@
   bool CreateAndMapAnonymous(size_t size);
 
   // 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)
   // DEPRECATED (crbug.com/345734):
   // Creates or opens a shared memory segment based on a name.
   // If open_existing is true, and the shared memory already exists,
   // opens the existing shared memory and ignores the size parameter.
   // If open_existing is false, shared memory must not exist.
   // size is the size of the block to be created.
   // Returns true on success, false on failure.
   bool CreateNamedDeprecated(
       const std::string& name, bool open_existing, size_t size) {
     SharedMemoryCreateOptions options;
     options.name_deprecated = &name;
     options.open_existing_deprecated = open_existing;
     options.size = size;
     return Create(options);
   }
 
   // Deletes resources associated with a shared memory segment based on name.
   // Not all platforms require this call.
   bool Delete(const std::string& name);
 
   // Opens a shared memory segment based on a name.
   // If read_only is true, opens for read-only access.
   // Returns true on success, false on failure.
   bool Open(const std::string& name, bool read_only);
+#endif  // !defined(OS_MACOSX)
 
   // Maps the shared memory into the caller's address space.
   // Returns true on success, false otherwise.  The memory address
   // is accessed via the memory() accessor.  The mapped address is guaranteed to
   // have an alignment of at least MAP_MINIMUM_ALIGNMENT. This method will fail
   // if this object is currently mapped.
   bool Map(size_t bytes) {
     return MapAt(0, bytes);
   }
 
   // Same as above, but with |offset| to specify from begining of the shared
   // memory block to map.
   // |offset| must be alignent to value of |SysInfo::VMAllocationGranularity()|.
   bool MapAt(off_t offset, size_t bytes);
   enum { MAP_MINIMUM_ALIGNMENT = 32 };
 
   // Unmaps the shared memory from the caller's address space.
   // Returns true if successful; returns false on error or if the
   // memory is not mapped.
   bool Unmap();
 
   // The size requested when the map is first created.
   size_t requested_size() const { return requested_size_; }
 
   // The actual size of the mapped memory (may be larger than requested).
   size_t mapped_size() const { return mapped_size_; }
 
   // Gets a pointer to the opened memory space if it has been
   // Mapped via Map().  Returns NULL if it is not mapped.
-  void *memory() const { return memory_; }
+  void* memory() const { return memory_; }
 
   // Returns the underlying OS handle for this segment.
   // Use of this handle for anything other than an opaque
   // identifier is not portable.
   SharedMemoryHandle handle() const;
 
   // Closes the open shared memory segment. The memory will remain mapped if
   // it was previously mapped.
   // It is safe to call Close repeatedly.
   void Close();
@@ skipping 70 matching lines @@
   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_