Remove CreateGpuMemoryBufferFromClientId and plumbing

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 109 matching lines @@
       for (auto& usage : kGPUReadWriteUsages) {
         if (IsNativeGpuMemoryBufferFactoryConfigurationSupported(format, usage))
           configurations.insert(std::make_pair(format, usage));
       }
     }
   }
 
   return configurations;
 }
 
-void DestroyGpuMemoryBuffer(const gpu::SyncToken& sync_token) {
-  // 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 24 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;
-  }
-
-  // Create a copy of the buffer to provide to the caller.
-  if (buffer_it->second.buffer) {
-    request->result = gpu::GpuMemoryBufferImpl::CreateFromHandle(
-        buffer_it->second.buffer->GetHandle(),
-        buffer_it->second.size, buffer_it->second.format,
-        buffer_it->second.usage, base::Bind(DestroyGpuMemoryBuffer));
-  }
-
-  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 13 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) {
-    // TODO(ccameron): Enable this for all buffer types.
-    // https://crbug.com/614791
-    if (handle.type == gfx::IO_SURFACE_BUFFER) {
-      buffer = gpu::GpuMemoryBufferImpl::CreateFromHandle(
-          handle, buffer_it->second.size, buffer_it->second.format,
-          buffer_it->second.usage, base::Bind(DestroyGpuMemoryBuffer));
-      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.buffer = 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(BufferInfo&& other)
-    : size(other.size),
-      type(other.type),
-      format(other.format),
-      usage(other.usage),
-      gpu_host_id(other.gpu_host_id),
-      buffer(std::move(other.buffer)) {}
+BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) =
+    default;
 
 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {}
 
 }  // namespace content