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::CreateGpuMemoryBufferFromClientIdRequest
+    : public CreateGpuMemoryBufferRequest {
+  CreateGpuMemoryBufferFromClientIdRequest(
+      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) {}
+  ~CreateGpuMemoryBufferFromClientIdRequest() {}
+  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::CreateGpuMemoryBufferFromClientId(
+    int client_id,
+    const gfx::GpuMemoryBufferId& gpu_memory_buffer_id) {
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  CreateGpuMemoryBufferFromClientIdRequest request(client_id,
+                                                   gpu_memory_buffer_id);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&BrowserGpuMemoryBufferManager::
+                     HandleCreateGpuMemoryBufferFromClientIdOnIO,
+                 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::CreateGpuMemoryBufferFromClientId");
+  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::HandleCreateGpuMemoryBufferFromClientIdOnIO(
+    CreateGpuMemoryBufferFromClientIdRequest* request) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // This must be robust to renderer processes specifying invalid ids or the
+  // client being removed.
+  ClientMap::iterator client_it = clients_.find(request->client_id);
+  if (client_it == clients_.end()) {
+    LOG(ERROR) << "CreateGpuMemoryBufferFromClientId: invalid client.";
+    request->event.Signal();
+    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();
+  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()) {
     request->event.Signal();
     return;
   }
@@ skipping 169 matching lines @@
     // The gpu_client uses a fixed tracing ID.
     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);
 }
 
+BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo() = default;
+
+BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(
+    const gfx::Size& size,
+    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() {}
+
 }  // namespace content