Get rid of SharedMemory::GiveToProcess.

base/memory/shared_memory_win.cc

 // Copyright (c) 2011 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 <aclapi.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 167 matching lines @@
 // static
 size_t SharedMemory::GetHandleLimit() {
   // Rounded down from value reported here:
   // http://blogs.technet.com/b/markrussinovich/archive/2009/09/29/3283844.aspx
   return static_cast<size_t>(1 << 23);
 }
 
 // static
 SharedMemoryHandle SharedMemory::DuplicateHandle(
     const SharedMemoryHandle& handle) {
-  DCHECK(handle.BelongsToCurrentProcess());
-  HANDLE duped_handle;
-  ProcessHandle process = GetCurrentProcess();
-  BOOL success =
-      ::DuplicateHandle(process, handle.GetHandle(), process, &duped_handle, 0,
-                        FALSE, DUPLICATE_SAME_ACCESS);

[Nico, 2017/05/02 15:58:45]

Oh, you just moved this around. Nits still apply, I suppose.

-  if (success) {
-    base::SharedMemoryHandle handle(duped_handle, GetCurrentProcId());
-    handle.SetOwnershipPassesToIPC(true);
-    return handle;
-  }
-  return SharedMemoryHandle();
+  return handle.Duplicate();
 }
 
 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
   // TODO(bsy,sehr): crbug.com/210609 NaCl forces us to round up 64k here,
   // wasting 32k per mapping on average.
   static const size_t kSectionMask = 65536 - 1;
@@ skipping 135 matching lines @@
                          FILE_MAP_READ | SECTION_QUERY, FALSE, 0)) {
     return SharedMemoryHandle();
   }
   SharedMemoryHandle handle =
       SharedMemoryHandle(result, base::GetProcId(process));
   handle.SetOwnershipPassesToIPC(true);
   return handle;
 }
 
 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
-                                        SharedMemoryHandle* new_handle,
-                                        bool close_self) {
+                                        SharedMemoryHandle* new_handle) {
   *new_handle = SharedMemoryHandle();
   DWORD access = FILE_MAP_READ | SECTION_QUERY;
   DWORD options = 0;
   HANDLE mapped_file = mapped_file_.Get();
   HANDLE result;
   if (!read_only_)
     access |= FILE_MAP_WRITE;
-  if (close_self) {
-    // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
-    options = DUPLICATE_CLOSE_SOURCE;
-    HANDLE detached_handle = mapped_file_.Take();
-    DCHECK_EQ(detached_handle, mapped_file);
-    Unmap();
-  }
-
-  if (process == GetCurrentProcess() && close_self) {
-    *new_handle = SharedMemoryHandle(mapped_file, base::GetCurrentProcId());
-    return true;
-  }
 
   if (!::DuplicateHandle(GetCurrentProcess(), mapped_file, process, &result,
                          access, FALSE, options)) {
     return false;
   }
   *new_handle = SharedMemoryHandle(result, base::GetProcId(process));
   new_handle->SetOwnershipPassesToIPC(true);
   return true;
 }
 
 
 void SharedMemory::Close() {
   mapped_file_.Close();
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
   return SharedMemoryHandle(mapped_file_.Get(), base::GetCurrentProcId());
 }
 
 SharedMemoryHandle SharedMemory::TakeHandle() {
   SharedMemoryHandle handle(mapped_file_.Take(), base::GetCurrentProcId());
   handle.SetOwnershipPassesToIPC(true);
   memory_ = nullptr;
   mapped_size_ = 0;
   return handle;
 }
 
 }  // namespace base