Replace manual conversions with Mojo type mappings

services/video_capture/device_factory_media_to_mojo_adapter.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 "services/video_capture/device_factory_media_to_mojo_adapter.h"
 
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "media/capture/video/fake_video_capture_device.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/video_capture/device_mock_to_media_adapter.h"
-#include "services/video_capture/mojo_media_conversions.h"
 #include "services/video_capture/video_capture_device_proxy_impl.h"
 
 namespace video_capture {
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::ActiveDeviceEntry() =
     default;
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::~ActiveDeviceEntry() =
     default;
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::ActiveDeviceEntry(
     DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&& other) = default;
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::operator=(
     DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&& other) = default;
 
 DeviceFactoryMediaToMojoAdapter::DeviceFactoryMediaToMojoAdapter(
     std::unique_ptr<media::VideoCaptureDeviceFactory> device_factory,
     const media::VideoCaptureJpegDecoderFactoryCB& jpeg_decoder_factory_callback)
     : device_factory_(std::move(device_factory)),
       jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback) {}
 
 DeviceFactoryMediaToMojoAdapter::~DeviceFactoryMediaToMojoAdapter() = default;
 
 void DeviceFactoryMediaToMojoAdapter::EnumerateDeviceDescriptors(
     const EnumerateDeviceDescriptorsCallback& callback) {
-  std::vector<mojom::VideoCaptureDeviceDescriptorPtr> result;
-  media::VideoCaptureDeviceDescriptors descriptors;
+  std::vector<media::VideoCaptureDeviceDescriptor> descriptors;
   device_factory_->GetDeviceDescriptors(&descriptors);
-  for (const auto& entry : descriptors) {
-    result.push_back(ConvertFromMediaToMojo(entry));
-  }
-  callback.Run(std::move(result));
+  callback.Run(std::move(descriptors));
 }
 
 void DeviceFactoryMediaToMojoAdapter::GetSupportedFormats(
-    mojom::VideoCaptureDeviceDescriptorPtr device_descriptor,
+    const media::VideoCaptureDeviceDescriptor& descriptor,
     const GetSupportedFormatsCallback& callback) {
-  std::vector<mojom::VideoCaptureFormatPtr> result;
   media::VideoCaptureFormats formats;
-  device_factory_->GetSupportedFormats(
-      ConvertFromMojoToMedia(std::move(device_descriptor)), &formats);
-  for (const auto& entry : formats) {
-    result.push_back(
-        ConvertFromMediaToMojo(entry));
-  }
-  callback.Run(std::move(result));
+  device_factory_->GetSupportedFormats(std::move(descriptor), &formats);
+  callback.Run(std::move(formats));
 }
 
 void DeviceFactoryMediaToMojoAdapter::CreateDeviceProxy(
-    mojom::VideoCaptureDeviceDescriptorPtr device_descriptor,
+    const media::VideoCaptureDeviceDescriptor& descriptor,
     mojom::VideoCaptureDeviceProxyRequest proxy_request,
     const CreateDeviceProxyCallback& callback) {
-  auto media_descriptor = ConvertFromMojoToMedia(std::move(device_descriptor));
-  if (active_devices_.find(media_descriptor) != active_devices_.end()) {
+  if (active_devices_.find(descriptor) != active_devices_.end()) {
     // The requested device is already in use.
     // Revoke the access and close the device, then bind to the new request.
-    ActiveDeviceEntry& device_entry = active_devices_[media_descriptor];
+    ActiveDeviceEntry& device_entry = active_devices_[descriptor];
     device_entry.binding->Unbind();
     device_entry.device_proxy->Stop();
     device_entry.binding->Bind(std::move(proxy_request));
     device_entry.binding->set_connection_error_handler(base::Bind(
         &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
         base::Unretained(this),
-        media_descriptor));
+        descriptor));
     callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
     return;
   }
 
   // Create device
   std::unique_ptr<media::VideoCaptureDevice> media_device =
-      device_factory_->CreateDevice(
-          media_descriptor);
+      device_factory_->CreateDevice(descriptor);
   if (media_device == nullptr) {
     callback.Run(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
     return;
   }
 
   // Add entry to active_devices to keep track of it
   ActiveDeviceEntry device_entry;
   device_entry.device_proxy = base::MakeUnique<VideoCaptureDeviceProxyImpl>(
       std::move(media_device), jpeg_decoder_factory_callback_);
   device_entry.binding =
       base::MakeUnique<mojo::Binding<mojom::VideoCaptureDeviceProxy>>(
           device_entry.device_proxy.get(), std::move(proxy_request));
   device_entry.binding->set_connection_error_handler(base::Bind(
       &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
-      base::Unretained(this), media_descriptor));
-  active_devices_[media_descriptor] = std::move(device_entry);
+      base::Unretained(this), descriptor));
+  active_devices_[descriptor] = std::move(device_entry);
 
   callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
 }
 
 void DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose(
     media::VideoCaptureDeviceDescriptor descriptor) {
   active_devices_[descriptor].device_proxy->Stop();
   active_devices_.erase(descriptor);
 }
 
 }  // namespace video_capture