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

content/common/gpu/media/gpu_video_encode_accelerator.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/common/gpu/media/gpu_video_encode_accelerator.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/numerics/safe_math.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.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 "ipc/ipc_message_macros.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
@@ skipping 69 matching lines @@
 
   if (input_visible_size.width() > media::limits::kMaxDimension ||
       input_visible_size.height() > media::limits::kMaxDimension ||
       input_visible_size.GetArea() > media::limits::kMaxCanvas) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
                    "input_visible_size " << input_visible_size.ToString()
                 << " too large";
     return false;
   }
 
-  std::vector<GpuVideoEncodeAccelerator::CreateVEAFp>
-      create_vea_fps = CreateVEAFps();
+  const gpu::GpuPreferences& gpu_preferences =
+      stub_->channel()->gpu_channel_manager()->gpu_preferences();
+
+  std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps =
+      CreateVEAFps(gpu_preferences);
   // Try all possible encoders and use the first successful encoder.
   for (size_t i = 0; i < create_vea_fps.size(); ++i) {
     encoder_ = (*create_vea_fps[i])();
     if (encoder_ && encoder_->Initialize(input_format,
                                          input_visible_size,
                                          output_profile,
                                          initial_bitrate,
                                          this)) {
       input_format_ = input_format;
       input_visible_size_ = input_visible_size;
@@ skipping 48 matching lines @@
 void GpuVideoEncodeAccelerator::OnWillDestroyStub() {
   DCHECK(stub_);
   stub_->channel()->RemoveRoute(host_route_id_);
   stub_->RemoveDestructionObserver(this);
   encoder_.reset();
   delete this;
 }
 
 // static
 gpu::VideoEncodeAcceleratorSupportedProfiles
-GpuVideoEncodeAccelerator::GetSupportedProfiles() {
+GpuVideoEncodeAccelerator::GetSupportedProfiles(
+    const gpu::GpuPreferences& gpu_preferences) {
   media::VideoEncodeAccelerator::SupportedProfiles profiles;
-  std::vector<GpuVideoEncodeAccelerator::CreateVEAFp>
-      create_vea_fps = CreateVEAFps();
+  std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps =
+      CreateVEAFps(gpu_preferences);
 
   for (size_t i = 0; i < create_vea_fps.size(); ++i) {
     scoped_ptr<media::VideoEncodeAccelerator>
         encoder = (*create_vea_fps[i])();
     if (!encoder)
       continue;
     media::VideoEncodeAccelerator::SupportedProfiles vea_profiles =
         encoder->GetSupportedProfiles();
     GpuVideoAcceleratorUtil::InsertUniqueEncodeProfiles(
         vea_profiles, &profiles);
   }
   return GpuVideoAcceleratorUtil::ConvertMediaToGpuEncodeProfiles(profiles);
 }
 
 // static
 std::vector<GpuVideoEncodeAccelerator::CreateVEAFp>
-GpuVideoEncodeAccelerator::CreateVEAFps() {
+GpuVideoEncodeAccelerator::CreateVEAFps(
+    const gpu::GpuPreferences& gpu_preferences) {
   std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps;
+#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateV4L2VEA);
-  create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateVaapiVEA);
-  create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateAndroidVEA);
+#endif
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+  if (!gpu_preferences.disable_vaapi_accelerated_video_encode)
+    create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateVaapiVEA);
+#endif
+#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
+  if (!gpu_preferences.disable_web_rtc_hw_encoding)
+    create_vea_fps.push_back(&GpuVideoEncodeAccelerator::CreateAndroidVEA);
+#endif
   return create_vea_fps;
 }
 
+#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
 // static
 scoped_ptr<media::VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateV4L2VEA() {
   scoped_ptr<media::VideoEncodeAccelerator> encoder;
-#if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
   if (device)
     encoder.reset(new V4L2VideoEncodeAccelerator(device));
-#endif
   return encoder;
 }
+#endif
 
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
 // static
 scoped_ptr<media::VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateVaapiVEA() {
-  scoped_ptr<media::VideoEncodeAccelerator> encoder;
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-  if (!cmd_line->HasSwitch(switches::kDisableVaapiAcceleratedVideoEncode))
-    encoder.reset(new VaapiVideoEncodeAccelerator());
+  return make_scoped_ptr<media::VideoEncodeAccelerator>(
+      new VaapiVideoEncodeAccelerator());
+}
 #endif
-  return encoder;
-}
 
+#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
 // static
 scoped_ptr<media::VideoEncodeAccelerator>
 GpuVideoEncodeAccelerator::CreateAndroidVEA() {
-  scoped_ptr<media::VideoEncodeAccelerator> encoder;
-#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
-  encoder.reset(new AndroidVideoEncodeAccelerator());
+  return make_scoped_ptr<media::VideoEncodeAccelerator>(
+      new AndroidVideoEncodeAccelerator());
+}
 #endif
-  return encoder;
-}
 
 void GpuVideoEncodeAccelerator::OnEncode(
     const AcceleratedVideoEncoderMsg_Encode_Params& params) {
   DVLOG(3) << "GpuVideoEncodeAccelerator::OnEncode: frame_id = "
            << params.frame_id << ", buffer_size=" << params.buffer_size
            << ", force_keyframe=" << params.force_keyframe;
   DCHECK_EQ(media::PIXEL_FORMAT_I420, input_format_);
 
   // Wrap into a SharedMemory in the beginning, so that |params.buffer_handle|
   // is cleaned properly in case of an early return.
@@ skipping 198 matching lines @@
   Send(new AcceleratedVideoEncoderHostMsg_NotifyInputDone(host_route_id_,
                                                           frame_id));
   // Just let |buffers| fall out of scope.
 }
 
 void GpuVideoEncodeAccelerator::Send(IPC::Message* message) {
   stub_->channel()->Send(message);
 }
 
 }  // namespace content