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

base/memory/shared_memory_handle_mac.cc

 // Copyright 2015 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.
 
 #include "base/memory/shared_memory_handle.h"
 
 #include <mach/mach_vm.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
@@ skipping 26 matching lines @@
       &named_right,
       MACH_PORT_NULL);  // Parent handle.
   if (kr != KERN_SUCCESS) {
     memory_object_ = MACH_PORT_NULL;
     return;
   }
 
   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_) {
   CopyRelevantData(handle);
 }
 
 SharedMemoryHandle& SharedMemoryHandle::operator=(
     const SharedMemoryHandle& handle) {
   if (this == &handle)
     return *this;
@@ skipping 112 matching lines @@
       kern_return_t kr = mach_vm_map(
           mach_task_self(),
           reinterpret_cast<mach_vm_address_t*>(memory),    // Output parameter
           bytes,
           0,                                               // Alignment mask
           VM_FLAGS_ANYWHERE,
           memory_object_,
           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;
   }
 }
 
 void SharedMemoryHandle::Close() const {
   if (!IsValid())
     return;
 
   switch (type_) {
     case POSIX:
       if (IGNORE_EINTR(close(file_descriptor_.fd)) < 0)
         DPLOG(ERROR) << "Error closing fd.";
       break;
     case MACH:
       kern_return_t kr = mach_port_deallocate(mach_task_self(), memory_object_);
       if (kr != KERN_SUCCESS)
         DPLOG(ERROR) << "Error deallocating mach port: " << kr;
       break;
   }
 }
 
+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:
       file_descriptor_ = handle.file_descriptor_;
       break;
     case MACH:
       memory_object_ = handle.memory_object_;
       size_ = handle.size_;
       pid_ = handle.pid_;
+      ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_;
       break;
   }
 }
 
 }  // namespace base