Add GpuMemoryBuffer CreateFromClientId interface

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

Index: content/browser/gpu/browser_gpu_memory_buffer_manager.cc
diff --git a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
index d104dd39033a848afc866d0850db87476c4ad520..c8dd9a399d53194fbc35157eb3921edf77ee0bdf 100644
--- a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
+++ b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
@@ -168,6 +168,21 @@ struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandleRequest
   gfx::GpuMemoryBufferHandle handle;
 };
 
+struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromChildIdRequest
+    : public CreateGpuMemoryBufferRequest {
+  CreateGpuMemoryBufferFromChildIdRequest(
+      int client_id,
+      const gfx::GpuMemoryBufferId& gpu_memory_buffer_id)
+      : CreateGpuMemoryBufferRequest(gfx::Size(),
+                                     gfx::BufferFormat::RGBA_8888,
+                                     gfx::BufferUsage::GPU_READ,
+                                     client_id,
+                                     gpu::kNullSurfaceHandle),
+        gpu_memory_buffer_id(gpu_memory_buffer_id) {}
+  ~CreateGpuMemoryBufferFromChildIdRequest() {}
+  gfx::GpuMemoryBufferId gpu_memory_buffer_id;
+};
+
 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(
     int gpu_client_id,
     uint64_t gpu_client_tracing_id)
@@ -312,6 +327,30 @@ void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
       id, size, format, child_process_handle));
 }
 
+std::unique_ptr<gfx::GpuMemoryBuffer>
+BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromChildId(
+    int child_client_id,
+    const gfx::GpuMemoryBufferId& gpu_memory_buffer_id) {
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  CreateGpuMemoryBufferFromChildIdRequest request(child_client_id,
+                                                  gpu_memory_buffer_id);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&BrowserGpuMemoryBufferManager::
+                     HandleCreateGpuMemoryBufferFromChildIdOnIO,
+                 base::Unretained(this),  // Safe as we wait for result below.
+                 base::Unretained(&request)));
+
+  // We're blocking the UI thread, which is generally undesirable.
+  TRACE_EVENT0(
+      "browser",
+      "BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromChildId");
+  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  request.event.Wait();
+  return std::move(request.result);
+}
+
 gfx::GpuMemoryBuffer*
 BrowserGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
@@ -534,6 +573,12 @@ void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferFromHandleOnIO(
   request->event.Signal();
 }
 
+void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferFromChildIdOnIO(
+    CreateGpuMemoryBufferFromChildIdRequest* request) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // TODO(ccameron): Implement this.

[ccameron, 2016/05/12 23:41:38]

I've left this blank in this patch -- the plan is to have the next patch
implement this.

AFAICT, we'll need to implement this in two ways
Scheme 1: Store the information in BufferInfo that is necessary to open the
buffer
Scheme 2: Send an IPC to the GPU process to create a GpuMemoryBufferHandle for
us to open.

Shared memory will need to do Scheme 1. IOSurfaces can do either -- Scheme 1
will be more efficient (just 1 hop), but will involve a fair bit of #if-MACOSX
code. I suspect other types will need to do Scheme 2.

[reveman, 2016/05/13 12:28:37]

We should do Scheme 1 as we need to store something in BufferInfo that allows us
to create the buffer without a GPU trip anyhow. It's a bug that we don't. See
crbug.com/597932. We should be able to do this without much ifdef-code, I think.

[ccameron, 2016/05/16 18:41:16]

I've added the implementation for IOSurfaces here. It has more ifdef code than
I'd like because we can't just hold on to the handle (because that affects the
refcounting we need from the window server).

+}
+
 void BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO(
     CreateGpuMemoryBufferRequest* request,
     const gfx::GpuMemoryBufferHandle& handle) {