gpu: Compositor management of GpuMemoryBuffer instances.

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"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/numerics/safe_math.h"
 #include "base/path_service.h"
 #include "base/process/process_metrics.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "content/common/child_process_messages.h"
-#include "content/common/gpu/client/gpu_memory_buffer_impl.h"
+#include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
 #include "content/public/common/child_process_host_delegate.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/message_filter.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #elif defined(OS_WIN)
@@ skipping 215 matching lines @@
     }
   }
 
   if (!handled) {
     handled = true;
     IPC_BEGIN_MESSAGE_MAP(ChildProcessHostImpl, msg)
       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
                           OnShutdownRequest)
       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateSharedMemory,
                           OnAllocateSharedMemory)
-      IPC_MESSAGE_HANDLER(ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer,
-                          OnAllocateGpuMemoryBuffer)
+      IPC_MESSAGE_HANDLER_DELAY_REPLY(
+          ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer,
+          OnAllocateGpuMemoryBuffer)
+      IPC_MESSAGE_HANDLER(ChildProcessHostMsg_DeletedGpuMemoryBuffer,
+                          OnDeletedGpuMemoryBuffer)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
 
     if (!handled)
       handled = delegate_->OnMessageReceived(msg);
   }
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
     logger->OnPostDispatchMessage(msg, channel_id_);
@@ skipping 35 matching lines @@
 }
 
 void ChildProcessHostImpl::OnShutdownRequest() {
   if (delegate_->CanShutdown())
     Send(new ChildProcessMsg_Shutdown());
 }
 
 void ChildProcessHostImpl::OnAllocateGpuMemoryBuffer(
     uint32 width,
     uint32 height,
-    uint32 internalformat,
-    uint32 usage,
-    gfx::GpuMemoryBufferHandle* handle) {
-  handle->type = gfx::SHARED_MEMORY_BUFFER;
-  AllocateSharedMemory(
-      width * height * GpuMemoryBufferImpl::BytesPerPixel(internalformat),
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage,
+    IPC::Message* reply) {
+  base::CheckedNumeric<int> size = width;
+  size *= height;
+  if (!size.IsValid()) {
+    GpuMemoryBufferAllocated(reply, gfx::GpuMemoryBufferHandle());
+    return;
+  }
+
+  // TODO(reveman): Add support for other types of GpuMemoryBuffers.
+  if (!GpuMemoryBufferImplSharedMemory::IsConfigurationSupported(
+          gfx::Size(width, height), format, usage)) {
+    GpuMemoryBufferAllocated(reply, gfx::GpuMemoryBufferHandle());
+    return;
+  }
+
+  GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
+      gfx::Size(width, height),
+      format,
       peer_handle_,
-      &handle->handle);
+      base::Bind(&ChildProcessHostImpl::GpuMemoryBufferAllocated,
+                 base::Unretained(this),

[piman, 2014/10/10 02:58:42]

nit: can you add a comment that unretained is safe because the callback is
called synchronously for GpuMemoryBufferImplSharedMemory? Just so that this
isn't cargo-culted to other types later (where it might be wrong).

[reveman, 2014/10/10 12:47:44]

Done.

+                 reply));
+}
+
+void ChildProcessHostImpl::OnDeletedGpuMemoryBuffer(
+    gfx::GpuMemoryBufferType type,
+    const gfx::GpuMemoryBufferId& id) {
+  // Note: Nothing to do here as ownership of shared memory backed
+  // GpuMemoryBuffers is passed with IPC.
+}
+
+void ChildProcessHostImpl::GpuMemoryBufferAllocated(
+    IPC::Message* reply,
+    const gfx::GpuMemoryBufferHandle& handle) {
+  ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer::WriteReplyParams(reply,
+                                                                    handle);
+  Send(reply);
 }
 
 }  // namespace content