Revert of content gpu refactor: get rid of gpu related content switches.

content/common/gpu/media/gpu_video_decode_accelerator.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/common/gpu/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 
 #include "content/common/gpu/gpu_channel.h"
-#include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/media/gpu_video_accelerator_util.h"
 #include "content/common/gpu/media/media_messages.h"
+#include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/command_buffer.h"
-#include "gpu/command_buffer/service/gpu_preferences.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/message_filter.h"
 #include "media/base/limits.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_surface_egl.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
@@ skipping 111 matching lines @@
 }
 
 GpuVideoDecodeAccelerator::~GpuVideoDecodeAccelerator() {
   // This class can only be self-deleted from OnWillDestroyStub(), which means
   // the VDA has already been destroyed in there.
   DCHECK(!video_decode_accelerator_);
 }
 
 // static
 gpu::VideoDecodeAcceleratorCapabilities
-GpuVideoDecodeAccelerator::GetCapabilities(
-    const gpu::GpuPreferences& gpu_preferences) {
+GpuVideoDecodeAccelerator::GetCapabilities() {
   media::VideoDecodeAccelerator::Capabilities capabilities;
-  if (gpu_preferences.disable_accelerated_video_decode)
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
     return gpu::VideoDecodeAcceleratorCapabilities();
 
   // Query supported profiles for each VDA. The order of querying VDAs should
   // be the same as the order of initializing VDAs. Then the returned profile
   // can be initialized by corresponding VDA successfully.
 #if defined(OS_WIN)
   capabilities.supported_profiles =
       DXVAVideoDecodeAccelerator::GetSupportedProfiles();
 #elif defined(OS_CHROMEOS)
   media::VideoDecodeAccelerator::SupportedProfiles vda_profiles;
@@ skipping 153 matching lines @@
 
 bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
   if (filter_ && io_task_runner_->BelongsToCurrentThread())
     return filter_->SendOnIOThread(message);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   return stub_->channel()->Send(message);
 }
 
 bool GpuVideoDecodeAccelerator::Initialize(
     const media::VideoDecodeAccelerator::Config& config) {
-  const gpu::GpuPreferences& gpu_preferences =
-      stub_->channel()->gpu_channel_manager()->gpu_preferences();
-  if (gpu_preferences.disable_accelerated_video_decode)
-    return false;
-
   DCHECK(!video_decode_accelerator_);
 
   if (!stub_->channel()->AddRoute(host_route_id_, stub_->stream_id(), this)) {
     DLOG(ERROR) << "Initialize(): failed to add route";
     return false;
   }
 
 #if !defined(OS_WIN)
   // Ensure we will be able to get a GL context at all before initializing
   // non-Windows VDAs.
   if (!make_context_current_.Run()) {
     return false;
   }
 #endif
 
   // Array of Create..VDA() function pointers, maybe applicable to the current
   // platform. This list is ordered by priority of use and it should be the
   // same as the order of querying supported profiles of VDAs.
   const GpuVideoDecodeAccelerator::CreateVDAFp create_vda_fps[] = {
-#if defined(OS_WIN)
-    &GpuVideoDecodeAccelerator::CreateDXVAVDA,
-#endif
-#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
-    &GpuVideoDecodeAccelerator::CreateV4L2VDA,
-    &GpuVideoDecodeAccelerator::CreateV4L2SliceVDA,
-#endif
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-    &GpuVideoDecodeAccelerator::CreateVaapiVDA,
-#endif
-#if defined(OS_MACOSX)
-    &GpuVideoDecodeAccelerator::CreateVTVDA,
-#endif
-#if !defined(OS_CHROMEOS) && defined(USE_OZONE)
-    &GpuVideoDecodeAccelerator::CreateOzoneVDA,
-#endif
-#if defined(OS_ANDROID)
-    &GpuVideoDecodeAccelerator::CreateAndroidVDA,
-#endif
-  };
+      &GpuVideoDecodeAccelerator::CreateDXVAVDA,
+      &GpuVideoDecodeAccelerator::CreateV4L2VDA,
+      &GpuVideoDecodeAccelerator::CreateV4L2SliceVDA,
+      &GpuVideoDecodeAccelerator::CreateVaapiVDA,
+      &GpuVideoDecodeAccelerator::CreateVTVDA,
+      &GpuVideoDecodeAccelerator::CreateOzoneVDA,
+      &GpuVideoDecodeAccelerator::CreateAndroidVDA};
 
   for (const auto& create_vda_function : create_vda_fps) {
     video_decode_accelerator_ = (this->*create_vda_function)();
     if (!video_decode_accelerator_ ||
         !video_decode_accelerator_->Initialize(config, this))
       continue;
 
     if (video_decode_accelerator_->CanDecodeOnIOThread()) {
       filter_ = new MessageFilter(this, host_route_id_);
       stub_->channel()->AddFilter(filter_.get());
     }
     return true;
   }
   video_decode_accelerator_.reset();
   LOG(ERROR) << "HW video decode not available for profile " << config.profile
              << (config.is_encrypted ? " with encryption" : "");
   return false;
 }
 
-#if defined(OS_WIN)
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateDXVAVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
-  const gpu::GpuPreferences& gpu_preferences =
-      stub_->channel()->gpu_channel_manager()->gpu_preferences();
+#if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN7) {
     DVLOG(0) << "Initializing DXVA HW decoder for windows.";
-    decoder.reset(new DXVAVideoDecodeAccelerator(
-        make_context_current_, stub_->decoder()->GetGLContext(),
-        gpu_preferences.enable_accelerated_vpx_decode));
+    decoder.reset(new DXVAVideoDecodeAccelerator(make_context_current_,
+        stub_->decoder()->GetGLContext()));
   } else {
     NOTIMPLEMENTED() << "HW video decode acceleration not available.";
   }
+#endif
   return decoder;
 }
-#endif
 
-#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateV4L2VDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     decoder.reset(new V4L2VideoDecodeAccelerator(
         gfx::GLSurfaceEGL::GetHardwareDisplay(),
         stub_->decoder()->GetGLContext()->GetHandle(),
         weak_factory_for_io_.GetWeakPtr(),
         make_context_current_,
         device,
         io_task_runner_));
   }
+#endif
   return decoder;
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateV4L2SliceVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     decoder.reset(new V4L2SliceVideoDecodeAccelerator(
         device,
         gfx::GLSurfaceEGL::GetHardwareDisplay(),
         stub_->decoder()->GetGLContext()->GetHandle(),
         weak_factory_for_io_.GetWeakPtr(),
         make_context_current_,
         io_task_runner_));
   }
+#endif
   return decoder;
 }
-#endif
 
-#if (defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)) || defined(OS_MACOSX)
 void GpuVideoDecodeAccelerator::BindImage(uint32_t client_texture_id,
                                           uint32_t texture_target,
                                           scoped_refptr<gl::GLImage> image) {
   gpu::gles2::GLES2Decoder* command_decoder = stub_->decoder();
   gpu::gles2::TextureManager* texture_manager =
       command_decoder->GetContextGroup()->texture_manager();
   gpu::gles2::TextureRef* ref = texture_manager->GetTexture(client_texture_id);
   if (ref) {
     texture_manager->SetLevelImage(ref, texture_target, 0, image.get(),
                                    gpu::gles2::Texture::BOUND);
   }
 }
-#endif
 
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateVaapiVDA() {
-  return make_scoped_ptr<media::VideoDecodeAccelerator>(
-      new VaapiVideoDecodeAccelerator(
-          make_context_current_,
-          base::Bind(&GpuVideoDecodeAccelerator::BindImage,
-                     base::Unretained(this))));
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+  decoder.reset(new VaapiVideoDecodeAccelerator(
+      make_context_current_, base::Bind(&GpuVideoDecodeAccelerator::BindImage,
+                                        base::Unretained(this))));
+#endif
+  return decoder;
 }
-#endif
 
-#if defined(OS_MACOSX)
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateVTVDA() {
-  return make_scoped_ptr<media::VideoDecodeAccelerator>(
-      new VTVideoDecodeAccelerator(
-          make_context_current_,
-          base::Bind(&GpuVideoDecodeAccelerator::BindImage,
-                     base::Unretained(this))));
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_MACOSX)
+  decoder.reset(new VTVideoDecodeAccelerator(
+      make_context_current_, base::Bind(&GpuVideoDecodeAccelerator::BindImage,
+                                        base::Unretained(this))));
+#endif
+  return decoder;
 }
-#endif
 
-#if !defined(OS_CHROMEOS) && defined(USE_OZONE)
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateOzoneVDA() {
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if !defined(OS_CHROMEOS) && defined(USE_OZONE)
   media::MediaOzonePlatform* platform =
       media::MediaOzonePlatform::GetInstance();
-  return make_scoped_ptr<media::VideoDecodeAccelerator>(
-      platform->CreateVideoDecodeAccelerator(make_context_current_));
+  decoder.reset(platform->CreateVideoDecodeAccelerator(make_context_current_));
+#endif
+  return decoder;
 }
-#endif
 
-#if defined(OS_ANDROID)
 scoped_ptr<media::VideoDecodeAccelerator>
 GpuVideoDecodeAccelerator::CreateAndroidVDA() {
-  return make_scoped_ptr<media::VideoDecodeAccelerator>(
-      new AndroidVideoDecodeAccelerator(stub_->decoder()->AsWeakPtr(),
-                                        make_context_current_));
+  scoped_ptr<media::VideoDecodeAccelerator> decoder;
+#if defined(OS_ANDROID)
+  decoder.reset(new AndroidVideoDecodeAccelerator(stub_->decoder()->AsWeakPtr(),
+                                                  make_context_current_));
+#endif
+  return decoder;
 }
-#endif
 
 void GpuVideoDecodeAccelerator::OnSetCdm(int cdm_id) {
   DCHECK(video_decode_accelerator_);
   video_decode_accelerator_->SetCdm(cdm_id);
 }
 
 void GpuVideoDecodeAccelerator::CallOrPostNotifyError(
     media::VideoDecodeAccelerator::Error error) {
   if (child_task_runner_->BelongsToCurrentThread()) {
     NotifyError(error);
@@ skipping 123 matching lines @@
   scoped_refptr<gpu::gles2::TextureRef> texture_ref = it->second;
   GLenum target = texture_ref->texture()->target();
   gpu::gles2::TextureManager* texture_manager =
       stub_->decoder()->GetContextGroup()->texture_manager();
   DCHECK(!texture_ref->texture()->IsLevelCleared(target, 0));
   texture_manager->SetLevelCleared(texture_ref.get(), target, 0, true);
   uncleared_textures_.erase(it);
 }
 
 }  // namespace content