Change effect of flag kDisableAcceleratedVideoDecode to only affect decode

content/renderer/media/renderer_gpu_video_accelerator_factories.cc

 // Copyright 2013 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/renderer/media/renderer_gpu_video_accelerator_factories.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 
 // static
 std::unique_ptr<RendererGpuVideoAcceleratorFactories>
 RendererGpuVideoAcceleratorFactories::Create(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<ui::ContextProviderCommandBuffer>& context_provider,
     bool enable_gpu_memory_buffer_video_frames,
     const cc::BufferToTextureTargetMap& image_texture_targets,
-    bool enable_video_accelerator) {
+    bool enable_video_decode_accelerator) {
   RecordContextProviderPhaseUmaEnum(
       ContextProviderPhase::CONTEXT_PROVIDER_ACQUIRED);
   return base::WrapUnique(new RendererGpuVideoAcceleratorFactories(
       std::move(gpu_channel_host), main_thread_task_runner, task_runner,
       context_provider, enable_gpu_memory_buffer_video_frames,
-      image_texture_targets, enable_video_accelerator));
+      image_texture_targets, enable_video_decode_accelerator));
 }
 
 RendererGpuVideoAcceleratorFactories::RendererGpuVideoAcceleratorFactories(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<ui::ContextProviderCommandBuffer>& context_provider,
     bool enable_gpu_memory_buffer_video_frames,
     const cc::BufferToTextureTargetMap& image_texture_targets,
-    bool enable_video_accelerator)
+    bool enable_video_decode_accelerator)
     : main_thread_task_runner_(main_thread_task_runner),
       task_runner_(task_runner),
       gpu_channel_host_(std::move(gpu_channel_host)),
       context_provider_refptr_(context_provider),
       context_provider_(context_provider.get()),
       enable_gpu_memory_buffer_video_frames_(
           enable_gpu_memory_buffer_video_frames),
       image_texture_targets_(image_texture_targets),
-      video_accelerator_enabled_(enable_video_accelerator),
+      video_decode_accelerator_enabled_(enable_video_decode_accelerator),
       gpu_memory_buffer_manager_(
           RenderThreadImpl::current()->GetGpuMemoryBufferManager()),
       thread_safe_sender_(ChildThreadImpl::current()->thread_safe_sender()) {
   DCHECK(main_thread_task_runner_);
   DCHECK(gpu_channel_host_);
 }
 
 RendererGpuVideoAcceleratorFactories::~RendererGpuVideoAcceleratorFactories() {}
 
 bool RendererGpuVideoAcceleratorFactories::CheckContextLost() {
@@ skipping 12 matching lines @@
       main_thread_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &RendererGpuVideoAcceleratorFactories::ReleaseContextProvider,
               base::Unretained(this)));
     }
   }
   return !context_provider_;
 }
 
-bool RendererGpuVideoAcceleratorFactories::IsGpuVideoAcceleratorEnabled() {
-  return video_accelerator_enabled_;
+bool RendererGpuVideoAcceleratorFactories::
+    IsGpuVideoDecodeAcceleratorEnabled() {
+  return video_decode_accelerator_enabled_;
 }
 
 base::UnguessableToken RendererGpuVideoAcceleratorFactories::GetChannelToken() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (CheckContextLost())
     return base::UnguessableToken();
 
   if (channel_token_.is_empty()) {
     context_provider_->GetCommandBufferProxy()->channel()->Send(
         new GpuCommandBufferMsg_GetChannelToken(&channel_token_));
   }
 
   return channel_token_;
 }
 
 int32_t RendererGpuVideoAcceleratorFactories::GetCommandBufferRouteId() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (CheckContextLost())
     return 0;
   return context_provider_->GetCommandBufferProxy()->route_id();
 }
 
 std::unique_ptr<media::VideoDecodeAccelerator>
 RendererGpuVideoAcceleratorFactories::CreateVideoDecodeAccelerator() {
-  DCHECK(video_accelerator_enabled_);
+  DCHECK(video_decode_accelerator_enabled_);
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (CheckContextLost())
     return nullptr;
 
   return std::unique_ptr<media::VideoDecodeAccelerator>(
       new media::GpuVideoDecodeAcceleratorHost(
           context_provider_->GetCommandBufferProxy()));
 }
 
 std::unique_ptr<media::VideoEncodeAccelerator>
 RendererGpuVideoAcceleratorFactories::CreateVideoEncodeAccelerator() {
-  DCHECK(video_accelerator_enabled_);
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (CheckContextLost())
     return nullptr;
 
   return std::unique_ptr<media::VideoEncodeAccelerator>(
       new media::GpuVideoEncodeAcceleratorHost(
           context_provider_->GetCommandBufferProxy()));
 }
 
 bool RendererGpuVideoAcceleratorFactories::CreateTextures(
@@ skipping 175 matching lines @@
   context_provider_refptr_ = nullptr;
 }
 
 scoped_refptr<ui::ContextProviderCommandBuffer>
 RendererGpuVideoAcceleratorFactories::ContextProviderMainThread() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   return context_provider_refptr_;
 }
 
 }  // namespace content