gpu: Simplify the error handling during gpu memory buffer allocation.

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 12 matching lines @@
 #include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "gpu/ipc/client/gpu_memory_buffer_impl_shared_memory.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer_tracing.h"
 #include "ui/gl/gl_switches.h"
 
 namespace content {
 namespace {
 
-void HostCreateGpuMemoryBuffer(
-    gpu::SurfaceHandle surface_handle,
-    GpuProcessHost* host,
-    gfx::GpuMemoryBufferId id,
-    const gfx::Size& size,
-    gfx::BufferFormat format,
-    gfx::BufferUsage usage,
-    int client_id,
-    const BrowserGpuMemoryBufferManager::CreateCallback& callback) {
-  host->CreateGpuMemoryBuffer(id, size, format, usage, client_id,
-                              surface_handle, callback);
-}
-
 void GpuMemoryBufferDeleted(
     scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner,
     const gpu::GpuMemoryBufferImpl::DestructionCallback& destruction_callback,
     const gpu::SyncToken& sync_token) {
   destruction_task_runner->PostTask(
       FROM_HERE, base::Bind(destruction_callback, sync_token));
 }
 
 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
 
@@ skipping 20 matching lines @@
   int client_id;
   gpu::SurfaceHandle surface_handle;
   std::unique_ptr<gfx::GpuMemoryBuffer> result;
 };
 
 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) {
+      gpu_client_tracing_id_(gpu_client_tracing_id) {
   DCHECK(!g_gpu_memory_buffer_manager);
   g_gpu_memory_buffer_manager = this;
 }
 
 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() {
   g_gpu_memory_buffer_manager = nullptr;
 }
 
 // static
 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() {
@@ skipping 13 matching lines @@
     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.
   if (IsNativeGpuMemoryBufferConfiguration(format, usage)) {
-    CreateGpuMemoryBufferOnIO(
-        base::Bind(&HostCreateGpuMemoryBuffer, gpu::kNullSurfaceHandle), id,
-        size, format, usage, child_client_id, false, callback);
+    CreateGpuMemoryBufferOnIO(id, size, format, usage, gpu::kNullSurfaceHandle,
+                              child_client_id, callback);
     return;
   }
 
   // Early out if we cannot fallback to shared memory buffer.
   if (!gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
       !gpu::GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size,
                                                                   format)) {
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
@@ skipping 133 matching lines @@
     CreateGpuMemoryBufferRequest* request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId();
 
   // Use service side allocation for native configurations.
   if (IsNativeGpuMemoryBufferConfiguration(request->format, request->usage)) {
     // Note: Unretained is safe as this is only used for synchronous allocation
     // from a non-IO thread.
     CreateGpuMemoryBufferOnIO(
-        base::Bind(&HostCreateGpuMemoryBuffer, request->surface_handle), new_id,
-        request->size, request->format, request->usage, request->client_id,
-        false,
+        new_id, request->size, request->format, request->usage,
+        request->surface_handle, request->client_id,
         base::Bind(
             &BrowserGpuMemoryBufferManager::HandleGpuMemoryBufferCreatedOnIO,
             base::Unretained(this), base::Unretained(request)));
     return;
   }
 
   DCHECK(gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
       << static_cast<int>(request->usage);
 
   BufferMap& buffers = clients_[request->client_id];
@@ skipping 33 matching lines @@
       handle, request->size, request->format, request->usage,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), handle.id, request->client_id)));
   request->event.Signal();
 }
 
 void BrowserGpuMemoryBufferManager::CreateGpuMemoryBufferOnIO(
-    const CreateDelegate& create_delegate,
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
+    gpu::SurfaceHandle surface_handle,
     int client_id,
-    bool reused_gpu_process,
     const CreateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
-  if (!host) {
-    host = GpuProcessHost::Get();
-    if (!host) {
-      LOG(ERROR) << "Failed to launch GPU process.";
-      callback.Run(gfx::GpuMemoryBufferHandle());
-      return;
-    }
-    gpu_host_id_ = host->host_id();
-    reused_gpu_process = false;
-  } else {
-    if (reused_gpu_process) {
-      // We come here if we retried to create the buffer because of a failure
-      // in GpuMemoryBufferCreatedOnIO, but we ended up with the same process
-      // ID, meaning the failure was not because of a channel error, but
-      // another reason. So fail now.
-      LOG(ERROR) << "Failed to create GpuMemoryBuffer.";
-      callback.Run(gfx::GpuMemoryBufferHandle());
-      return;
-    }
-    reused_gpu_process = true;
-  }
-
   BufferMap& buffers = clients_[client_id];
 
   // Note: Handling of cases where the client is removed before the allocation
   // completes is less subtle if we set the buffer type to EMPTY_BUFFER here
   // and verify that this has not changed when creation completes.
   auto insert_result = buffers.insert(std::make_pair(
       id, BufferInfo(size, gfx::EMPTY_BUFFER, format, usage, 0)));
   if (!insert_result.second) {
     DLOG(ERROR) << "Child process attempted to create a GpuMemoryBuffer with "
                    "an existing ID.";
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
+  GpuProcessHost* host = GpuProcessHost::Get();
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
-  create_delegate.Run(
-      host, id, size, format, usage, client_id,
+  host->CreateGpuMemoryBuffer(
+      id, size, format, usage, client_id, surface_handle,
       base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferCreatedOnIO,
-                 base::Unretained(this), create_delegate, id, client_id,
-                 gpu_host_id_, reused_gpu_process, callback));
+                 base::Unretained(this), id, surface_handle, client_id,
+                 host->host_id(), callback));
 }
 
 void BrowserGpuMemoryBufferManager::GpuMemoryBufferCreatedOnIO(
-    const CreateDelegate& create_delegate,
     gfx::GpuMemoryBufferId id,
+    gpu::SurfaceHandle surface_handle,
     int client_id,
     int gpu_host_id,
-    bool reused_gpu_process,
     const CreateCallback& callback,
-    const gfx::GpuMemoryBufferHandle& handle) {
+    const gfx::GpuMemoryBufferHandle& handle,
+    GpuProcessHost::BufferCreationStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   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;
   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) {
+    if (handle.is_null() &&
+        status == GpuProcessHost::BufferCreationStatus::GPU_HOST_INVALID) {
       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;
       gfx::Size size = buffer_it->second.size;
       gfx::BufferFormat format = buffer_it->second.format;
       gfx::BufferUsage usage = buffer_it->second.usage;
       // Remove the buffer entry and call CreateGpuMemoryBufferOnIO again.
       buffers.erase(buffer_it);
-      CreateGpuMemoryBufferOnIO(create_delegate, id, size, format, usage,
-                                client_id, reused_gpu_process, callback);
+      CreateGpuMemoryBufferOnIO(id, size, format, usage, surface_handle,
+                                client_id, callback);
     } else {
       // Remove the buffer entry and run the allocation callback with an empty
       // handle to indicate failure.
       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
@@ skipping 59 matching lines @@
       format(format),
       usage(usage),
       gpu_host_id(gpu_host_id) {}
 
 BrowserGpuMemoryBufferManager::BufferInfo::BufferInfo(const BufferInfo& other) =
     default;
 
 BrowserGpuMemoryBufferManager::BufferInfo::~BufferInfo() {}
 
 }  // namespace content