Pass texture target for GpuMemoryBuffers VideoFrames textures.

VideoFrames created from GpuMemoryBuffer via CreateImageCHROMIUM must
use different texture targets depending on the underlying GpuMemoryBuffer
implementations (e.g: IOSurfaces require GL_RECTANGLE).

This patch makes sure to compute the right texture target for video
frames in the browser process and passes it to the renderer process
using a command line flag.

BUG=

Review URL: https://codereview.chromium.org/1182273014

Cr-Commit-Position: refs/heads/master@{#334646}

11 files changed, 64 insertions, 28 deletions

diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index 714005e..931e468 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -1137,22 +1137,26 @@ static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
   if (IsForceGpuRasterizationEnabled())
     command_line->AppendSwitch(switches::kForceGpuRasterization);
 
-  // TODO(reveman): We currently assume that the compositor will use BGRA_8888
-  // if it's able to, and RGBA_8888 otherwise. Since we don't know what it will
-  // use we hardcode BGRA_8888 here for now. We should instead
-  // move decisions about GpuMemoryBuffer format to the browser embedder so we
-  // know it here, and pass that decision to the compositor for each usage.
-  // crbug.com/490362
-  gfx::GpuMemoryBuffer::Format format = gfx::GpuMemoryBuffer::BGRA_8888;
-
-  // TODO(danakj): When one-copy uploads support partial update, change this
-  // usage to PERSISTENT_MAP for one-copy.
-  gfx::GpuMemoryBuffer::Usage usage = gfx::GpuMemoryBuffer::MAP;
-
   command_line->AppendSwitchASCII(
-      switches::kUseImageTextureTarget,
+      switches::kContentImageTextureTarget,
       base::UintToString(
-          BrowserGpuChannelHostFactory::GetImageTextureTarget(format, usage)));
+          // TODO(reveman): We currently assume that the compositor will use
+          // BGRA_8888 if it's able to, and RGBA_8888 otherwise. Since we don't
+          // know what it will use we hardcode BGRA_8888 here for now. We should
+          // instead move decisions about GpuMemoryBuffer format to the browser
+          // embedder so we know it here, and pass that decision to the
+          // compositor for each usage.
+          // crbug.com/490362
+          BrowserGpuChannelHostFactory::GetImageTextureTarget(
+              gfx::GpuMemoryBuffer::BGRA_8888,
+              // TODO(danakj): When one-copy supports partial update, change
+              // this usage to PERSISTENT_MAP for one-copy.
+              gfx::GpuMemoryBuffer::MAP)));
+
+  command_line->AppendSwitchASCII(
+      switches::kVideoImageTextureTarget,
+      base::UintToString(BrowserGpuChannelHostFactory::GetImageTextureTarget(
+          gfx::GpuMemoryBuffer::R_8, gfx::GpuMemoryBuffer::MAP)));
 
   // Appending disable-gpu-feature switches due to software rendering list.
   GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
diff --git a/content/public/common/content_switches.cc b/content/public/common/content_switches.cc
index f49c053..5ee831a 100644
--- a/content/public/common/content_switches.cc
+++ b/content/public/common/content_switches.cc
@@ -831,8 +831,11 @@ const char kUseFakeUIForMediaStream[]     = "use-fake-ui-for-media-stream";
 // Enable native GPU memory buffer support when available.
 const char kEnableNativeGpuMemoryBuffers[] = "enable-native-gpu-memory-buffers";
 
-// Overrides the default texture target used with CHROMIUM_image extension.
-const char kUseImageTextureTarget[] = "use-image-texture-target";
+// Texture target for CHROMIUM_image backed content textures.
+const char kContentImageTextureTarget[] = "content-image-texture-target";
+
+// Texture target for CHROMIUM_image backed video frame textures.
+const char kVideoImageTextureTarget[] = "video-image-texture-target";
 
 // Set when Chromium should use a mobile user agent.
 const char kUseMobileUserAgent[] = "use-mobile-user-agent";
diff --git a/content/public/common/content_switches.h b/content/public/common/content_switches.h
index 89a5c2c..0ce8d12 100644
--- a/content/public/common/content_switches.h
+++ b/content/public/common/content_switches.h
@@ -227,7 +227,8 @@ CONTENT_EXPORT extern const char kTraceUploadURL[];
 CONTENT_EXPORT extern const char kUIPrioritizeInGpuProcess[];
 CONTENT_EXPORT extern const char kUseFakeUIForMediaStream[];
 CONTENT_EXPORT extern const char kEnableNativeGpuMemoryBuffers[];
-CONTENT_EXPORT extern const char kUseImageTextureTarget[];
+CONTENT_EXPORT extern const char kContentImageTextureTarget[];
+CONTENT_EXPORT extern const char kVideoImageTextureTarget[];
 CONTENT_EXPORT extern const char kUseMobileUserAgent[];
 CONTENT_EXPORT extern const char kUseNormalPriorityForTileTaskWorkerThreads[];
 extern const char kUseSurfaces[];
diff --git a/content/renderer/media/renderer_gpu_video_accelerator_factories.cc b/content/renderer/media/renderer_gpu_video_accelerator_factories.cc
index 7ae9ab6..690320d 100644
--- a/content/renderer/media/renderer_gpu_video_accelerator_factories.cc
+++ b/content/renderer/media/renderer_gpu_video_accelerator_factories.cc
@@ -28,10 +28,12 @@ scoped_refptr<RendererGpuVideoAcceleratorFactories>
 RendererGpuVideoAcceleratorFactories::Create(
     GpuChannelHost* gpu_channel_host,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    const scoped_refptr<ContextProviderCommandBuffer>& context_provider) {
+    const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
+    unsigned image_texture_target) {
   scoped_refptr<RendererGpuVideoAcceleratorFactories> factories =
-      new RendererGpuVideoAcceleratorFactories(
-          gpu_channel_host, task_runner, context_provider);
+      new RendererGpuVideoAcceleratorFactories(gpu_channel_host, task_runner,
+                                               context_provider,
+                                               image_texture_target);
   // Post task from outside constructor, since AddRef()/Release() is unsafe from
   // within.
   task_runner->PostTask(
@@ -44,10 +46,12 @@ RendererGpuVideoAcceleratorFactories::Create(
 RendererGpuVideoAcceleratorFactories::RendererGpuVideoAcceleratorFactories(
     GpuChannelHost* gpu_channel_host,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    const scoped_refptr<ContextProviderCommandBuffer>& context_provider)
+    const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
+    unsigned image_texture_target)
     : task_runner_(task_runner),
       gpu_channel_host_(gpu_channel_host),
       context_provider_(context_provider),
+      image_texture_target_(image_texture_target),
       gpu_memory_buffer_manager_(
           ChildThreadImpl::current()->gpu_memory_buffer_manager()),
       thread_safe_sender_(ChildThreadImpl::current()->thread_safe_sender()) {
@@ -211,6 +215,10 @@ bool RendererGpuVideoAcceleratorFactories::IsTextureRGSupported() {
   return context->GetImplementation()->capabilities().texture_rg;
 }
 
+unsigned RendererGpuVideoAcceleratorFactories::ImageTextureTarget() {
+  return image_texture_target_;
+}
+
 gpu::gles2::GLES2Interface*
 RendererGpuVideoAcceleratorFactories::GetGLES2Interface() {
   DCHECK(task_runner_->BelongsToCurrentThread());
diff --git a/content/renderer/media/renderer_gpu_video_accelerator_factories.h b/content/renderer/media/renderer_gpu_video_accelerator_factories.h
index fb002c8..c236f41 100644
--- a/content/renderer/media/renderer_gpu_video_accelerator_factories.h
+++ b/content/renderer/media/renderer_gpu_video_accelerator_factories.h
@@ -46,7 +46,8 @@ class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
   static scoped_refptr<RendererGpuVideoAcceleratorFactories> Create(
       GpuChannelHost* gpu_channel_host,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      const scoped_refptr<ContextProviderCommandBuffer>& context_provider);
+      const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
+      unsigned image_texture_target);
 
   // media::GpuVideoAcceleratorFactories implementation.
   scoped_ptr<media::VideoDecodeAccelerator> CreateVideoDecodeAccelerator()
@@ -69,6 +70,7 @@ class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
       gfx::GpuMemoryBuffer::Usage usage) override;
 
   bool IsTextureRGSupported() override;
+  unsigned ImageTextureTarget() override;
   gpu::gles2::GLES2Interface* GetGLES2Interface() override;
   scoped_ptr<base::SharedMemory> CreateSharedMemory(size_t size) override;
   scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override;
@@ -83,7 +85,8 @@ class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
   RendererGpuVideoAcceleratorFactories(
       GpuChannelHost* gpu_channel_host,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      const scoped_refptr<ContextProviderCommandBuffer>& context_provider);
+      const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
+      unsigned image_texture_target);
   ~RendererGpuVideoAcceleratorFactories() override;
 
   // Helper to bind |context_provider| to the |task_runner_| thread after
@@ -98,6 +101,7 @@ class CONTENT_EXPORT RendererGpuVideoAcceleratorFactories
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<GpuChannelHost> gpu_channel_host_;
   scoped_refptr<ContextProviderCommandBuffer> context_provider_;
+  const unsigned image_texture_target_;
   scoped_ptr<GLHelper> gl_helper_;
   gpu::GpuMemoryBufferManager* const gpu_memory_buffer_manager_;
 
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index ebd6fde..481d5ba 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -599,7 +599,7 @@ void RenderThreadImpl::Init() {
 #endif
 
   std::string image_texture_target_string =
-      command_line.GetSwitchValueASCII(switches::kUseImageTextureTarget);
+      command_line.GetSwitchValueASCII(switches::kContentImageTextureTarget);
   bool parsed_image_texture_target = base::StringToUint(
       image_texture_target_string, &use_image_texture_target_);
   DCHECK(parsed_image_texture_target);
@@ -1290,8 +1290,15 @@ RenderThreadImpl::GetGpuFactories() {
     }
   }
   if (gpu_va_context_provider_.get()) {
+    std::string image_texture_target_string =
+        cmd_line->GetSwitchValueASCII(switches::kContentImageTextureTarget);
+    unsigned image_texture_target = 0;
+    bool parsed_image_texture_target =
+        base::StringToUint(image_texture_target_string, &image_texture_target);
+    DCHECK(parsed_image_texture_target);
     gpu_factories = RendererGpuVideoAcceleratorFactories::Create(
-        gpu_channel_host.get(), media_task_runner, gpu_va_context_provider_);
+        gpu_channel_host.get(), media_task_runner, gpu_va_context_provider_,
+        image_texture_target);
   }
   return gpu_factories;
 }
diff --git a/content/renderer/render_thread_impl_browsertest.cc b/content/renderer/render_thread_impl_browsertest.cc
index ccff53f..6a06f9e 100644
--- a/content/renderer/render_thread_impl_browsertest.cc
+++ b/content/renderer/render_thread_impl_browsertest.cc
@@ -160,7 +160,7 @@ class RenderThreadImplBrowserTest : public testing::Test {
     base::CommandLine::StringVector old_argv = cmd->argv();
 
     cmd->AppendSwitchASCII(switches::kNumRasterThreads, "1");
-    cmd->AppendSwitchASCII(switches::kUseImageTextureTarget,
+    cmd->AppendSwitchASCII(switches::kContentImageTextureTarget,
                            base::UintToString(GL_TEXTURE_2D));
 
     thread_ = new RenderThreadImplForTest(
diff --git a/media/renderers/gpu_video_accelerator_factories.h b/media/renderers/gpu_video_accelerator_factories.h
index 9782ed18..0c81189d 100644
--- a/media/renderers/gpu_video_accelerator_factories.h
+++ b/media/renderers/gpu_video_accelerator_factories.h
@@ -66,6 +66,7 @@ class MEDIA_EXPORT GpuVideoAcceleratorFactories
       gfx::GpuMemoryBuffer::Format format,
       gfx::GpuMemoryBuffer::Usage usage) = 0;
 
+  virtual unsigned ImageTextureTarget() = 0;
   virtual bool IsTextureRGSupported() = 0;
 
   virtual gpu::gles2::GLES2Interface* GetGLES2Interface() = 0;
diff --git a/media/renderers/mock_gpu_video_accelerator_factories.cc b/media/renderers/mock_gpu_video_accelerator_factories.cc
index 8dda0b2..d4f41a8 100644
--- a/media/renderers/mock_gpu_video_accelerator_factories.cc
+++ b/media/renderers/mock_gpu_video_accelerator_factories.cc
@@ -71,4 +71,8 @@ MockGpuVideoAcceleratorFactories::CreateVideoEncodeAccelerator() {
   return scoped_ptr<VideoEncodeAccelerator>(DoCreateVideoEncodeAccelerator());
 }
 
+unsigned MockGpuVideoAcceleratorFactories::ImageTextureTarget() {
+  return GL_TEXTURE_2D;
+}
+
 }  // namespace media
diff --git a/media/renderers/mock_gpu_video_accelerator_factories.h b/media/renderers/mock_gpu_video_accelerator_factories.h
index f83030c..6eeefa3 100644
--- a/media/renderers/mock_gpu_video_accelerator_factories.h
+++ b/media/renderers/mock_gpu_video_accelerator_factories.h
@@ -49,6 +49,7 @@ class MockGpuVideoAcceleratorFactories : public GpuVideoAcceleratorFactories {
       gfx::GpuMemoryBuffer::Format format,
       gfx::GpuMemoryBuffer::Usage usage) override;
 
+  unsigned ImageTextureTarget() override;
   MOCK_METHOD0(IsTextureRGSupported, bool());
   MOCK_METHOD0(GetGLES2Interface, gpu::gles2::GLES2Interface*());
 
diff --git a/media/video/gpu_memory_buffer_video_frame_pool.cc b/media/video/gpu_memory_buffer_video_frame_pool.cc
index 23a7a94..137a56d 100644
--- a/media/video/gpu_memory_buffer_video_frame_pool.cc
+++ b/media/video/gpu_memory_buffer_video_frame_pool.cc
@@ -32,7 +32,10 @@ class GpuMemoryBufferVideoFramePool::PoolImpl
   // null.
   PoolImpl(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
            const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories)
-      : task_runner_(task_runner), gpu_factories_(gpu_factories) {}
+      : task_runner_(task_runner),
+        gpu_factories_(gpu_factories),
+        texture_target_(gpu_factories_ ? gpu_factories_->ImageTextureTarget()
+                                       : GL_TEXTURE_2D) {}
 
   // Takes a software VideoFrame and returns a VideoFrame backed by native
   // textures if possible.
@@ -100,7 +103,7 @@ class GpuMemoryBufferVideoFramePool::PoolImpl
   // Pool of resources.
   std::list<FrameResources*> resources_pool_;
 
-  unsigned texture_target_ = GL_TEXTURE_2D;
+  const unsigned texture_target_;
   DISALLOW_COPY_AND_ASSIGN(PoolImpl);
 };