[Mojo Video Capture] Implement a VideoCaptureProvider using the Mojo service (part 1)

content/browser/renderer_host/media/service_video_capture_provider.cc

+// Copyright 2017 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 "content/browser/renderer_host/media/service_video_capture_provider.h"
+
+#include "content/browser/renderer_host/media/service_video_capture_device_launcher.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/service_manager_connection.h"
+#include "services/service_manager/public/cpp/connector.h"
+#include "services/video_capture/public/interfaces/constants.mojom.h"
+
+namespace {
+
+void BindToBrowserConnector(service_manager::mojom::ConnectorRequest request) {
+  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&BindToBrowserConnector, base::Passed(&request)));
+    return;
+  }
+
+  content::ServiceManagerConnection::GetForProcess()
+      ->GetConnector()
+      ->BindConnectorRequest(std::move(request));
+}
+
+}  // namespace

[mcasas, 2017/05/03 19:10:23]

IIRC in content/ these anonymous namespaces
are supposed to be inside content namespace
(which is different from media/ where these
anonymous go out of media namespace).

[chfremer, 2017/05/03 21:29:36]

Oh. This is confusing. I'll try to remember it.
Luckily, here, the anonymous namespace was eliminated based on rockot@'s
simplification.

+
+namespace content {
+
+ServiceVideoCaptureProvider::ServiceVideoCaptureProvider() = default;
+
+ServiceVideoCaptureProvider::~ServiceVideoCaptureProvider() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void ServiceVideoCaptureProvider::Uninitialize() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  device_factory_.reset();
+  device_factory_provider_.reset();
+}
+
+void ServiceVideoCaptureProvider::GetDeviceInfosAsync(
+    const base::Callback<void(
+        const std::vector<media::VideoCaptureDeviceInfo>&)>& result_callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  LazyConnectToService();
+  device_factory_->GetDeviceInfos(result_callback);
+}
+
+std::unique_ptr<VideoCaptureDeviceLauncher>
+ServiceVideoCaptureProvider::CreateDeviceLauncher() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  LazyConnectToService();
+  return base::MakeUnique<ServiceVideoCaptureDeviceLauncher>(&device_factory_);
+}
+
+void ServiceVideoCaptureProvider::LazyConnectToService() {
+  if (device_factory_provider_.is_bound())
+    return;
+
+  service_manager::mojom::ConnectorRequest connector_request;
+  std::unique_ptr<service_manager::Connector> connector =
+      service_manager::Connector::Create(&connector_request);
+  BindToBrowserConnector(std::move(connector_request));

[Ken Rockot(use gerrit already), 2017/05/03 17:59:46]

Can ServiceVideoCaptureProvider actually be created on arbitrary threads or is
it just created on the main thread?

[chfremer, 2017/05/03 18:29:09]

This is not going to be visible and tested before CL25, but in there it is going
to be as follows:
ServiceVideoCaptureProvider will be created on the main thread, but will then be
operated on the IO thread. I had to add a thread_checker_.DetachFromThread(); to
CL25 for this to work, but to make it more clear I can also port it to this CL.

[Ken Rockot(use gerrit already), 2017/05/03 18:32:19]

I see. You can probably simply things a bit then, by having this object own its
own std::unique_ptr<Connector>. You could initialize it in the constructor
(which as you say runs on the main thread) by simply calling
ServiceManagerConnection::GetForProcess()->GetConnector()->Clone(). The
Connector you get back won't be bound to a specific thread until you make a call
on it.

[chfremer, 2017/05/03 21:29:36]

Done.

+
+  connector->BindInterface(video_capture::mojom::kServiceName,
+                           &device_factory_provider_);
+  device_factory_provider_->ConnectToDeviceFactory(
+      mojo::MakeRequest(&device_factory_));
+  // Unretained |this| is safe, because |this| owns |device_factory_|.
+  device_factory_.set_connection_error_handler(
+      base::Bind(&ServiceVideoCaptureProvider::OnLostConnectionToDeviceFactory,
+                 base::Unretained(this)));
+}
+
+void ServiceVideoCaptureProvider::OnLostConnectionToDeviceFactory() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // This may indicate that the video capture service has crashed. Uninitialize
+  // here, so that a new connection will be established when clients try to
+  // reconnect.
+  Uninitialize();
+}
+
+}  // namespace content