Implement GpuMemoryBufferManager::CreateGpuMemoryBufferFromClientId

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 112 matching lines @@
       for (auto& usage : kGPUReadWriteUsages) {
         if (IsNativeGpuMemoryBufferFactoryConfigurationSupported(format, usage))
           configurations.insert(std::make_pair(format, usage));
       }
     }
   }
 
   return configurations;
 }
 
+void DestroyGpuMemoryBufferNoOp(const gpu::SyncToken& sync_token) {

[reveman, 2016/05/24 22:19:47]

nit: no need for NoOp in the name

[ccameron, 2016/05/24 22:58:04]

Done.

+  // No additional state needs to be cleaned up.
+}
+
 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
 
 }  // namespace
 
 struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferRequest {
   CreateGpuMemoryBufferRequest(const gfx::Size& size,
                                gfx::BufferFormat format,
                                gfx::BufferUsage usage,
                                int client_id,
                                gpu::SurfaceHandle surface_handle)
@@ skipping 448 matching lines @@
     return;
   }
   BufferMap& buffers = client_it->second;
   BufferMap::iterator buffer_it = buffers.find(request->gpu_memory_buffer_id);
   if (buffer_it == buffers.end()) {
     LOG(ERROR) << "CreateGpuMemoryBufferFromClientId: invalid id.";
     request->event.Signal();
     return;
   }
 
-  // TODO(ccameron): Implement this.
-  NOTIMPLEMENTED();
+  // Create a copy of the buffer to provide to the caller.
+  if (buffer_it->second.parent_buffer_instance) {
+    request->result = gpu::GpuMemoryBufferImpl::CreateFromHandle(
+        buffer_it->second.parent_buffer_instance->GetHandle(),
+        buffer_it->second.size, buffer_it->second.format,
+        buffer_it->second.usage, base::Bind(DestroyGpuMemoryBufferNoOp));
+  }
+
   request->event.Signal();
 }
 
 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()) {
@@ skipping 16 matching lines @@
 void BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferOnIO(
     const CreateDelegate& create_delegate,
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     bool reused_gpu_process,
     const CreateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  TRACE_EVENT0("browser",
+               "BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferOnIO");
 
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
   if (!host) {
     host = GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
                                CAUSE_FOR_GPU_LAUNCH_GPU_MEMORY_BUFFER_ALLOCATE);
     if (!host) {
       LOG(ERROR) << "Failed to launch GPU process.";
       callback.Run(gfx::GpuMemoryBufferHandle());
       return;
     }
@@ skipping 37 matching lines @@
 
 void BrowserGpuMemoryBufferManager::GpuMemoryBufferCreatedOnIO(
     const CreateDelegate& create_delegate,
     gfx::GpuMemoryBufferId id,
     int client_id,
     int gpu_host_id,
     bool reused_gpu_process,
     const CreateCallback& callback,
     const gfx::GpuMemoryBufferHandle& handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  TRACE_EVENT0("browser",
+               "BrowserGpuMemoryBufferManager::GpuMemoryBufferCreatedOnIO");
 
   ClientMap::iterator client_it = clients_.find(client_id);
 
   // This can happen if client is removed while the buffer is being allocated.
   if (client_it == clients_.end()) {
     if (!handle.is_null()) {
       GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id);
       if (host)
         host->DestroyGpuMemoryBuffer(handle.id, client_id, gpu::SyncToken());
     }
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   BufferMap& buffers = client_it->second;
 
   BufferMap::iterator buffer_it = buffers.find(id);
   DCHECK(buffer_it != buffers.end());
   DCHECK_EQ(buffer_it->second.type, gfx::EMPTY_BUFFER);
 
   // If the handle isn't valid, that means that the GPU process crashed or is
   // misbehaving.
   bool valid_handle = !handle.is_null() && handle.id == id;
+
+  // Open a copy of the buffer in the browser process for future use.
+  std::unique_ptr<gpu::GpuMemoryBufferImpl> buffer;
+  if (valid_handle) {
+    // This is currently only used by IOSurface buffers.
+    if (handle.type == gfx::IO_SURFACE_BUFFER) {

[reveman, 2016/05/24 22:19:47]

This should be the correct behavior on all platforms. Do we need the
conditional?

[ccameron, 2016/05/24 22:58:04]

Changed this to a TODO. This is the only one that I have extensively tested, so
I'd feel safer leaving the conditional for now. I saw some flakey issues with GL
tryjobs on Linux, which I'll want to investigate.

+      buffer = gpu::GpuMemoryBufferImpl::CreateFromHandle(
+          handle, buffer_it->second.size, buffer_it->second.format,
+          buffer_it->second.usage, base::Bind(DestroyGpuMemoryBufferNoOp));
+      if (!buffer)
+        valid_handle = false;
+    }
+  }
+
   if (!valid_handle) {
     // If we failed after re-using the GPU process, it may have died in the
     // mean time. Retry to have a chance to create a fresh GPU process.
     if (handle.is_null() && reused_gpu_process) {
       DVLOG(1) << "Failed to create buffer through existing GPU process. "
                   "Trying to restart GPU process.";
       // If the GPU process has already been restarted, retry without failure
       // when GPU process host ID already exists.
       if (gpu_host_id != gpu_host_id_)
         reused_gpu_process = false;
@@ skipping 10 matching lines @@
       buffers.erase(buffer_it);
       callback.Run(gfx::GpuMemoryBufferHandle());
     }
     return;
   }
 
   // Store the type and host id of this buffer so it can be cleaned up if the
   // client is removed.
   buffer_it->second.type = handle.type;
   buffer_it->second.gpu_host_id = gpu_host_id;
+  buffer_it->second.parent_buffer_instance = std::move(buffer);
 
   callback.Run(handle);
 }
 
 void BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO(
     gfx::GpuMemoryBufferId id,
     int client_id,
     const gpu::SyncToken& sync_token) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(clients_.find(client_id) != clients_.end());
@@ skipping 40 matching lines @@
     gfx::GpuMemoryBufferType type,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int gpu_host_id)
     : size(size),
       type(type),
       format(format),
       usage(usage),
       gpu_host_id(gpu_host_id) {}
 
-BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) =
-    default;
+BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(BufferInfo&& other)
+    : size(other.size),
+      type(other.type),
+      format(other.format),
+      usage(other.usage),
+      gpu_host_id(other.gpu_host_id),
+      parent_buffer_instance(std::move(other.parent_buffer_instance)) {}
 
 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {}
 
 }  // namespace content