Revert of [Mojo Video Capture] Adapt video_capture service to refactored video capture stack

services/video_capture/device_factory_media_to_mojo_adapter.cc

Index: services/video_capture/device_factory_media_to_mojo_adapter.cc
diff --git a/services/video_capture/device_factory_media_to_mojo_adapter.cc b/services/video_capture/device_factory_media_to_mojo_adapter.cc
index 12b3a0083c4abe9265745da573b968be3e3be1f1..07f6db53a083b031d6328c789efc2a6160952d78 100644
--- a/services/video_capture/device_factory_media_to_mojo_adapter.cc
+++ b/services/video_capture/device_factory_media_to_mojo_adapter.cc
@@ -15,54 +15,6 @@
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/video_capture/device_media_to_mojo_adapter.h"
 
-namespace {
-
-// Translates a set of device infos reported by a VideoCaptureSystem to a set
-// of device infos that the video capture service exposes to its client.
-// The Video Capture Service instances of VideoCaptureDeviceClient to
-// convert the formats provided by the VideoCaptureDevice instances. Here, we
-// translate the set of supported formats as reported by the |device_factory_|
-// to what will be output by the VideoCaptureDeviceClient we connect to it.
-// TODO(chfremer): A cleaner design would be to have this translation
-// happen in VideoCaptureDeviceClient, and talk only to VideoCaptureDeviceClient
-// instead of VideoCaptureSystem.
-static void TranslateDeviceInfos(
-    const video_capture::mojom::DeviceFactory::GetDeviceInfosCallback& callback,
-    const std::vector<media::VideoCaptureDeviceInfo>& device_infos) {
-  std::vector<media::VideoCaptureDeviceInfo> translated_device_infos;
-  for (const auto& device_info : device_infos) {
-    media::VideoCaptureDeviceInfo translated_device_info;
-    translated_device_info.descriptor = device_info.descriptor;
-    for (const auto& format : device_info.supported_formats) {
-      media::VideoCaptureFormat translated_format;
-      switch (format.pixel_format) {
-        case media::PIXEL_FORMAT_I420:
-        case media::PIXEL_FORMAT_MJPEG:
-          translated_format.pixel_format = media::PIXEL_FORMAT_I420;
-          break;
-        case media::PIXEL_FORMAT_Y16:
-          translated_format.pixel_format = media::PIXEL_FORMAT_Y16;
-        default:
-          // Any other format cannot be consumed by VideoCaptureDeviceClient.
-          continue;
-      }
-      translated_format.frame_size = format.frame_size;
-      translated_format.frame_rate = format.frame_rate;
-      translated_format.pixel_storage = media::PIXEL_STORAGE_CPU;
-      if (base::ContainsValue(translated_device_info.supported_formats,
-                              translated_format))
-        continue;
-      translated_device_info.supported_formats.push_back(translated_format);
-    }
-    if (translated_device_info.supported_formats.empty())
-      continue;
-    translated_device_infos.push_back(translated_device_info);
-  }
-  callback.Run(translated_device_infos);
-}
-
-}  // anonymous namespace
-
 namespace video_capture {
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::ActiveDeviceEntry() =
@@ -79,18 +31,17 @@
     DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&& other) = default;
 
 DeviceFactoryMediaToMojoAdapter::DeviceFactoryMediaToMojoAdapter(
-    std::unique_ptr<media::VideoCaptureSystem> capture_system,
+    std::unique_ptr<media::VideoCaptureDeviceFactory> device_factory,
     const media::VideoCaptureJpegDecoderFactoryCB&
         jpeg_decoder_factory_callback)
-    : capture_system_(std::move(capture_system)),
+    : device_factory_(std::move(device_factory)),
       jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback) {}
 
 DeviceFactoryMediaToMojoAdapter::~DeviceFactoryMediaToMojoAdapter() = default;
 
 void DeviceFactoryMediaToMojoAdapter::GetDeviceInfos(
     const GetDeviceInfosCallback& callback) {
-  capture_system_->GetDeviceInfosAsync(
-      base::Bind(&TranslateDeviceInfos, callback));
+  NOTIMPLEMENTED();
 }
 
 void DeviceFactoryMediaToMojoAdapter::CreateDevice(
@@ -112,8 +63,14 @@
     return;
   }
 
+  // Create device
+  media::VideoCaptureDeviceDescriptor descriptor;
+  if (LookupDescriptorFromId(device_id, &descriptor) == false) {
+    callback.Run(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
+    return;
+  }
   std::unique_ptr<media::VideoCaptureDevice> media_device =
-      capture_system_->CreateDevice(device_id);
+      device_factory_->CreateDevice(descriptor);
   if (media_device == nullptr) {
     callback.Run(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
     return;
@@ -139,4 +96,20 @@
   active_devices_by_id_.erase(device_id);
 }
 
+bool DeviceFactoryMediaToMojoAdapter::LookupDescriptorFromId(
+    const std::string& device_id,
+    media::VideoCaptureDeviceDescriptor* descriptor) {
+  media::VideoCaptureDeviceDescriptors descriptors;
+  device_factory_->GetDeviceDescriptors(&descriptors);
+  auto descriptor_iter = std::find_if(
+      descriptors.begin(), descriptors.end(),
+      [&device_id](const media::VideoCaptureDeviceDescriptor& descriptor) {
+        return descriptor.device_id == device_id;
+      });
+  if (descriptor_iter == descriptors.end())
+    return false;
+  *descriptor = *descriptor_iter;
+  return true;
+}
+
 }  // namespace video_capture