Add a size parameter to SharedMemoryHandle.

base/memory/shared_memory_mac.cc

 // Copyright (c) 2012 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.h"
 
 #include <errno.h>
 #include <mach/mach_vm.h>
 #include <stddef.h>
 #include <sys/mman.h>
@@ skipping 30 matching lines @@
 // ownership of the underlying memory object.
 // |handle| is the handle to copy.
 // If |handle| is already mapped, |mapped_addr| is its mapped location.
 // Otherwise, |mapped_addr| should be |nullptr|.
 bool MakeMachSharedMemoryHandleReadOnly(SharedMemoryHandle* new_handle,
                                         SharedMemoryHandle handle,
                                         void* mapped_addr) {
   if (!handle.IsValid())
     return false;
 
-  size_t size;
-  CHECK(handle.GetSize(&size));
+  size_t size = handle.GetSize();
 
   // Map if necessary.
   void* temp_addr = mapped_addr;
   base::mac::ScopedMachVM scoper;
   if (!temp_addr) {
     // Intentionally lower current prot and max prot to |VM_PROT_READ|.
     kern_return_t kr = mach_vm_map(
         mach_task_self(), reinterpret_cast<mach_vm_address_t*>(&temp_addr),
         size, 0, VM_FLAGS_ANYWHERE, handle.GetMemoryObject(), 0, FALSE,
         VM_PROT_READ, VM_PROT_READ, VM_INHERIT_NONE);
@@ skipping 54 matching lines @@
 // static
 int SharedMemory::GetFdFromSharedMemoryHandle(
     const SharedMemoryHandle& handle) {
   return handle.file_descriptor_.fd;
 }
 
 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
-// static
-bool SharedMemory::GetSizeFromSharedMemoryHandle(
-    const SharedMemoryHandle& handle,
-    size_t* size) {
-  return handle.GetSize(size);
-}
-
 // Chromium mostly only uses the unique/private shmem as specified by
 // "name == L"". The exception is in the StatsTable.
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
   DCHECK(!shm_.IsValid());
   if (options.size == 0) {
     last_error_ = SharedMemoryError::BAD_PARAMS;
     return false;
   }
 
   if (options.size > static_cast<size_t>(std::numeric_limits<int>::max())) {
@@ skipping 34 matching lines @@
       last_error_ = SharedMemoryError::TRUNCATE_FAILED;
       return false;
     }
   }
   requested_size_ = options.size;
 
   int mapped_file = -1;
   int readonly_mapped_file = -1;
   result = PrepareMapFile(std::move(fp), std::move(readonly_fd), &mapped_file,
                           &readonly_mapped_file, &last_error_);
-  shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false),
+  shm_ = SharedMemoryHandle(FileDescriptor(mapped_file, false), options.size,
                             UnguessableToken::Create());
-  readonly_shm_ = SharedMemoryHandle(
-      FileDescriptor(readonly_mapped_file, false), shm_.GetGUID());
+  readonly_shm_ =
+      SharedMemoryHandle(FileDescriptor(readonly_mapped_file, false),
+                         options.size, shm_.GetGUID());
   return result;
 }
 
 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
   if (!shm_.IsValid()) {
     last_error_ = SharedMemoryError::BAD_PARAMS;
     return false;
   }
   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max())) {
     last_error_ = SharedMemoryError::BAD_PARAMS;
@@ skipping 32 matching lines @@
                          mapped_size_);
       break;
   }
 
   memory_ = NULL;
   mapped_size_ = 0;
   return true;
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
-  switch (shm_.type_) {
-    case SharedMemoryHandle::POSIX:
-      return SharedMemoryHandle(FileDescriptor(shm_.file_descriptor_.fd, false),
-                                shm_.GetGUID());

[Nico, 2017/05/15 22:13:36]

Why is this changing?

[erikchen, 2017/05/15 22:57:18]

The old code weas basically the same, expect it changes the
ownership_passes_to_ipc_ member to false. POSIX fd is used in exactly one place,
which doesn't pass to IPC.

And this now patches the implementation on POSIX.

-    case SharedMemoryHandle::MACH:
-      return shm_;
-  }
+  return shm_;
 }
 
 SharedMemoryHandle SharedMemory::TakeHandle() {
   SharedMemoryHandle dup = DuplicateHandle(handle());
   Close();
   return dup;
 }
 
 void SharedMemory::Close() {
   shm_.Close();
@@ skipping 16 matching lines @@
 
   DCHECK(shm_.IsValid());
   base::SharedMemoryHandle new_handle;
   bool success = MakeMachSharedMemoryHandleReadOnly(&new_handle, shm_, memory_);
   if (success)
     new_handle.SetOwnershipPassesToIPC(true);
   return new_handle;
 }
 
 }  // namespace base