Add GpuMemoryBuffer CreateFromClientId interface

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

 // Copyright 2014 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_memory_buffer_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 150 matching lines @@
       : CreateGpuMemoryBufferRequest(size,
                                      format,
                                      gfx::BufferUsage::GPU_READ,
                                      client_id,
                                      gpu::kNullSurfaceHandle),
         handle(handle) {}
   ~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)
     : native_configurations_(GetNativeGpuMemoryBufferConfigurations()),
       gpu_client_id_(gpu_client_id),
       gpu_client_tracing_id_(gpu_client_tracing_id),
       gpu_host_id_(0) {
   DCHECK(!g_gpu_memory_buffer_manager);
   g_gpu_memory_buffer_manager = this;
 }
@@ skipping 124 matching lines @@
     DLOG(ERROR) << "Child process attempted to allocate a GpuMemoryBuffer with "
                    "an existing ID.";
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   callback.Run(gpu::GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
       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) {
   return gpu::GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void BrowserGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
   static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token(
@@ skipping 202 matching lines @@
   request->result = gpu::GpuMemoryBufferImplSharedMemory::CreateFromHandle(
       handle, request->size, request->format, request->usage,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), new_id, request->client_id)));
   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) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Early out if factory failed to create the buffer.
   if (handle.is_null()) {
     request->event.Signal();
     return;
   }
@@ skipping 170 matching lines @@
     return gpu_client_tracing_id_;
   }
 
   // In normal cases, |client_id| is a child process id, so we can perform
   // the standard conversion.
   return ChildProcessHostImpl::ChildProcessUniqueIdToTracingProcessId(
       client_id);
 }
 
 }  // namespace content