Plumb GpuMemoryBuffer allocation to GPU process.

content/browser/gpu/browser_gpu_channel_host_factory.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/browser/gpu/browser_gpu_channel_host_factory.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 451 matching lines @@
                                        target_task_runner);
   filter->AddRoute(MSG_ROUTING_CONTROL, handler);
 
   GetIOLoopProxy()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::AddFilterOnIO,
                  gpu_host_id_,
                  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