Reland 1: "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>
 
+#include "base/mac/mac_util.h"
 #include "base/posix/eintr_wrapper.h"
 
 namespace base {
 
 static_assert(sizeof(SharedMemoryHandle::Type) <=
                   sizeof(SharedMemoryHandle::TypeWireFormat),
               "Size of enum SharedMemoryHandle::Type exceeds size of type "
               "transmitted over wire.");
 
 SharedMemoryHandle::SharedMemoryHandle() : type_(POSIX), file_descriptor_() {}
@@ skipping 16 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 101 matching lines @@
                                void** memory,
                                bool read_only) {
   DCHECK(IsValid());
   switch (type_) {
     case SharedMemoryHandle::POSIX:
       *memory = mmap(nullptr, bytes, PROT_READ | (read_only ? 0 : PROT_WRITE),
                      MAP_SHARED, file_descriptor_.fd, offset);
 
       return *memory && *memory != reinterpret_cast<void*>(-1);
     case SharedMemoryHandle::MACH:
+      // The flag VM_PROT_IS_MASK is only supported on OSX 10.7+.
+      DCHECK(mac::IsOSLionOrLater());
+
       DCHECK_EQ(pid_, GetCurrentProcId());
       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
           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