Add a GUID to base::SharedMemoryHandle.

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 <stddef.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
 #include "base/mac/mac_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/unguessable_token.h"
 
 namespace base {
 
 SharedMemoryHandle::SharedMemoryHandle()
     : type_(MACH), memory_object_(MACH_PORT_NULL) {}
 
 SharedMemoryHandle::SharedMemoryHandle(
-    const base::FileDescriptor& file_descriptor)
-    : type_(POSIX), file_descriptor_(file_descriptor) {}
+    const base::FileDescriptor& file_descriptor,
+    const base::UnguessableToken& guid)
+    : type_(POSIX), file_descriptor_(file_descriptor), guid_(guid) {}
 
-SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) {
+SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size,
+                                       const base::UnguessableToken& guid) {
   type_ = MACH;
   mach_port_t named_right;
   kern_return_t kr = mach_make_memory_entry_64(
       mach_task_self(),
       &size,
       0,  // Address.
       MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE,
       &named_right,
       MACH_PORT_NULL);  // Parent handle.
   if (kr != KERN_SUCCESS) {
     memory_object_ = MACH_PORT_NULL;
     return;
   }
 
   memory_object_ = named_right;
   size_ = size;
   ownership_passes_to_ipc_ = false;
+  guid_ = guid;
 }
 
 SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object,
-                                       mach_vm_size_t size)
+                                       mach_vm_size_t size,
+                                       const base::UnguessableToken& guid)
     : type_(MACH),
       memory_object_(memory_object),
       size_(size),
-      ownership_passes_to_ipc_(false) {}
-
-SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) {
-  CopyRelevantData(handle);
-}
-
-SharedMemoryHandle& SharedMemoryHandle::operator=(
-    const SharedMemoryHandle& handle) {
-  if (this == &handle)
-    return *this;
-
-  type_ = handle.type_;
-  CopyRelevantData(handle);
-  return *this;
-}
+      ownership_passes_to_ipc_(false),
+      guid_(guid) {}
 
 SharedMemoryHandle SharedMemoryHandle::Duplicate() const {
   switch (type_) {
     case POSIX: {
       if (!IsValid())
         return SharedMemoryHandle();
       int duped_fd = HANDLE_EINTR(dup(file_descriptor_.fd));
       if (duped_fd < 0)
         return SharedMemoryHandle();
-      return SharedMemoryHandle(FileDescriptor(duped_fd, true));
+      return SharedMemoryHandle(FileDescriptor(duped_fd, true), guid_);
     }
     case MACH: {
       if (!IsValid())
         return SharedMemoryHandle();
 
       // Increment the ref count.
       kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_,
                                             MACH_PORT_RIGHT_SEND, 1);
       DCHECK_EQ(kr, KERN_SUCCESS);
       SharedMemoryHandle handle(*this);
@@ skipping 85 matching lines @@
 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) {
-  type_ = handle.type_;
-  switch (type_) {
-    case POSIX:
-      file_descriptor_ = handle.file_descriptor_;
-      break;
-    case MACH:
-      memory_object_ = handle.memory_object_;
-      size_ = handle.size_;
-      ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_;
-      break;
-  }
-}
-
 }  // namespace base