exo: Directly create GpuMemoryBufferImpl when a handle is available.

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 60 matching lines @@
   ~CreateGpuMemoryBufferRequest() {}
   base::WaitableEvent event;
   gfx::Size size;
   gfx::BufferFormat format;
   gfx::BufferUsage usage;
   int client_id;
   gpu::SurfaceHandle surface_handle;
   std::unique_ptr<gfx::GpuMemoryBuffer> result;
 };
 
-struct BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandleRequest
-    : public CreateGpuMemoryBufferRequest {
-  CreateGpuMemoryBufferFromHandleRequest(
-      const gfx::GpuMemoryBufferHandle& handle,
-      const gfx::Size& size,
-      gfx::BufferFormat format,
-      int client_id)
-      : CreateGpuMemoryBufferRequest(size,
-                                     format,
-                                     gfx::BufferUsage::GPU_READ,
-                                     client_id,
-                                     gpu::kNullSurfaceHandle),
-        handle(handle) {}
-  ~CreateGpuMemoryBufferFromHandleRequest() {}
-  gfx::GpuMemoryBufferHandle handle;
-};
-
 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(
     int gpu_client_id,
     uint64_t gpu_client_tracing_id)
     : native_configurations_(gpu::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 39 matching lines @@
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::CreateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
   return AllocateGpuMemoryBufferForSurface(size, format, usage, surface_handle);
 }
 
-std::unique_ptr<gfx::GpuMemoryBuffer>
-BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle(
-    const gfx::GpuMemoryBufferHandle& handle,
-    const gfx::Size& size,
-    gfx::BufferFormat format) {
-  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  CreateGpuMemoryBufferFromHandleRequest request(handle, size, format,
-                                                 gpu_client_id_);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&BrowserGpuMemoryBufferManager::
-                     HandleCreateGpuMemoryBufferFromHandleOnIO,
-                 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::CreateGpuMemoryBufferFromHandle");
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
-  request.event.Wait();
-  return std::move(request.result);
-}
-
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Use service side allocation for native configurations.
@@ skipping 179 matching lines @@
   request->result = gpu::GpuMemoryBufferImplSharedMemory::Create(
       new_id, request->size, request->format,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), new_id, request->client_id)));
   request->event.Signal();
 }
 
-void BrowserGpuMemoryBufferManager::HandleCreateGpuMemoryBufferFromHandleOnIO(
-    CreateGpuMemoryBufferFromHandleRequest* request) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId();
-
-  BufferMap& buffers = clients_[request->client_id];
-  auto insert_result = buffers.insert(std::make_pair(
-      new_id, BufferInfo(request->size, request->handle.type,
-                         request->format, request->usage, 0)));
-  DCHECK(insert_result.second);
-
-  gfx::GpuMemoryBufferHandle handle = request->handle;
-  handle.id = new_id;
-
-  // Note: Unretained is safe as IO thread is stopped before manager is
-  // destroyed.
-  request->result = gpu::GpuMemoryBufferImpl::CreateFromHandle(
-      handle, request->size, request->format, request->usage,
-      base::Bind(
-          &GpuMemoryBufferDeleted,
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
-          base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
-                     base::Unretained(this), new_id, request->client_id)));
-  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 188 matching lines @@
       format(format),
       usage(usage),
       gpu_host_id(gpu_host_id) {}
 
 BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) =
     default;
 
 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {}
 
 }  // namespace content