Add PERSISTENT_MAP usage for GpuMemoryBuffers.

content/browser/gpu/browser_gpu_channel_host_factory.cc

 // Copyright (c) 2012 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_channel_host_factory.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 25 matching lines @@
 
 #if defined(USE_OZONE)
 #include "content/common/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
 #endif
 
 namespace content {
 namespace {
 
 base::LazyInstance<std::set<gfx::GpuMemoryBuffer::Usage>>
     g_enabled_gpu_memory_buffer_usages;
+
+bool IsGpuMemoryBufferFactoryConfigurationSupported(
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage,
+    gfx::GpuMemoryBufferType type) {
+  switch (type) {
+    case gfx::SHARED_MEMORY_BUFFER:
+      // Shared memory buffers must be created in-process.
+      return false;
+#if defined(OS_MACOSX)
+    case gfx::IO_SURFACE_BUFFER:
+      return GpuMemoryBufferFactoryIOSurface::
+          IsGpuMemoryBufferConfigurationSupported(format, usage);
+#endif
+#if defined(OS_ANDROID)
+    case gfx::SURFACE_TEXTURE_BUFFER:
+      return GpuMemoryBufferFactorySurfaceTexture::
+          IsGpuMemoryBufferConfigurationSupported(format, usage);
+#endif
+#if defined(USE_OZONE)
+    case gfx::OZONE_NATIVE_BUFFER:
+      return GpuMemoryBufferFactoryOzoneNativeBuffer::
+          IsGpuMemoryBufferConfigurationSupported(format, usage);
+#endif
+    default:
+      NOTREACHED();
+      return false;
+  }
 }
 
+}  // namespace
+
 BrowserGpuChannelHostFactory* BrowserGpuChannelHostFactory::instance_ = NULL;
 
 struct BrowserGpuChannelHostFactory::CreateRequest {
   CreateRequest(int32 route_id)
       : event(true, false),
         gpu_host_id(0),
         route_id(route_id),
         result(CREATE_COMMAND_BUFFER_FAILED) {}
   ~CreateRequest() {}
   base::WaitableEvent event;
@@ skipping 189 matching lines @@
   g_enabled_gpu_memory_buffer_usages.Get().insert(usage);
 }
 
 // static
 bool BrowserGpuChannelHostFactory::IsGpuMemoryBufferFactoryUsageEnabled(
     gfx::GpuMemoryBuffer::Usage usage) {
   return g_enabled_gpu_memory_buffer_usages.Get().count(usage) != 0;
 }
 
 // static
-uint32 BrowserGpuChannelHostFactory::GetImageTextureTarget() {
-  if (!IsGpuMemoryBufferFactoryUsageEnabled(gfx::GpuMemoryBuffer::MAP))
+uint32 BrowserGpuChannelHostFactory::GetImageTextureTarget(
+    gfx::GpuMemoryBuffer::Format format,
+    gfx::GpuMemoryBuffer::Usage usage) {
+  if (!IsGpuMemoryBufferFactoryUsageEnabled(usage))
     return GL_TEXTURE_2D;
 
   std::vector<gfx::GpuMemoryBufferType> supported_types;
   GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
   DCHECK(!supported_types.empty());
 
-  // The GPU service will always use the preferred type.
+  // The GPU service will always use the preferred type, if the |format| and
+  // |usage| allows.
   gfx::GpuMemoryBufferType type = supported_types[0];
 
+  if (!IsGpuMemoryBufferFactoryConfigurationSupported(format, usage, type))
+    return GL_TEXTURE_2D;
+
   switch (type) {
     case gfx::SURFACE_TEXTURE_BUFFER:
     case gfx::OZONE_NATIVE_BUFFER:
       // 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:
@@ skipping 186 matching lines @@
     host->AddFilter(filter.get());
 }
 
 bool BrowserGpuChannelHostFactory::IsGpuMemoryBufferConfigurationSupported(
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage) {
   // Return early if usage is not enabled.
   if (!IsGpuMemoryBufferFactoryUsageEnabled(usage))
     return false;
 
-  // Preferred type is always used by factory.
   std::vector<gfx::GpuMemoryBufferType> supported_types;
   GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
   DCHECK(!supported_types.empty());
-  switch (supported_types[0]) {
-    case gfx::SHARED_MEMORY_BUFFER:
-      // Shared memory buffers must be created in-process.
-      return false;
-#if defined(OS_MACOSX)
-    case gfx::IO_SURFACE_BUFFER:
-      return GpuMemoryBufferFactoryIOSurface::
-          IsGpuMemoryBufferConfigurationSupported(format, usage);
-#endif
-#if defined(OS_ANDROID)
-    case gfx::SURFACE_TEXTURE_BUFFER:
-      return GpuMemoryBufferFactorySurfaceTexture::
-          IsGpuMemoryBufferConfigurationSupported(format, usage);
-#endif
-#if defined(USE_OZONE)
-    case gfx::OZONE_NATIVE_BUFFER:
-      return GpuMemoryBufferFactoryOzoneNativeBuffer::
-          IsGpuMemoryBufferConfigurationSupported(format, usage);
-#endif
-    default:
-      NOTREACHED();
-      return false;
-  }
+
+  // The GPU service will always use the preferred type, if the |format| and
+  // |usage| allows.
+  gfx::GpuMemoryBufferType type = supported_types[0];
+
+  return IsGpuMemoryBufferFactoryConfigurationSupported(format, usage, type);
 }
 
 void BrowserGpuChannelHostFactory::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage,
     int client_id,
     int32 surface_id,
     const CreateGpuMemoryBufferCallback& callback) {
@@ skipping 47 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CreateGpuMemoryBufferCallbackMap::iterator iter =
       create_gpu_memory_buffer_requests_.find(request_id);
   DCHECK(iter != create_gpu_memory_buffer_requests_.end());
   iter->second.Run(handle);
   create_gpu_memory_buffer_requests_.erase(iter);
 }
 
 }  // namespace content