Give base::SharedMemory::CreateAnonymous an executable flag

base/shared_memory.h

 // Copyright (c) 2011 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_SHARED_MEMORY_H_
 #define BASE_SHARED_MEMORY_H_
 #pragma once
 
 #include "build/build_config.h"
 
@@ skipping 20 matching lines @@
 #elif defined(OS_POSIX)
 // A SharedMemoryId is sufficient to identify a given shared memory segment on a
 // system, but insufficient to map it.
 typedef FileDescriptor SharedMemoryHandle;
 typedef ino_t SharedMemoryId;
 // On POSIX, the lock is implemented as a lockf() on the mapped file,
 // so no additional member (or definition of SharedMemoryLock) is
 // needed.
 #endif
 
+// Options for creating a shared memory object.
+struct SharedMemoryCreateOptions {
+  SharedMemoryCreateOptions() : name(NULL), open_existing(false),
+                                size(0), executable(false)
+  {}

[Mark Mentovai, 2011/12/01 19:31:16]

{} belongs on the preceding line, or { on the preceding line and } on this line.

Same on line 51.

+
+  explicit SharedMemoryCreateOptions(uint32 isize) : name(NULL),

[Mark Mentovai, 2011/12/01 19:31:16]

Why do we need this form of the constructor? Can’t we just let callers set size
once they’ve established a local SharedMemoryCreateOptions object?

+                                                     open_existing(false),
+                                                     size(isize),
+                                                     executable(false)
+  {}
+
+  // 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;
+
+  // 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 is
+  // non-NULL.
+  bool open_existing;
+
+  // Size of the shared memory object to be created.
+  // When opening an existing object, this has no effect.
+  uint32 size;
+
+  // If true, mappings might need to be made executable later.
+  bool executable;
+};
+
 // Platform abstraction for shared memory.  Provides a C++ wrapper
 // around the OS primitive for a memory mapped file.
 class BASE_EXPORT SharedMemory {
  public:
   SharedMemory();
 
 #if defined(OS_WIN)
   // Similar to the default constructor, except that this allows for
   // calling Lock() to acquire the named mutex before either Create or Open
   // are called on Windows.
@@ skipping 16 matching lines @@
   // Return true iff the given handle is valid (i.e. not the distingished
   // invalid value; NULL for a HANDLE and -1 for a file descriptor)
   static bool IsHandleValid(const SharedMemoryHandle& handle);
 
   // Returns invalid handle (see comment above for exact definition).
   static SharedMemoryHandle NULLHandle();
 
   // Closes a shared memory handle.
   static void CloseHandle(const SharedMemoryHandle& handle);
 
+  // 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(uint32 size);
 
   // Creates an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
-  bool CreateAnonymous(uint32 size);
+  bool CreateAnonymous(uint32 size) {
+    SharedMemoryCreateOptions options(size);
+    return Create(options);
+  }
 
   // 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 CreateNamed(const std::string& name, bool open_existing, uint32 size);
+  bool CreateNamed(const std::string& name, bool open_existing, uint32 size) {
+    SharedMemoryCreateOptions options(size);
+    options.name = &name;
+    options.open_existing = open_existing;
+    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);
 
@@ skipping 124 matching lines @@
   }
 
  private:
   SharedMemory* shared_memory_;
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryAutoLock);
 };
 
 }  // namespace base
 
 #endif  // BASE_SHARED_MEMORY_H_