mac: Add auto-close and share-read-only functionality to SharedMemory.

base/memory/shared_memory_handle_mac.cc

Index: base/memory/shared_memory_handle_mac.cc
diff --git a/base/memory/shared_memory_handle_mac.cc b/base/memory/shared_memory_handle_mac.cc
index 13af82dbd952263bc36d023a736eea808717a654..c4951df1a09b288950873910d75abbfc1ff82c30 100644
--- a/base/memory/shared_memory_handle_mac.cc
+++ b/base/memory/shared_memory_handle_mac.cc
@@ -44,12 +44,17 @@ SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) {
   memory_object_ = named_right;
   size_ = size;
   pid_ = GetCurrentProcId();
+  ownership_passes_to_ipc_ = false;
 }
 
 SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object,
                                        mach_vm_size_t size,
                                        base::ProcessId pid)
-    : type_(MACH), memory_object_(memory_object), size_(size), pid_(pid) {}
+    : type_(MACH),
+      memory_object_(memory_object),
+      size_(size),
+      pid_(pid),
+      ownership_passes_to_ipc_(false) {}
 
 SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle)
     : type_(handle.type_) {
@@ -182,7 +187,7 @@ bool SharedMemoryHandle::MapAt(off_t offset,
           offset,
           FALSE,                                           // Copy
           VM_PROT_READ | (read_only ? 0 : VM_PROT_WRITE),  // Current protection
-          VM_PROT_READ | VM_PROT_WRITE,                    // Maximum protection
+          VM_PROT_WRITE | VM_PROT_READ | VM_PROT_IS_MASK,  // Maximum protection

[Mark Mentovai, 2015/10/23 14:24:03]

This bit wasn’t defined in 10.6. Does its kernel mind being passed it?

Does it make sense to use the IS_MASK bit for current protection too?

[erikchen, 2015/10/23 17:13:31]

mark: 10.6.8 doesn't have VM_PROT_IS_MASK and will have the wrong behaior. 

Options: 
(1) don't support Mach-based shared memory on 10.6.8
(2) find a way to determine the max prot of a memory object
(3) Add a max_prot member to SharedMemoryHandle, and plumb it through ipc/.

I couldn't find a way to do (2). (3) is not difficult, but honestly I'm leaning
towards (1). Thoughts?

           VM_INHERIT_NONE);
       return kr == KERN_SUCCESS;
   }
@@ -205,6 +210,16 @@ void SharedMemoryHandle::Close() const {
   }
 }
 
+void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) {
+  DCHECK_EQ(type_, MACH);
+  ownership_passes_to_ipc_ = ownership_passes;
+}
+
+bool SharedMemoryHandle::OwnershipPassesToIPC() const {
+  DCHECK_EQ(type_, MACH);
+  return ownership_passes_to_ipc_;
+}
+
 void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) {
   switch (type_) {
     case POSIX:
@@ -214,6 +229,7 @@ void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) {
       memory_object_ = handle.memory_object_;
       size_ = handle.size_;
       pid_ = handle.pid_;
+      ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_;
       break;
   }
 }