[Video Capture] Move static factory logic out of class VideoCaptureDeviceFactory

Moves the existing methods for creating a platform-specific instance of interface
media::VideoCaptureDeviceFactory out of the interface class and into standalone
functions in a separate file.

This is reasonable, because the factory logic does really not belong in the
abstract interface.

This is needed to be able to move the factory logic part and the
VideoCaptureDeviceFactory interface to separate gn targets in the subsequent
CL.

This CL is part of a series, see Design Doc at
https://docs.google.com/document/d/1mYnsZfLBRmbsDpUtfb6C7dzhfw2Kcxg_-uiG_6MnWVQ/edit?usp=sharing

Change-Id: Iddd093c3a8d0b665094ca3ded32ff4c46f592219
Reviewed-on: https://chromium-review.googlesource.com/1139175Reviewed-by: Emircan Uysaler <emircan@chromium.org>
Commit-Queue: Christian Fremerey <chfremer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#576497}

content/browser/renderer_host/media/media_stream_manager.cc

@@ -55,7 +55,7 @@
 #include "media/base/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "media/base/media_switches.h"
-#include "media/capture/video/video_capture_device_factory.h"
+#include "media/capture/video/create_video_capture_device_factory.h"
 #include "media/capture/video/video_capture_system_impl.h"
 #include "services/video_capture/public/uma/video_capture_service_event.h"
 #include "url/gurl.h"
@@ -487,7 +487,7 @@ MediaStreamManager::MediaStreamManager(
           video_capture::uma::BROWSER_USING_LEGACY_CAPTURE);
       video_capture_provider = InProcessVideoCaptureProvider::CreateInstance(
           std::make_unique<media::VideoCaptureSystemImpl>(
-              media::VideoCaptureDeviceFactory::CreateFactory(
+              media::CreateVideoCaptureDeviceFactory(
                   BrowserThread::GetTaskRunnerForThread(BrowserThread::UI))),
           std::move(device_task_runner),
           base::BindRepeating(&SendVideoCaptureLogMessage));

media/capture/BUILD.gn

@@ -93,27 +93,8 @@ source_set("capture_device_specific") {
 component("capture_lib") {
   defines = [ "CAPTURE_IMPLEMENTATION" ]
   sources = [
-    "video/linux/camera_config_chromeos.cc",
-    "video/linux/camera_config_chromeos.h",
-    "video/linux/v4l2_capture_delegate.cc",
-    "video/linux/v4l2_capture_delegate.h",
-    "video/linux/v4l2_capture_device.h",
-    "video/linux/v4l2_capture_device_impl.cc",
-    "video/linux/v4l2_capture_device_impl.h",
-    "video/linux/video_capture_device_chromeos.cc",
-    "video/linux/video_capture_device_chromeos.h",
-    "video/linux/video_capture_device_factory_linux.cc",
-    "video/linux/video_capture_device_factory_linux.h",
-    "video/linux/video_capture_device_linux.cc",
-    "video/linux/video_capture_device_linux.h",
-    "video/mac/video_capture_device_avfoundation_mac.h",
-    "video/mac/video_capture_device_avfoundation_mac.mm",
-    "video/mac/video_capture_device_decklink_mac.h",
-    "video/mac/video_capture_device_decklink_mac.mm",
-    "video/mac/video_capture_device_factory_mac.h",
-    "video/mac/video_capture_device_factory_mac.mm",
-    "video/mac/video_capture_device_mac.h",
-    "video/mac/video_capture_device_mac.mm",
+    "video/create_video_capture_device_factory.cc",
+    "video/create_video_capture_device_factory.h",
     "video/scoped_buffer_pool_reservation.h",
     "video/shared_memory_buffer_tracker.cc",
     "video/shared_memory_buffer_tracker.h",
@@ -137,27 +118,6 @@ component("capture_lib") {
     "video/video_frame_receiver.h",
     "video/video_frame_receiver_on_task_runner.cc",
     "video/video_frame_receiver_on_task_runner.h",
-    "video/win/capability_list_win.cc",
-    "video/win/capability_list_win.h",
-    "video/win/filter_base_win.cc",
-    "video/win/filter_base_win.h",
-    "video/win/metrics.cc",
-    "video/win/metrics.h",
-    "video/win/pin_base_win.cc",
-    "video/win/pin_base_win.h",
-    "video/win/sink_filter_observer_win.h",
-    "video/win/sink_filter_win.cc",
-    "video/win/sink_filter_win.h",
-    "video/win/sink_input_pin_win.cc",
-    "video/win/sink_input_pin_win.h",
-    "video/win/video_capture_device_factory_win.cc",
-    "video/win/video_capture_device_factory_win.h",
-    "video/win/video_capture_device_mf_win.cc",
-    "video/win/video_capture_device_mf_win.h",
-    "video/win/video_capture_device_utils_win.cc",
-    "video/win/video_capture_device_utils_win.h",
-    "video/win/video_capture_device_win.cc",
-    "video/win/video_capture_device_win.h",
     "video_capturer_source.cc",
     "video_capturer_source.h",
   ]
@@ -194,6 +154,16 @@ component("capture_lib") {
   }
 
   if (is_mac) {
+    sources += [
+      "video/mac/video_capture_device_avfoundation_mac.h",
+      "video/mac/video_capture_device_avfoundation_mac.mm",
+      "video/mac/video_capture_device_decklink_mac.h",
+      "video/mac/video_capture_device_decklink_mac.mm",
+      "video/mac/video_capture_device_factory_mac.h",
+      "video/mac/video_capture_device_factory_mac.mm",
+      "video/mac/video_capture_device_mac.h",
+      "video/mac/video_capture_device_mac.mm",
+    ]
     deps += [ "//third_party/decklink" ]
     libs = [
       "AVFoundation.framework",
@@ -206,6 +176,29 @@ component("capture_lib") {
   }
 
   if (is_win) {
+    sources += [
+      "video/win/capability_list_win.cc",
+      "video/win/capability_list_win.h",
+      "video/win/filter_base_win.cc",
+      "video/win/filter_base_win.h",
+      "video/win/metrics.cc",
+      "video/win/metrics.h",
+      "video/win/pin_base_win.cc",
+      "video/win/pin_base_win.h",
+      "video/win/sink_filter_observer_win.h",
+      "video/win/sink_filter_win.cc",
+      "video/win/sink_filter_win.h",
+      "video/win/sink_input_pin_win.cc",
+      "video/win/sink_input_pin_win.h",
+      "video/win/video_capture_device_factory_win.cc",
+      "video/win/video_capture_device_factory_win.h",
+      "video/win/video_capture_device_mf_win.cc",
+      "video/win/video_capture_device_mf_win.h",
+      "video/win/video_capture_device_utils_win.cc",
+      "video/win/video_capture_device_utils_win.h",
+      "video/win/video_capture_device_win.cc",
+      "video/win/video_capture_device_win.h",
+    ]
     deps += [ "//media/base/win" ]
     libs = [
       "mf.lib",
@@ -223,6 +216,25 @@ component("capture_lib") {
     configs += [ "//build/config/compiler:no_size_t_to_int_warning" ]
   }
 
+  # This includes the case of ChromeOS
+  if (is_linux) {
+    sources += [
+      "video/linux/camera_config_chromeos.cc",
+      "video/linux/camera_config_chromeos.h",
+      "video/linux/v4l2_capture_delegate.cc",
+      "video/linux/v4l2_capture_delegate.h",
+      "video/linux/v4l2_capture_device.h",
+      "video/linux/v4l2_capture_device_impl.cc",
+      "video/linux/v4l2_capture_device_impl.h",
+      "video/linux/video_capture_device_chromeos.cc",
+      "video/linux/video_capture_device_chromeos.h",
+      "video/linux/video_capture_device_factory_linux.cc",
+      "video/linux/video_capture_device_factory_linux.h",
+      "video/linux/video_capture_device_linux.cc",
+      "video/linux/video_capture_device_linux.h",
+    ]
+  }
+
   if (is_chromeos) {
     sources += [
       "video/chromeos/camera_3a_controller.cc",

media/capture/video/android/video_capture_device_factory_android.cc

@@ -154,11 +154,4 @@ bool VideoCaptureDeviceFactoryAndroid::IsLegacyOrDeprecatedDevice(
       AttachCurrentThread(), id));
 }
 
-// static
-VideoCaptureDeviceFactory*
-VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  return new VideoCaptureDeviceFactoryAndroid();
-}
-
 }  // namespace media

media/capture/video/chromeos/video_capture_device_factory_chromeos.cc

@@ -6,8 +6,6 @@
 
 #include "base/memory/ptr_util.h"
 #include "media/capture/video/chromeos/camera_hal_dispatcher_impl.h"
-#include "media/capture/video/chromeos/public/cros_features.h"
-#include "media/capture/video/linux/video_capture_device_factory_linux.h"
 
 namespace media {
 
@@ -85,28 +83,4 @@ bool VideoCaptureDeviceFactoryChromeOS::Init() {
   return true;
 }
 
-#if defined(OS_CHROMEOS)
-// static
-VideoCaptureDeviceFactory*
-VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
-    scoped_refptr<base::SingleThreadTaskRunner>
-        task_runner_for_screen_observer) {
-  // On Chrome OS we have to support two use cases:
-  //
-  // 1. For devices that have the camera HAL v3 service running on Chrome OS,
-  //    we use the HAL v3 capture device which VideoCaptureDeviceFactoryChromeOS
-  //    provides.
-  // 2. Existing devices that use UVC cameras need to use the V4L2 capture
-  //    device which VideoCaptureDeviceFacotoryLinux provides; there are also
-  //    some special devices that may never be able to implement a camera HAL
-  //    v3.
-  if (ShouldUseCrosCameraService()) {
-    return new VideoCaptureDeviceFactoryChromeOS(
-        task_runner_for_screen_observer);
-  } else {
-    return new VideoCaptureDeviceFactoryLinux(task_runner_for_screen_observer);
-  }
-}
-#endif
-
 }  // namespace media

media/capture/video/create_video_capture_device_factory.cc

+// Copyright 2018 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/capture/video/create_video_capture_device_factory.h"
+
+#include "base/command_line.h"
+#include "build/build_config.h"
+#include "media/base/media_switches.h"
+#include "media/capture/video/fake_video_capture_device_factory.h"
+#include "media/capture/video/file_video_capture_device_factory.h"
+
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+#include "media/capture/video/linux/video_capture_device_factory_linux.h"
+#elif defined(OS_CHROMEOS)
+#include "media/capture/video/chromeos/public/cros_features.h"
+#include "media/capture/video/chromeos/video_capture_device_factory_chromeos.h"
+#include "media/capture/video/linux/video_capture_device_factory_linux.h"
+#elif defined(OS_WIN)
+#include "media/capture/video/win/video_capture_device_factory_win.h"
+#elif defined(OS_MACOSX)
+#include "media/capture/video/mac/video_capture_device_factory_mac.h"
+#elif defined(OS_ANDROID)
+#include "media/capture/video/android/video_capture_device_factory_android.h"
+#endif
+
+namespace media {
+
+namespace {
+
+std::unique_ptr<VideoCaptureDeviceFactory>
+CreatePlatformSpecificVideoCaptureDeviceFactory(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  return std::make_unique<VideoCaptureDeviceFactoryLinux>(ui_task_runner);
+#elif defined(OS_CHROMEOS)
+  // On Chrome OS we have to support two use cases:
+  //
+  // 1. For devices that have the camera HAL v3 service running on Chrome OS,
+  //    we use the HAL v3 capture device which VideoCaptureDeviceFactoryChromeOS
+  //    provides.
+  // 2. Existing devices that use UVC cameras need to use the V4L2 capture
+  //    device which VideoCaptureDeviceFacotoryLinux provides; there are also
+  //    some special devices that may never be able to implement a camera HAL
+  //    v3.
+  if (ShouldUseCrosCameraService()) {
+    return std::make_unique<VideoCaptureDeviceFactoryChromeOS>(ui_task_runner);
+  } else {
+    return std::make_unique<VideoCaptureDeviceFactoryLinux>(ui_task_runner);
+  }
+#elif defined(OS_WIN)
+  return std::make_unique<VideoCaptureDeviceFactoryWin>();
+#elif defined(OS_MACOSX)
+  return std::make_unique<VideoCaptureDeviceFactoryMac>();
+#elif defined(OS_ANDROID)
+  return std::make_unique<VideoCaptureDeviceFactoryAndroid>();
+#else
+  NOTIMPLEMENTED();
+  return nullptr;
+#endif
+}
+
+}  // anonymous namespace
+
+std::unique_ptr<VideoCaptureDeviceFactory> CreateVideoCaptureDeviceFactory(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  // Use a Fake or File Video Device Factory if the command line flags are
+  // present, otherwise use the normal, platform-dependent, device factory.
+  if (command_line->HasSwitch(switches::kUseFakeDeviceForMediaStream)) {
+    if (command_line->HasSwitch(switches::kUseFileForFakeVideoCapture)) {
+      return std::make_unique<FileVideoCaptureDeviceFactory>();
+    } else {
+      std::vector<FakeVideoCaptureDeviceSettings> config;
+      FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
+          command_line->GetSwitchValueASCII(
+              switches::kUseFakeDeviceForMediaStream),
+          &config);
+      auto result = std::make_unique<FakeVideoCaptureDeviceFactory>();
+      result->SetToCustomDevicesConfig(config);
+      return std::move(result);
+    }
+  } else {
+    // |ui_task_runner| is needed for the Linux ChromeOS factory to retrieve
+    // screen rotations.
+    return CreatePlatformSpecificVideoCaptureDeviceFactory(ui_task_runner);
+  }
+}
+
+}  // namespace media

media/capture/video/create_video_capture_device_factory.h

+// Copyright 2018 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.
+
+#ifndef MEDIA_CAPTURE_VIDEO_CREATE_VIDEO_CAPTURE_DEVICE_FACTORY_H_
+#define MEDIA_CAPTURE_VIDEO_CREATE_VIDEO_CAPTURE_DEVICE_FACTORY_H_
+
+#include <memory>
+
+#include "base/single_thread_task_runner.h"
+#include "media/capture/capture_export.h"
+#include "media/capture/video/video_capture_device_factory.h"
+
+namespace media {
+
+std::unique_ptr<VideoCaptureDeviceFactory> CAPTURE_EXPORT
+CreateVideoCaptureDeviceFactory(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
+
+}  // namespace media
+
+#endif  // MEDIA_CAPTURE_VIDEO_CREATE_VIDEO_CAPTURE_DEVICE_FACTORY_H_

media/capture/video/linux/video_capture_device_factory_linux.cc

@@ -344,13 +344,4 @@ void VideoCaptureDeviceFactoryLinux::GetSupportedFormatsForV4L2BufferType(
   }
 }
 
-#if !defined(OS_CHROMEOS)
-// static
-VideoCaptureDeviceFactory*
-VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  return new VideoCaptureDeviceFactoryLinux(ui_task_runner);
-}
-#endif
-
 }  // namespace media

media/capture/video/mac/video_capture_device_factory_mac.mm

@@ -120,11 +120,4 @@ void VideoCaptureDeviceFactoryMac::GetSupportedFormats(
   }
 }
 
-// static
-VideoCaptureDeviceFactory*
-VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  return new VideoCaptureDeviceFactoryMac();
-}
-
 }  // namespace media

media/capture/video/video_capture_device_factory.cc

@@ -14,53 +14,12 @@
 
 namespace media {
 
-// static
-std::unique_ptr<VideoCaptureDeviceFactory>
-VideoCaptureDeviceFactory::CreateFactory(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  // Use a Fake or File Video Device Factory if the command line flags are
-  // present, otherwise use the normal, platform-dependent, device factory.
-  if (command_line->HasSwitch(switches::kUseFakeDeviceForMediaStream)) {
-    if (command_line->HasSwitch(switches::kUseFileForFakeVideoCapture)) {
-      return std::unique_ptr<VideoCaptureDeviceFactory>(
-          new FileVideoCaptureDeviceFactory());
-    } else {
-      std::vector<FakeVideoCaptureDeviceSettings> config;
-      FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
-          command_line->GetSwitchValueASCII(
-              switches::kUseFakeDeviceForMediaStream),
-          &config);
-      auto result = std::make_unique<FakeVideoCaptureDeviceFactory>();
-      result->SetToCustomDevicesConfig(config);
-      return std::move(result);
-    }
-  } else {
-    // |ui_task_runner| is needed for the Linux ChromeOS factory to retrieve
-    // screen rotations.
-    return std::unique_ptr<VideoCaptureDeviceFactory>(
-        CreateVideoCaptureDeviceFactory(ui_task_runner));
-  }
-}
-
 VideoCaptureDeviceFactory::VideoCaptureDeviceFactory() {
   thread_checker_.DetachFromThread();
 }
 
 VideoCaptureDeviceFactory::~VideoCaptureDeviceFactory() = default;
 
-#if !defined(OS_MACOSX) && !defined(OS_LINUX) && !defined(OS_ANDROID) && \
-    !defined(OS_WIN)
-// static
-VideoCaptureDeviceFactory*
-VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  NOTIMPLEMENTED();
-  return NULL;
-}
-#endif
-
 void VideoCaptureDeviceFactory::GetCameraLocationsAsync(
     std::unique_ptr<VideoCaptureDeviceDescriptors> device_descriptors,
     DeviceDescriptorsCallback result_callback) {

media/capture/video/video_capture_device_factory.h

@@ -34,9 +34,6 @@ using MojoJpegEncodeAcceleratorFactoryCB =
 // crbug.com/665065
 class CAPTURE_EXPORT VideoCaptureDeviceFactory {
  public:
-  static std::unique_ptr<VideoCaptureDeviceFactory> CreateFactory(
-      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
-
   VideoCaptureDeviceFactory();
   virtual ~VideoCaptureDeviceFactory();
 
@@ -73,9 +70,6 @@ class CAPTURE_EXPORT VideoCaptureDeviceFactory {
   base::ThreadChecker thread_checker_;
 
  private:
-  static VideoCaptureDeviceFactory* CreateVideoCaptureDeviceFactory(
-      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
-
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureDeviceFactory);
 };
 

media/capture/video/video_capture_device_unittest.cc

@@ -21,7 +21,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
-#include "media/capture/video/video_capture_device_factory.h"
+#include "media/capture/video/create_video_capture_device_factory.h"
 #include "media/capture/video_capture_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -300,8 +300,8 @@ class VideoCaptureDeviceTest
         base::DoNothing::Repeatedly<
             media::mojom::JpegEncodeAcceleratorRequest>());
 #endif
-    video_capture_device_factory_ = VideoCaptureDeviceFactory::CreateFactory(
-        base::ThreadTaskRunnerHandle::Get());
+    video_capture_device_factory_ =
+        CreateVideoCaptureDeviceFactory(base::ThreadTaskRunnerHandle::Get());
   }
 
   void SetUp() override {

media/capture/video/win/video_capture_device_factory_win.cc

@@ -753,11 +753,4 @@ void VideoCaptureDeviceFactoryWin::GetSupportedFormats(
   GetApiSpecificSupportedFormats(device, formats);
 }
 
-// static
-VideoCaptureDeviceFactory*
-VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  return new VideoCaptureDeviceFactoryWin();
-}
-
 }  // namespace media

services/video_capture/device_factory_provider_impl.cc

@@ -6,6 +6,7 @@
 
 #include "base/task_scheduler/post_task.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "media/capture/video/create_video_capture_device_factory.h"
 #include "media/capture/video/fake_video_capture_device_factory.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video/video_capture_buffer_tracker.h"
@@ -110,7 +111,7 @@ void DeviceFactoryProviderImpl::LazyInitializeDeviceFactory() {
   // happen on a "UI thread equivalent", e.g. obtaining screen rotation on
   // Chrome OS.
   std::unique_ptr<media::VideoCaptureDeviceFactory> media_device_factory =
-      media::VideoCaptureDeviceFactory::CreateFactory(
+      media::CreateVideoCaptureDeviceFactory(
           base::ThreadTaskRunnerHandle::Get());
   auto video_capture_system = std::make_unique<media::VideoCaptureSystemImpl>(
       std::move(media_device_factory));