content: Move type selection logic out of GpuMemoryBufferImpl.

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 "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 namespace {
 
+// Note: To keep things simple this function will only return one out of two
+// types; the preferred GPU memory buffer type or the shared memory type.
+gfx::GpuMemoryBufferType GetPreferredGpuMemoryBufferTypeForConfiguration(
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage) {
+  // First check if this configuration is supported by the preferred type.
+  if (GpuMemoryBufferImpl::IsConfigurationSupported(
+          GpuMemoryBufferImpl::GetPreferredType(), format, usage)) {
+    return GpuMemoryBufferImpl::GetPreferredType();
+  }
+
+  // If configuration is not supported by the preferred type, use shared
+  // memory type if it supports this configuration.
+  if (GpuMemoryBufferImpl::IsConfigurationSupported(
+          gfx::SHARED_MEMORY_BUFFER, format, usage)) {
+    return gfx::SHARED_MEMORY_BUFFER;
+  }
+
+  return gfx::EMPTY_BUFFER;
+}
+
 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
 
 // Global atomic to generate gpu memory buffer unique IDs.
 base::StaticAtomicSequenceNumber g_next_gpu_memory_buffer_id;
 
 }  // namespace
 
 struct BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferRequest {
   AllocateGpuMemoryBufferRequest(const gfx::Size& size,
                                  gfx::GpuMemoryBuffer::Format format,
@@ skipping 52 matching lines @@
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  // Determine what GPU memory buffer type to use and early out if |format| and
+  // |usage| configuration is not supported.
+  gfx::GpuMemoryBufferType type =
+      GetPreferredGpuMemoryBufferTypeForConfiguration(format, usage);
+  if (type == gfx::EMPTY_BUFFER) {
+    callback.Run(gfx::GpuMemoryBufferHandle());
+    return;
+  }
+
   gfx::GpuMemoryBufferId new_id = g_next_gpu_memory_buffer_id.GetNext();
 
   BufferMap& buffers = clients_[child_client_id];
   DCHECK(buffers.find(new_id) == buffers.end());
 
   // Note: Handling of cases where the child process 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 allocation
   // completes.
   buffers[new_id] = gfx::EMPTY_BUFFER;
 
   GpuMemoryBufferImpl::AllocateForChildProcess(
+      type,
       new_id,
       size,
       format,
       usage,
       child_process_handle,
       child_client_id,
       base::Bind(&BrowserGpuMemoryBufferManager::
                      GpuMemoryBufferAllocatedForChildProcess,
                  base::Unretained(this),
                  child_process_handle,
@@ skipping 107 matching lines @@
   // Store the type for this buffer so it can be cleaned up if the child
   // process is removed.
   buffer_it->second = handle.type;
 
   callback.Run(handle);
 }
 
 // static
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO(
     AllocateGpuMemoryBufferRequest* request) {
+

[reveman, 2014/11/11 19:07:45]

hm, this blank line should not be here.

   GpuMemoryBufferImpl::Create(
+      GetPreferredGpuMemoryBufferTypeForConfiguration(

[alexst (slow to review), 2014/11/11 18:49:23]

Should this early out in BrowserGpuMemoryBufferManager::AllocateGpuMemoryBuffer
for consistency? 

If GetPreferredGpuMemoryBufferTypeForConfiguration ever returns EMPTY_BUFFER
here, we'll end up hitting a NOTREACHED in the GpuMemoryBufferImpl.

[reveman, 2014/11/11 19:07:44]

I think we should consider it a browser bug if this ever returns EMPTY_BUFFER.
And I'd rather NOTREACHED than early out for browser bugs.

+          request->format, request->usage),
       g_next_gpu_memory_buffer_id.GetNext(),
       request->size,
       request->format,
       request->usage,
       request->client_id,
       base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferCreatedOnIO,
                  base::Unretained(request)));
 }
 
 // static
 void BrowserGpuMemoryBufferManager::GpuMemoryBufferCreatedOnIO(
     AllocateGpuMemoryBufferRequest* request,
     scoped_ptr<GpuMemoryBufferImpl> buffer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   request->result = buffer.Pass();
   request->event.Signal();
 }
 
 }  // namespace content