content: Use type-parameterized tests for GpuMemoryBuffer implementations.

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/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/generic_shared_memory_id_generator.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
-#include "content/common/gpu/gpu_memory_buffer_factory_shared_memory.h"
+#include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_MACOSX)
 #include "content/common/gpu/gpu_memory_buffer_factory_io_surface.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "content/common/gpu/gpu_memory_buffer_factory_surface_texture.h"
 #endif
 
 #if defined(USE_OZONE)
 #include "content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h"
 #endif
 
 namespace content {
 namespace {
 
 void GpuMemoryBufferDeleted(
     scoped_refptr<base::SingleThreadTaskRunner> destruction_task_runner,
     const GpuMemoryBufferImpl::DestructionCallback& destruction_callback,
     uint32 sync_point) {
   destruction_task_runner->PostTask(
       FROM_HERE, base::Bind(destruction_callback, sync_point));
 }
 
-bool IsGpuMemoryBufferFactoryConfigurationSupported(
-    gfx::GpuMemoryBufferType type,
-    const GpuMemoryBufferFactory::Configuration& configuration) {
-  switch (type) {
+bool IsNativeGpuMemoryBufferFactoryConfigurationSupported(
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage) {
+  switch (GpuMemoryBufferFactory::GetNativeType()) {
     case gfx::SHARED_MEMORY_BUFFER:
-      return GpuMemoryBufferFactorySharedMemory::
-          IsGpuMemoryBufferConfigurationSupported(configuration.format,
-                                                  configuration.usage);
+      return false;
 #if defined(OS_MACOSX)
     case gfx::IO_SURFACE_BUFFER:
       return GpuMemoryBufferFactoryIOSurface::
-          IsGpuMemoryBufferConfigurationSupported(configuration.format,
-                                                  configuration.usage);
+          IsGpuMemoryBufferConfigurationSupported(format, usage);
 #endif
 #if defined(OS_ANDROID)
     case gfx::SURFACE_TEXTURE_BUFFER:
       return GpuMemoryBufferFactorySurfaceTexture::
-          IsGpuMemoryBufferConfigurationSupported(configuration.format,
-                                                  configuration.usage);
+          IsGpuMemoryBufferConfigurationSupported(format, usage);
 #endif
 #if defined(USE_OZONE)
     case gfx::OZONE_NATIVE_PIXMAP:
       return GpuMemoryBufferFactoryOzoneNativePixmap::
-          IsGpuMemoryBufferConfigurationSupported(configuration.format,
-                                                  configuration.usage);
+          IsGpuMemoryBufferConfigurationSupported(format, usage);
 #endif
     default:
       NOTREACHED();
       return false;
   }
 }
 
-gfx::GpuMemoryBufferType GetGpuMemoryBufferFactoryType() {
-  std::vector<gfx::GpuMemoryBufferType> supported_types;
-  GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
-  DCHECK(!supported_types.empty());
-
-  // The GPU service will always use the preferred type.
-  return supported_types[0];
-}
-
-std::vector<GpuMemoryBufferFactory::Configuration>
-GetSupportedGpuMemoryBufferConfigurations(gfx::GpuMemoryBufferType type) {
-  std::vector<GpuMemoryBufferFactory::Configuration> configurations;
+GpuMemoryBufferConfigurationSet GetNativeGpuMemoryBufferConfigurations() {
+  GpuMemoryBufferConfigurationSet configurations;
 #if defined(OS_MACOSX)
   bool enable_native_gpu_memory_buffers =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableNativeGpuMemoryBuffers);
 #else
   bool enable_native_gpu_memory_buffers =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNativeGpuMemoryBuffers);
 #endif
 
+#if defined(USE_OZONE) || defined(OS_MACOSX)
+  bool force_native_scanout_formats = true;
+#else
+  bool force_native_scanout_formats = false;
+#endif
+
   // Disable native buffers when using Mesa.
   if (base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kUseGL) == gfx::kGLImplementationOSMesaName) {
     enable_native_gpu_memory_buffers = false;
+    force_native_scanout_formats = false;
   }
 
   if (enable_native_gpu_memory_buffers) {
-    const GpuMemoryBufferFactory::Configuration kNativeConfigurations[] = {
-        {gfx::BufferFormat::R_8, gfx::BufferUsage::MAP},
-        {gfx::BufferFormat::R_8, gfx::BufferUsage::PERSISTENT_MAP},
-        {gfx::BufferFormat::RGBA_4444, gfx::BufferUsage::MAP},
-        {gfx::BufferFormat::RGBA_4444, gfx::BufferUsage::PERSISTENT_MAP},
-        {gfx::BufferFormat::RGBA_8888, gfx::BufferUsage::MAP},
-        {gfx::BufferFormat::RGBA_8888, gfx::BufferUsage::PERSISTENT_MAP},
-        {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::MAP},
-        {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::PERSISTENT_MAP},
-        {gfx::BufferFormat::UYVY_422, gfx::BufferUsage::MAP},
-        {gfx::BufferFormat::UYVY_422, gfx::BufferUsage::PERSISTENT_MAP},
-        {gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferUsage::MAP},
-        {gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferUsage::PERSISTENT_MAP},
-    };
-    for (auto& configuration : kNativeConfigurations) {
-      if (IsGpuMemoryBufferFactoryConfigurationSupported(type, configuration))
-        configurations.push_back(configuration);
+    const gfx::BufferFormat kNativeFormats[] = {
+        gfx::BufferFormat::R_8,       gfx::BufferFormat::RGBA_4444,
+        gfx::BufferFormat::RGBA_8888, gfx::BufferFormat::BGRA_8888,
+        gfx::BufferFormat::UYVY_422,  gfx::BufferFormat::YUV_420_BIPLANAR};
+    const gfx::BufferUsage kNativeUsages[] = {gfx::BufferUsage::MAP,
+                                              gfx::BufferUsage::PERSISTENT_MAP};
+    for (auto& format : kNativeFormats) {
+      for (auto& usage : kNativeUsages) {
+        if (IsNativeGpuMemoryBufferFactoryConfigurationSupported(format, usage))
+          configurations.insert(std::make_pair(format, usage));
+      }
     }
   }
 
-#if defined(USE_OZONE) || defined(OS_MACOSX)
-  const GpuMemoryBufferFactory::Configuration kScanoutConfigurations[] = {
-      {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::SCANOUT},
-      {gfx::BufferFormat::BGRX_8888, gfx::BufferUsage::SCANOUT},
-      {gfx::BufferFormat::UYVY_422, gfx::BufferUsage::SCANOUT},
-      {gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferUsage::SCANOUT},
-  };
-  for (auto& configuration : kScanoutConfigurations) {
-    if (IsGpuMemoryBufferFactoryConfigurationSupported(type, configuration))
-      configurations.push_back(configuration);
+  if (force_native_scanout_formats) {
+    const gfx::BufferFormat kScanoutFormats[] = {
+        gfx::BufferFormat::BGRA_8888, gfx::BufferFormat::BGRX_8888,
+        gfx::BufferFormat::UYVY_422, gfx::BufferFormat::YUV_420_BIPLANAR};
+    for (auto& format : kScanoutFormats) {
+      if (IsNativeGpuMemoryBufferFactoryConfigurationSupported(
+              format, gfx::BufferUsage::SCANOUT)) {
+        configurations.insert(
+            std::make_pair(format, gfx::BufferUsage::SCANOUT));
+      }
+    }
   }
-#endif
 
   return configurations;
 }
 
 BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
 
 }  // namespace
 
 struct BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferRequest {
   AllocateGpuMemoryBufferRequest(const gfx::Size& size,
@@ skipping 13 matching lines @@
   gfx::BufferFormat format;
   gfx::BufferUsage usage;
   int client_id;
   int surface_id;
   scoped_ptr<gfx::GpuMemoryBuffer> result;
 };
 
 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(
     int gpu_client_id,
     uint64_t gpu_client_tracing_id)
-    : factory_type_(GetGpuMemoryBufferFactoryType()),
-      supported_configurations_(
-          GetSupportedGpuMemoryBufferConfigurations(factory_type_)),
+    : 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;
 }
 
 BrowserGpuMemoryBufferManager::~BrowserGpuMemoryBufferManager() {
   g_gpu_memory_buffer_manager = nullptr;
 }
 
 // static
 BrowserGpuMemoryBufferManager* BrowserGpuMemoryBufferManager::current() {
   return g_gpu_memory_buffer_manager;
 }
 
 // static
 uint32 BrowserGpuMemoryBufferManager::GetImageTextureTarget(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
-  gfx::GpuMemoryBufferType type = GetGpuMemoryBufferFactoryType();
-  for (auto& configuration : GetSupportedGpuMemoryBufferConfigurations(type)) {
-    if (configuration.format != format || configuration.usage != usage)
-      continue;
-
-    switch (type) {
-      case gfx::SURFACE_TEXTURE_BUFFER:
-      case gfx::OZONE_NATIVE_PIXMAP:
-        // GPU memory buffers that are shared with the GL using EGLImages
-        // require TEXTURE_EXTERNAL_OES.
-        return GL_TEXTURE_EXTERNAL_OES;
-      case gfx::IO_SURFACE_BUFFER:
-        // IOSurface backed images require GL_TEXTURE_RECTANGLE_ARB.
-        return GL_TEXTURE_RECTANGLE_ARB;
-      default:
-        return GL_TEXTURE_2D;
-    }
+  GpuMemoryBufferConfigurationSet native_configurations =
+      GetNativeGpuMemoryBufferConfigurations();
+  if (native_configurations.find(std::make_pair(format, usage)) ==
+      native_configurations.end()) {
+    return GL_TEXTURE_2D;
   }
 
+  switch (GpuMemoryBufferFactory::GetNativeType()) {
+    case gfx::SURFACE_TEXTURE_BUFFER:
+    case gfx::OZONE_NATIVE_PIXMAP:
+      // GPU memory buffers that are shared with the GL using EGLImages
+      // require TEXTURE_EXTERNAL_OES.
+      return GL_TEXTURE_EXTERNAL_OES;
+    case gfx::IO_SURFACE_BUFFER:
+      // IOSurface backed images require GL_TEXTURE_RECTANGLE_ARB.
+      return GL_TEXTURE_RECTANGLE_ARB;
+    case gfx::SHARED_MEMORY_BUFFER:
+      return GL_TEXTURE_2D;
+    case gfx::EMPTY_BUFFER:
+      NOTREACHED();
+      return GL_TEXTURE_2D;
+  }
+
+  NOTREACHED();
   return GL_TEXTURE_2D;
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBuffer(const gfx::Size& size,
                                                        gfx::BufferFormat format,
                                                        gfx::BufferUsage usage) {
   return AllocateGpuMemoryBufferForSurface(size, format, usage, 0);
 }
 
@@ skipping 10 matching lines @@
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  // Use service side allocation if this is a supported configuration.
-  if (IsGpuMemoryBufferConfigurationSupported(format, usage)) {
+  // Use service side allocation for native configurations.
+  if (IsNativeGpuMemoryBufferConfiguration(format, usage)) {
     AllocateGpuMemoryBufferOnIO(id, size, format, usage, child_client_id, 0,
                                 false, callback);
     return;
   }
 
   // Early out if we cannot fallback to shared memory buffer.
   if (!GpuMemoryBufferImplSharedMemory::IsFormatSupported(format) ||
       !GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage) ||
       !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format)) {
     callback.Run(gfx::GpuMemoryBufferHandle());
@@ skipping 124 matching lines @@
 
   // We're blocking the UI thread, which is generally undesirable.
   TRACE_EVENT0(
       "browser",
       "BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return request.result.Pass();
 }
 
-bool BrowserGpuMemoryBufferManager::IsGpuMemoryBufferConfigurationSupported(
+bool BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBufferConfiguration(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) const {
-  for (auto& configuration : supported_configurations_) {
-    if (configuration.format == format && configuration.usage == usage)
-      return true;
-  }
-  return false;
+  return native_configurations_.find(std::make_pair(format, usage)) !=
+         native_configurations_.end();
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurfaceOnIO(
     AllocateGpuMemoryBufferRequest* request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = content::GetNextGenericSharedMemoryId();
 
-  // Use service side allocation if this is a supported configuration.
-  if (IsGpuMemoryBufferConfigurationSupported(request->format,
-                                              request->usage)) {
+  // 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.
     AllocateGpuMemoryBufferOnIO(
         new_id, request->size, request->format, request->usage,
         request->client_id, request->surface_id, false,
         base::Bind(&BrowserGpuMemoryBufferManager::
                        GpuMemoryBufferAllocatedForSurfaceOnIO,
                    base::Unretained(this), base::Unretained(request)));
     return;
   }
@@ skipping 206 matching lines @@
     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);
 }
 
 }  // namespace content