Plumb GpuMemoryBuffer allocation to GPU process.

content/browser/gpu/browser_gpu_channel_host_factory.cc

Index: content/browser/gpu/browser_gpu_channel_host_factory.cc
diff --git a/content/browser/gpu/browser_gpu_channel_host_factory.cc b/content/browser/gpu/browser_gpu_channel_host_factory.cc
index 0c43205d3d80b81a60230fba718914d1348b886f..13ccf34c433beb14efe7043498fc41734f1275df 100644
--- a/content/browser/gpu/browser_gpu_channel_host_factory.cc
+++ b/content/browser/gpu/browser_gpu_channel_host_factory.cc
@@ -469,4 +469,85 @@ void BrowserGpuChannelHostFactory::SetHandlerForControlMessages(
                  filter));
 }
 
+void BrowserGpuChannelHostFactory::CreateGpuMemoryBuffer(
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    unsigned internalformat,
+    unsigned usage,
+    const CreateGpuMemoryBufferCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  GetIOLoopProxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO,
+                 base::Unretained(this),
+                 handle,
+                 size,
+                 internalformat,
+                 usage,
+                 callback));

[piman, 2014/06/10 02:48:13]

This pattern, passing a callback to another thread, is dangerous in subtle ways.

A callback refcounts its storage. Because of this, you can't guarantee which
thread the storage gets destroyed, if you pass the callback to another thread.
Since the callback comes from the user, you don't know if its storage might
contain non-thread-safe references (e.g. a RefCounted class), in which case
destroying the storage on another thread would cause bad things.

A way around this is to keep the callback in a queue, that'd be only used from
the UI thread. In OnGpuMemoryBufferCreated you'd pop the callback and run it
(assuming in order callbacks, otherwise keeping an id and a hash_map would
work).

[alexst (slow to review), 2014/06/10 04:38:25]

That is very subtle...

[piman, 2014/06/10 23:11:31]

I know :(

+}
+
+void BrowserGpuChannelHostFactory::DestroyGpuMemoryBuffer(
+    const gfx::GpuMemoryBufferHandle& handle,
+    int32 sync_point) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  GetIOLoopProxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::DestroyGpuMemoryBufferOnIO,
+                 base::Unretained(this),
+                 handle,
+                 sync_point));
+}
+
+void BrowserGpuChannelHostFactory::CreateGpuMemoryBufferOnIO(
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    unsigned internalformat,
+    unsigned usage,
+    const CreateGpuMemoryBufferCallback& callback) {
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
+  if (!host) {
+    GpuMemoryBufferCreatedOnIO(callback, gfx::GpuMemoryBufferHandle());
+    return;
+  }
+
+  host->CreateGpuMemoryBuffer(
+      handle,
+      size,
+      internalformat,
+      usage,
+      base::Bind(&BrowserGpuChannelHostFactory::GpuMemoryBufferCreatedOnIO,
+                 callback));
+}
+
+// static
+void BrowserGpuChannelHostFactory::GpuMemoryBufferCreatedOnIO(
+    const CreateGpuMemoryBufferCallback& callback,
+    const gfx::GpuMemoryBufferHandle& handle) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated,
+                 callback,
+                 handle));
+}
+
+// static
+void BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated(
+    const CreateGpuMemoryBufferCallback& callback,
+    const gfx::GpuMemoryBufferHandle& handle) {
+  callback.Run(handle);
+}
+
+void BrowserGpuChannelHostFactory::DestroyGpuMemoryBufferOnIO(
+    const gfx::GpuMemoryBufferHandle& handle,
+    int32 sync_point) {
+  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
+  if (!host) {
+    return;
+  }
+
+  host->DestroyGpuMemoryBuffer(handle, sync_point);
+}
+
 }  // namespace content