Rename media::GpuVideoDecodeAcceleratorFactoryImpl to media::GpuVideoDecodeAcceleratorFactory

media/gpu/gpu_video_decode_accelerator_factory.cc

 // Copyright 2016 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 "media/gpu/gpu_video_decode_accelerator_factory_impl.h"
+#include "media/gpu/gpu_video_decode_accelerator_factory.h"
 
 #include "base/memory/ptr_util.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "media/gpu/gpu_video_accelerator_util.h"
 #include "media/gpu/media_gpu_export.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #elif defined(OS_MACOSX)
 #include "media/gpu/vt_video_decode_accelerator_mac.h"
 #elif defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
 #include "media/gpu/v4l2_device.h"
 #include "media/gpu/v4l2_slice_video_decode_accelerator.h"
 #include "media/gpu/v4l2_video_decode_accelerator.h"
 #include "ui/gl/gl_surface_egl.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_video_decode_accelerator.h"
 #include "ui/gl/gl_implementation.h"
 #endif
 #elif defined(OS_ANDROID)
 #include "media/gpu/android_video_decode_accelerator.h"
 #endif
 
 namespace media {
 
 // static
-MEDIA_GPU_EXPORT std::unique_ptr<GpuVideoDecodeAcceleratorFactoryImpl>
-GpuVideoDecodeAcceleratorFactoryImpl::Create(
+MEDIA_GPU_EXPORT std::unique_ptr<GpuVideoDecodeAcceleratorFactory>
+GpuVideoDecodeAcceleratorFactory::Create(
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb) {
-  return base::WrapUnique(new GpuVideoDecodeAcceleratorFactoryImpl(
+  return base::WrapUnique(new GpuVideoDecodeAcceleratorFactory(
       get_gl_context_cb, make_context_current_cb, bind_image_cb,
       GetGLES2DecoderCallback()));
 }
 
 // static
-MEDIA_GPU_EXPORT std::unique_ptr<GpuVideoDecodeAcceleratorFactoryImpl>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateWithGLES2Decoder(
+MEDIA_GPU_EXPORT std::unique_ptr<GpuVideoDecodeAcceleratorFactory>
+GpuVideoDecodeAcceleratorFactory::CreateWithGLES2Decoder(
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb,
     const GetGLES2DecoderCallback& get_gles2_decoder_cb) {
-  return base::WrapUnique(new GpuVideoDecodeAcceleratorFactoryImpl(
+  return base::WrapUnique(new GpuVideoDecodeAcceleratorFactory(
       get_gl_context_cb, make_context_current_cb, bind_image_cb,
       get_gles2_decoder_cb));
 }
 
 // static
-MEDIA_GPU_EXPORT std::unique_ptr<GpuVideoDecodeAcceleratorFactoryImpl>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateWithNoGL() {
+MEDIA_GPU_EXPORT std::unique_ptr<GpuVideoDecodeAcceleratorFactory>
+GpuVideoDecodeAcceleratorFactory::CreateWithNoGL() {
   return Create(GetGLContextCallback(), MakeGLContextCurrentCallback(),
                 BindGLImageCallback());
 }
 
 // static
 MEDIA_GPU_EXPORT gpu::VideoDecodeAcceleratorCapabilities
-GpuVideoDecodeAcceleratorFactoryImpl::GetDecoderCapabilities(
+GpuVideoDecodeAcceleratorFactory::GetDecoderCapabilities(
     const gpu::GpuPreferences& gpu_preferences) {
   VideoDecodeAccelerator::Capabilities capabilities;
   if (gpu_preferences.disable_accelerated_video_decode)
     return gpu::VideoDecodeAcceleratorCapabilities();
 
-  // Query VDAs for their capabilities and construct a set of supported
-  // profiles for current platform. This must be done in the same order as in
-  // CreateVDA(), as we currently preserve additional capabilities (such as
-  // resolutions supported) only for the first VDA supporting the given codec
-  // profile (instead of calculating a superset).
-  // TODO(posciak,henryhsu): improve this so that we choose a superset of
-  // resolutions and other supported profile parameters.
+// Query VDAs for their capabilities and construct a set of supported

[Pawel Osciak, 2016/07/26 00:57:26]

I've always been wondering about this, but should the comment rather be aligned
to the current code indent (one to the right) to which it refers, as it was
before, not the preprocessor macro?

+// profiles for current platform. This must be done in the same order as in
+// CreateVDA(), as we currently preserve additional capabilities (such as
+// resolutions supported) only for the first VDA supporting the given codec
+// profile (instead of calculating a superset).
+// TODO(posciak,henryhsu): improve this so that we choose a superset of
+// resolutions and other supported profile parameters.
 #if defined(OS_WIN)
   capabilities.supported_profiles =
       DXVAVideoDecodeAccelerator::GetSupportedProfiles();
 #elif defined(OS_CHROMEOS)
   VideoDecodeAccelerator::SupportedProfiles vda_profiles;
 #if defined(USE_V4L2_CODEC)
   vda_profiles = V4L2VideoDecodeAccelerator::GetSupportedProfiles();
   GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(
       vda_profiles, &capabilities.supported_profiles);
   vda_profiles = V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles();
@@ skipping 10 matching lines @@
       VTVideoDecodeAccelerator::GetSupportedProfiles();
 #elif defined(OS_ANDROID)
   capabilities =
       AndroidVideoDecodeAccelerator::GetCapabilities(gpu_preferences);
 #endif
   return GpuVideoAcceleratorUtil::ConvertMediaToGpuDecodeCapabilities(
       capabilities);
 }
 
 MEDIA_GPU_EXPORT std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateVDA(
+GpuVideoDecodeAcceleratorFactory::CreateVDA(
     VideoDecodeAccelerator::Client* client,
     const VideoDecodeAccelerator::Config& config,
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (gpu_preferences.disable_accelerated_video_decode)
     return nullptr;
 
   // Array of Create..VDA() function pointers, potentially usable on current
   // platform. This list is ordered by priority, from most to least preferred,
   // if applicable. This list must be in the same order as the querying order
   // in GetDecoderCapabilities() above.
   using CreateVDAFp = std::unique_ptr<VideoDecodeAccelerator> (
-      GpuVideoDecodeAcceleratorFactoryImpl::*)(
-      const gpu::GpuDriverBugWorkarounds&, const gpu::GpuPreferences&) const;
+      GpuVideoDecodeAcceleratorFactory::*)(const gpu::GpuDriverBugWorkarounds&,
+                                           const gpu::GpuPreferences&) const;
   const CreateVDAFp create_vda_fps[] = {
 #if defined(OS_WIN)
-    &GpuVideoDecodeAcceleratorFactoryImpl::CreateDXVAVDA,
+    &GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA,
 #endif
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
-    &GpuVideoDecodeAcceleratorFactoryImpl::CreateV4L2VDA,
-    &GpuVideoDecodeAcceleratorFactoryImpl::CreateV4L2SVDA,
+    &GpuVideoDecodeAcceleratorFactory::CreateV4L2VDA,
+    &GpuVideoDecodeAcceleratorFactory::CreateV4L2SVDA,
 #endif
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-    &GpuVideoDecodeAcceleratorFactoryImpl::CreateVaapiVDA,
+    &GpuVideoDecodeAcceleratorFactory::CreateVaapiVDA,
 #endif
 #if defined(OS_MACOSX)
-    &GpuVideoDecodeAcceleratorFactoryImpl::CreateVTVDA,
+    &GpuVideoDecodeAcceleratorFactory::CreateVTVDA,
 #endif
 #if defined(OS_ANDROID)
-    &GpuVideoDecodeAcceleratorFactoryImpl::CreateAndroidVDA,
+    &GpuVideoDecodeAcceleratorFactory::CreateAndroidVDA,
 #endif
   };
 
   std::unique_ptr<VideoDecodeAccelerator> vda;
 
   for (const auto& create_vda_function : create_vda_fps) {
     vda = (this->*create_vda_function)(workarounds, gpu_preferences);
     if (vda && vda->Initialize(config, client))
       return vda;
   }
 
   return nullptr;
 }
 
 #if defined(OS_WIN)
 std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateDXVAVDA(
+GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA(
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) const {
   std::unique_ptr<VideoDecodeAccelerator> decoder;
   if (base::win::GetVersion() >= base::win::VERSION_WIN7) {
     DVLOG(0) << "Initializing DXVA HW decoder for windows.";
     decoder.reset(new DXVAVideoDecodeAccelerator(get_gl_context_cb_,
                                                  make_context_current_cb_,
                                                  workarounds, gpu_preferences));
   }
   return decoder;
 }
 #endif
 
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
 std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateV4L2VDA(
+GpuVideoDecodeAcceleratorFactory::CreateV4L2VDA(
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) const {
   std::unique_ptr<VideoDecodeAccelerator> decoder;
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     decoder.reset(new V4L2VideoDecodeAccelerator(
         gl::GLSurfaceEGL::GetHardwareDisplay(), get_gl_context_cb_,
         make_context_current_cb_, device));
   }
   return decoder;
 }
 
 std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateV4L2SVDA(
+GpuVideoDecodeAcceleratorFactory::CreateV4L2SVDA(
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) const {
   std::unique_ptr<VideoDecodeAccelerator> decoder;
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     decoder.reset(new V4L2SliceVideoDecodeAccelerator(
         device, gl::GLSurfaceEGL::GetHardwareDisplay(), get_gl_context_cb_,
         make_context_current_cb_));
   }
   return decoder;
 }
 #endif
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
 std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateVaapiVDA(
+GpuVideoDecodeAcceleratorFactory::CreateVaapiVDA(
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) const {
   std::unique_ptr<VideoDecodeAccelerator> decoder;
   decoder.reset(new VaapiVideoDecodeAccelerator(make_context_current_cb_,
                                                 bind_image_cb_));
   return decoder;
 }
 #endif
 
 #if defined(OS_MACOSX)
 std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateVTVDA(
+GpuVideoDecodeAcceleratorFactory::CreateVTVDA(
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) const {
   std::unique_ptr<VideoDecodeAccelerator> decoder;
   decoder.reset(
       new VTVideoDecodeAccelerator(make_context_current_cb_, bind_image_cb_));
   return decoder;
 }
 #endif
 
 #if defined(OS_ANDROID)
 std::unique_ptr<VideoDecodeAccelerator>
-GpuVideoDecodeAcceleratorFactoryImpl::CreateAndroidVDA(
+GpuVideoDecodeAcceleratorFactory::CreateAndroidVDA(
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences) const {
   std::unique_ptr<VideoDecodeAccelerator> decoder;
   decoder.reset(new AndroidVideoDecodeAccelerator(make_context_current_cb_,
                                                   get_gles2_decoder_cb_));
   return decoder;
 }
 #endif
 
-GpuVideoDecodeAcceleratorFactoryImpl::GpuVideoDecodeAcceleratorFactoryImpl(
+GpuVideoDecodeAcceleratorFactory::GpuVideoDecodeAcceleratorFactory(
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb,
     const GetGLES2DecoderCallback& get_gles2_decoder_cb)
     : get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
       bind_image_cb_(bind_image_cb),
       get_gles2_decoder_cb_(get_gles2_decoder_cb) {}
 
-GpuVideoDecodeAcceleratorFactoryImpl::~GpuVideoDecodeAcceleratorFactoryImpl() {}
+GpuVideoDecodeAcceleratorFactory::~GpuVideoDecodeAcceleratorFactory() {}
 
 }  // namespace media