[Mojo Video Capture] Use actual factory instances implementing media::VideoCaptureDeviceFactory

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
new file mode 100644
index 0000000000000000000000000000000000000000..98e3842af9809e2d752eaacf056a8e6eb6f251e2
--- /dev/null
+++ b/services/video_capture/device_factory_media_to_mojo_adapter.cc
@@ -0,0 +1,102 @@
+// 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/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) {
+  media::VideoCaptureDeviceDescriptors descriptors;
+  device_factory_->GetDeviceDescriptors(&descriptors);
+  callback.Run(descriptors);
+}
+
+void DeviceFactoryMediaToMojoAdapter::GetSupportedFormats(
+    const media::VideoCaptureDeviceDescriptor& device_descriptor,
+    const GetSupportedFormatsCallback& callback) {
+  std::vector<VideoCaptureFormat> result;
+  NOTIMPLEMENTED();
+  callback.Run(std::move(result));
+}
+
+void DeviceFactoryMediaToMojoAdapter::CreateDeviceProxy(
+    const media::VideoCaptureDeviceDescriptor& device_descriptor,
+    mojom::VideoCaptureDeviceProxyRequest proxy_request,
+    const CreateDeviceProxyCallback& callback) {
+  if (active_devices_.find(device_descriptor) != active_devices_.end()) {
+    // The requested device is already in use.
+    // Revoke the access and close the device, then bind to the new request.

[mcasas, 2016/11/04 23:24:28]

Is this what we want to do? Or should 
subsequent requests for a device in use
just be rejected?

[chfremer, 2016/11/07 18:42:36]

This design was a suggestion by yzshen@ in response to a concern I had.
The concern was that if client A closes its |proxy_request|, this information 
arrives at the service asynchronously, and it may not be clear at what time 
a client B would be able to successfully call CreateDeviceProxy() again.

By always honoring the latest request and revoking older ones, we avoid this
potential issue.

I added a comment in the *.mojom to explain this design choice. 

+    ActiveDeviceEntry& device_entry = active_devices_[device_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), device_descriptor));
+    callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
+    return;
+  }
+
+  // Create device

[mcasas, 2016/11/04 23:24:28]

Superfluous comment?

[chfremer, 2016/11/07 18:42:36]

Done.

+  std::unique_ptr<media::VideoCaptureDevice> media_device =
+      device_factory_->CreateDevice(device_descriptor);
+  if (media_device == nullptr) {
+    callback.Run(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
+    return;
+  }
+
+  // Add entry to active_devices to keep track of it

[mcasas, 2016/11/04 23:24:28]

nit: |active_devices|

+  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), device_descriptor));
+  active_devices_[device_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