Separated DescriptorDeviceProvider from unittest

Now called FakeDeviceProvider, existing separately with exposed header, to allow for reuse elsewhere.
Also moved test dependents into 'test_support', out of unittest target. Cleaner + allows for reuse.

Change-Id: I76ca2f2c6de68bb27cf254907e3d7d9a87518ae1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2368558
Commit-Queue: Clovis PJ <clovispj@google.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Shik Chen <shik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#804739}

media/capture/BUILD.gn

@@ -330,10 +330,16 @@ source_set("test_support") {
   testonly = true
 
   sources = [
+    "video/linux/fake_device_provider.cc",
+    "video/linux/fake_device_provider.h",
+    "video/linux/fake_v4l2_impl.cc",
+    "video/linux/fake_v4l2_impl.h",
     "video/mock_device.cc",
     "video/mock_device.h",
     "video/mock_device_factory.cc",
     "video/mock_device_factory.h",
+    "video/mock_gpu_memory_buffer_manager.cc",
+    "video/mock_gpu_memory_buffer_manager.h",
     "video/mock_video_capture_device_client.cc",
     "video/mock_video_capture_device_client.h",
     "video/mock_video_frame_receiver.cc",
@@ -343,6 +349,8 @@ source_set("test_support") {
   deps = [
     ":capture_lib",
     "//base/test:test_support",
+    "//gpu/command_buffer/client",
+    "//gpu/command_buffer/common:common",
     "//media:test_support",
     "//media/capture/mojom:image_capture",
     "//media/capture/mojom:image_capture_types",
@@ -350,6 +358,21 @@ source_set("test_support") {
     "//ui/gfx:test_support",
   ]
 
+  if (is_chromeos) {
+    sources += [
+      "video/chromeos/mock_camera_module.cc",
+      "video/chromeos/mock_camera_module.h",
+      "video/chromeos/mock_vendor_tag_ops.cc",
+      "video/chromeos/mock_vendor_tag_ops.h",
+      "video/chromeos/mock_video_capture_client.cc",
+      "video/chromeos/mock_video_capture_client.h",
+    ]
+    deps += [
+      "//media/capture/video/chromeos/mojom:cros_camera",
+      "//media/capture/video/chromeos/public",
+    ]
+  }
+
   testonly = true
 }
 
@@ -365,14 +388,10 @@ test("capture_unittests") {
     "video/fake_video_capture_device_unittest.cc",
     "video/file_video_capture_device_unittest.cc",
     "video/linux/camera_config_chromeos_unittest.cc",
-    "video/linux/fake_v4l2_impl.cc",
-    "video/linux/fake_v4l2_impl.h",
     "video/linux/v4l2_capture_delegate_unittest.cc",
     "video/linux/video_capture_device_factory_linux_unittest.cc",
     "video/mac/video_capture_device_factory_mac_unittest.mm",
     "video/mac/video_capture_device_mac_unittest.mm",
-    "video/mock_gpu_memory_buffer_manager.cc",
-    "video/mock_gpu_memory_buffer_manager.h",
     "video/video_capture_device_client_unittest.cc",
     "video/video_capture_device_unittest.cc",
     "video_capture_types_unittest.cc",
@@ -453,12 +472,6 @@ test("capture_unittests") {
       "video/chromeos/camera_device_delegate_unittest.cc",
       "video/chromeos/camera_hal_delegate_unittest.cc",
       "video/chromeos/camera_hal_dispatcher_impl_unittest.cc",
-      "video/chromeos/mock_camera_module.cc",
-      "video/chromeos/mock_camera_module.h",
-      "video/chromeos/mock_vendor_tag_ops.cc",
-      "video/chromeos/mock_vendor_tag_ops.h",
-      "video/chromeos/mock_video_capture_client.cc",
-      "video/chromeos/mock_video_capture_client.h",
       "video/chromeos/request_manager_unittest.cc",
     ]
     deps += [

media/capture/video/linux/fake_device_provider.cc

+// Copyright 2020 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/linux/fake_device_provider.h"
+
+#include <string>
+#include <vector>
+
+#include "media/capture/video/video_capture_device_descriptor.h"
+#include "media/capture/video_capture_types.h"
+
+namespace media {
+
+FakeDeviceProvider::FakeDeviceProvider() = default;
+FakeDeviceProvider::~FakeDeviceProvider() = default;
+
+void FakeDeviceProvider::AddDevice(
+    const VideoCaptureDeviceDescriptor& descriptor) {
+  descriptors_.emplace_back(descriptor);
+}
+
+void FakeDeviceProvider::GetDeviceIds(
+    std::vector<std::string>* target_container) {
+  for (const auto& entry : descriptors_) {
+    target_container->emplace_back(entry.device_id);
+  }
+}
+
+std::string FakeDeviceProvider::GetDeviceModelId(const std::string& device_id) {
+  auto iter =
+      std::find_if(descriptors_.begin(), descriptors_.end(),
+                   [&device_id](const VideoCaptureDeviceDescriptor& val) {
+                     return val.device_id == device_id;
+                   });
+  if (iter == descriptors_.end())
+    CHECK(false) << "Unknown device_id " << device_id;
+
+  return iter->model_id;
+}
+
+std::string FakeDeviceProvider::GetDeviceDisplayName(
+    const std::string& device_id) {
+  auto iter =
+      std::find_if(descriptors_.begin(), descriptors_.end(),
+                   [&device_id](const VideoCaptureDeviceDescriptor& val) {
+                     return val.device_id == device_id;
+                   });
+  if (iter == descriptors_.end())
+    CHECK(false) << "Unknown device_id " << device_id;
+
+  return iter->display_name();
+}
+
+VideoFacingMode FakeDeviceProvider::GetCameraFacing(
+    const std::string& device_id,
+    const std::string& model_id) {
+  return MEDIA_VIDEO_FACING_NONE;
+}
+
+int FakeDeviceProvider::GetOrientation(const std::string& device_id,
+                                       const std::string& model_id) {
+  return 0;
+}
+
+}  // namespace media

media/capture/video/linux/fake_device_provider.h

+// Copyright 2020 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_LINUX_FAKE_DEVICE_PROVIDER_H_
+#define MEDIA_CAPTURE_VIDEO_LINUX_FAKE_DEVICE_PROVIDER_H_
+
+#include <string>
+#include <vector>
+
+#include "media/capture/video/linux/video_capture_device_factory_linux.h"
+#include "media/capture/video/video_capture_device_descriptor.h"
+#include "media/capture/video_capture_types.h"
+
+namespace media {
+
+class FakeDeviceProvider
+    : public VideoCaptureDeviceFactoryLinux::DeviceProvider {
+ public:
+  FakeDeviceProvider();
+  ~FakeDeviceProvider() override;
+
+  void AddDevice(const VideoCaptureDeviceDescriptor& descriptor);
+
+  void GetDeviceIds(std::vector<std::string>* target_container) override;
+  std::string GetDeviceModelId(const std::string& device_id) override;
+  std::string GetDeviceDisplayName(const std::string& device_id) override;
+  VideoFacingMode GetCameraFacing(const std::string& device_id,
+                                  const std::string& model_id) override;
+  int GetOrientation(const std::string& device_id,
+                     const std::string& model_id) override;
+
+ private:
+  std::vector<VideoCaptureDeviceDescriptor> descriptors_;
+};
+}  // namespace media
+#endif  // MEDIA_CAPTURE_VIDEO_LINUX_FAKE_DEVICE_PROVIDER_H_

media/capture/video/linux/video_capture_device_factory_linux_unittest.cc

@@ -7,6 +7,7 @@
 #include "base/run_loop.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
+#include "media/capture/video/linux/fake_device_provider.h"
 #include "media/capture/video/linux/fake_v4l2_impl.h"
 #include "media/capture/video/mock_video_capture_device_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -17,57 +18,6 @@ using ::testing::InvokeWithoutArgs;
 
 namespace media {
 
-class DescriptorDeviceProvider
-    : public VideoCaptureDeviceFactoryLinux::DeviceProvider {
- public:
-  void AddDevice(const VideoCaptureDeviceDescriptor& descriptor) {
-    descriptors_.emplace_back(descriptor);
-  }
-
-  void GetDeviceIds(std::vector<std::string>* target_container) override {
-    for (const auto& entry : descriptors_) {
-      target_container->emplace_back(entry.device_id);
-    }
-  }
-
-  std::string GetDeviceModelId(const std::string& device_id) override {
-    auto iter =
-        std::find_if(descriptors_.begin(), descriptors_.end(),
-                     [&device_id](const VideoCaptureDeviceDescriptor& val) {
-                       return val.device_id == device_id;
-                     });
-    if (iter == descriptors_.end())
-      CHECK(false) << "Unknown device_id " << device_id;
-
-    return iter->model_id;
-  }
-
-  std::string GetDeviceDisplayName(const std::string& device_id) override {
-    auto iter =
-        std::find_if(descriptors_.begin(), descriptors_.end(),
-                     [&device_id](const VideoCaptureDeviceDescriptor& val) {
-                       return val.device_id == device_id;
-                     });
-    if (iter == descriptors_.end())
-      CHECK(false) << "Unknown device_id " << device_id;
-
-    return iter->display_name();
-  }
-
-  VideoFacingMode GetCameraFacing(const std::string& device_id,
-                                  const std::string& model_id) override {
-    return MEDIA_VIDEO_FACING_NONE;
-  }
-
-  int GetOrientation(const std::string& device_id,
-                     const std::string& model_id) override {
-    return 0;
-  }
-
- private:
-  std::vector<VideoCaptureDeviceDescriptor> descriptors_;
-};
-
 class VideoCaptureDeviceFactoryLinuxTest
     : public ::testing::TestWithParam<VideoCaptureDeviceDescriptor> {
  public:
@@ -79,7 +29,7 @@ class VideoCaptureDeviceFactoryLinuxTest
         base::ThreadTaskRunnerHandle::Get());
     scoped_refptr<FakeV4L2Impl> fake_v4l2(new FakeV4L2Impl());
     fake_v4l2_ = fake_v4l2.get();
-    auto fake_device_provider = std::make_unique<DescriptorDeviceProvider>();
+    auto fake_device_provider = std::make_unique<FakeDeviceProvider>();
     fake_device_provider_ = fake_device_provider.get();
     factory_->SetV4L2EnvironmentForTesting(std::move(fake_v4l2),
                                            std::move(fake_device_provider));
@@ -87,7 +37,7 @@ class VideoCaptureDeviceFactoryLinuxTest
 
   base::test::TaskEnvironment task_environment_;
   FakeV4L2Impl* fake_v4l2_;
-  DescriptorDeviceProvider* fake_device_provider_;
+  FakeDeviceProvider* fake_device_provider_;
   std::unique_ptr<VideoCaptureDeviceFactoryLinux> factory_;
 };