Unify graphics buffer format & usage enums for GpuMemoryBuffer & SurfaceFactoryOzone

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"
@@ skipping 73 matching lines @@
   // 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;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNativeGpuMemoryBuffers)) {
     const GpuMemoryBufferFactory::Configuration kNativeConfigurations[] = {
-        {gfx::GpuMemoryBuffer::R_8, gfx::GpuMemoryBuffer::MAP},
-        {gfx::GpuMemoryBuffer::R_8, gfx::GpuMemoryBuffer::PERSISTENT_MAP},
-        {gfx::GpuMemoryBuffer::RGBA_4444, gfx::GpuMemoryBuffer::MAP},
-        {gfx::GpuMemoryBuffer::RGBA_4444, gfx::GpuMemoryBuffer::PERSISTENT_MAP},
-        {gfx::GpuMemoryBuffer::RGBA_8888, gfx::GpuMemoryBuffer::MAP},
-        {gfx::GpuMemoryBuffer::RGBA_8888, gfx::GpuMemoryBuffer::PERSISTENT_MAP},
-        {gfx::GpuMemoryBuffer::BGRA_8888, gfx::GpuMemoryBuffer::MAP},
-        {gfx::GpuMemoryBuffer::BGRA_8888,
-         gfx::GpuMemoryBuffer::PERSISTENT_MAP}};
+        {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}};
     for (auto& configuration : kNativeConfigurations) {
       if (IsGpuMemoryBufferFactoryConfigurationSupported(type, configuration))
         configurations.push_back(configuration);
     }
   }
 
 #if defined(USE_OZONE) || defined(OS_MACOSX)
   const GpuMemoryBufferFactory::Configuration kScanoutConfigurations[] = {
-      {gfx::GpuMemoryBuffer::BGRA_8888, gfx::GpuMemoryBuffer::SCANOUT},
-      {gfx::GpuMemoryBuffer::RGBX_8888, gfx::GpuMemoryBuffer::SCANOUT}};
+      {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::SCANOUT},
+      {gfx::BufferFormat::RGBX_8888, gfx::BufferUsage::SCANOUT}};
   for (auto& configuration : kScanoutConfigurations) {
     if (IsGpuMemoryBufferFactoryConfigurationSupported(type, configuration))
       configurations.push_back(configuration);
   }
 #endif
 
   return configurations;
 }
 
 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,
-                                 gfx::GpuMemoryBuffer::Usage usage,
+                                 gfx::BufferFormat format,
+                                 gfx::BufferUsage usage,
                                  int client_id,
                                  int surface_id)
       : event(true, false),
         size(size),
         format(format),
         usage(usage),
         client_id(client_id),
         surface_id(surface_id) {}
   ~AllocateGpuMemoryBufferRequest() {}
   base::WaitableEvent event;
   gfx::Size size;
-  gfx::GpuMemoryBuffer::Format format;
-  gfx::GpuMemoryBuffer::Usage usage;
+  gfx::BufferFormat format;
+  gfx::BufferUsage usage;
   int client_id;
   int surface_id;
   scoped_ptr<gfx::GpuMemoryBuffer> result;
 };
 
 BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(int gpu_client_id)
     : factory_type_(GetGpuMemoryBufferFactoryType()),
       supported_configurations_(
           GetSupportedGpuMemoryBufferConfigurations(factory_type_)),
       gpu_client_id_(gpu_client_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::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage) {
+    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;
     }
   }
 
   return GL_TEXTURE_2D;
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
-BrowserGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
-    const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage) {
+BrowserGpuMemoryBufferManager::AllocateGpuMemoryBuffer(const gfx::Size& size,
+                                                       gfx::BufferFormat format,
+                                                       gfx::BufferUsage usage) {
   return AllocateGpuMemoryBufferForSurface(size, format, usage, 0);
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForScanout(
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
+    gfx::BufferFormat format,
     int32 surface_id) {
   DCHECK_GT(surface_id, 0);
   return AllocateGpuMemoryBufferForSurface(
-      size, format, gfx::GpuMemoryBuffer::SCANOUT, surface_id);
+      size, format, gfx::BufferUsage::SCANOUT, surface_id);
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage,
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage,
     base::ProcessHandle child_process_handle,
     int child_client_id,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = g_next_gpu_memory_buffer_id.GetNext();
 
   // Use service side allocation if this is a supported configuration.
   if (IsGpuMemoryBufferConfigurationSupported(format, usage)) {
     AllocateGpuMemoryBufferOnIO(new_id, size, format, usage, child_client_id, 0,
@@ skipping 110 matching lines @@
     if (host)
       host->DestroyGpuMemoryBuffer(buffer.first, client_id, 0);
   }
 
   clients_.erase(client_it);
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurface(
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage,
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage,
     int32 surface_id) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AllocateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_,
                                          surface_id);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurfaceOnIO,
           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::AllocateGpuMemoryBufferForSurface");
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   request.event.Wait();
   return request.result.Pass();
 }
 
 bool BrowserGpuMemoryBufferManager::IsGpuMemoryBufferConfigurationSupported(
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage) const {
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage) const {
   for (auto& configuration : supported_configurations_) {
     if (configuration.format == format && configuration.usage == usage)
       return true;
   }
   return false;
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurfaceOnIO(
     AllocateGpuMemoryBufferRequest* request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   gfx::GpuMemoryBufferId new_id = g_next_gpu_memory_buffer_id.GetNext();
 
   // Use service side allocation if this is a supported configuration.
   if (IsGpuMemoryBufferConfigurationSupported(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;
   }
 
   DCHECK(GpuMemoryBufferImplSharedMemory::IsFormatSupported(request->format))
-      << request->format;
+      << static_cast<int>(request->format);
   DCHECK(GpuMemoryBufferImplSharedMemory::IsUsageSupported(request->usage))
-      << request->usage;
+      << static_cast<int>(request->usage);
 
   BufferMap& buffers = clients_[request->client_id];
   DCHECK(buffers.find(new_id) == buffers.end());
 
   // Allocate shared memory buffer as fallback.
   buffers[new_id] = BufferInfo(request->size, gfx::SHARED_MEMORY_BUFFER,
                                request->format, request->usage, 0);
   // Note: Unretained is safe as IO thread is stopped before manager is
   // destroyed.
   request->result = GpuMemoryBufferImplSharedMemory::Create(
@@ skipping 25 matching lines @@
           &GpuMemoryBufferDeleted,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
                      base::Unretained(this), handle.id, request->client_id)));
   request->event.Signal();
 }
 
 void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
-    gfx::GpuMemoryBuffer::Usage usage,
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage,
     int client_id,
     int surface_id,
     bool reused_gpu_process,
     const AllocationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BufferMap& buffers = clients_[client_id];
   DCHECK(buffers.find(id) == buffers.end());
 
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
@@ skipping 70 matching lines @@
     // 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;
       gfx::Size size = buffer_it->second.size;
-      gfx::GpuMemoryBuffer::Format format = buffer_it->second.format;
-      gfx::GpuMemoryBuffer::Usage usage = buffer_it->second.usage;
+      gfx::BufferFormat format = buffer_it->second.format;
+      gfx::BufferUsage usage = buffer_it->second.usage;
       // Remove the buffer entry and call AllocateGpuMemoryBufferOnIO again.
       buffers.erase(buffer_it);
       AllocateGpuMemoryBufferOnIO(id, size, format, usage, client_id,
                                   surface_id, reused_gpu_process, 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());
     }
@@ skipping 31 matching lines @@
   }
 
   GpuProcessHost* host = GpuProcessHost::FromID(buffer_it->second.gpu_host_id);
   if (host)
     host->DestroyGpuMemoryBuffer(id, client_id, sync_point);
 
   buffers.erase(buffer_it);
 }
 
 }  // namespace content