gpu: Reuse existing code for shared memory allocation.

content/common/child_process_host_impl.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 "content/common/child_process_host_impl.h"
 
 #include <limits>
 
 #include "base/atomic_sequence_num.h"
 #include "base/command_line.h"
@@ skipping 174 matching lines @@
 
 bool ChildProcessHostImpl::Send(IPC::Message* message) {
   if (!channel_) {
     delete message;
     return false;
   }
   return channel_->Send(message);
 }
 
 void ChildProcessHostImpl::AllocateSharedMemory(
-      size_t buffer_size, base::ProcessHandle child_process_handle,
+      size_t buffer_size,
       base::SharedMemoryHandle* shared_memory_handle) {
   base::SharedMemory shared_buf;
   if (!shared_buf.CreateAnonymous(buffer_size)) {
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     NOTREACHED() << "Cannot create shared memory buffer";
     return;
   }
-  shared_buf.GiveToProcess(child_process_handle, shared_memory_handle);
+  *shared_memory_handle = shared_buf.TakeHandle();
 }
 
 int ChildProcessHostImpl::GenerateChildProcessUniqueId() {
   // This function must be threadsafe.
   //
   // Historically, this function returned ids started with 1, so in several
   // places in the code a value of 0 (rather than kInvalidUniqueID) was used as
   // an invalid value. So we retain those semantics.
   int id = g_unique_id.GetNext() + 1;
 
@@ skipping 95 matching lines @@
   delegate_->OnChildDisconnected();
 }
 
 void ChildProcessHostImpl::OnBadMessageReceived(const IPC::Message& message) {
   delegate_->OnBadMessageReceived(message);
 }
 
 void ChildProcessHostImpl::OnAllocateSharedMemory(
     uint32_t buffer_size,
     base::SharedMemoryHandle* handle) {
-  AllocateSharedMemory(buffer_size, peer_process_.Handle(), handle);
+  AllocateSharedMemory(buffer_size, handle);
 }
 
 void ChildProcessHostImpl::OnShutdownRequest() {
   if (delegate_->CanShutdown())
     Send(new ChildProcessMsg_Shutdown());
 }
 
 void ChildProcessHostImpl::OnAllocateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     uint32_t width,
     uint32_t height,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gfx::GpuMemoryBufferHandle* handle) {
   // TODO(reveman): Add support for other types of GpuMemoryBuffers.
 
   // AllocateForChildProcess() will check if |width| and |height| are valid
   // and handle failure in a controlled way when not. We just need to make
   // sure |usage| is supported here.
   if (gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage)) {
     *handle = gpu::GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
-        id, gfx::Size(width, height), format, peer_process_.Handle());
+        id, gfx::Size(width, height), format);
   }
 }
 
 void ChildProcessHostImpl::OnDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gpu::SyncToken& sync_token) {
   // Note: Nothing to do here as ownership of shared memory backed
   // GpuMemoryBuffers is passed with IPC.
 }
 
 }  // namespace content