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

This CL is part of the Mojo Video Capture work. For the bigger picture,
see [1] CL24_part1.

Goal of CL24:
The interface content::VideoCaptureProvider currently has one implementation
called InProcessVideoCaptureProvider, which is essentially a factory for the
legacy in-process video capture stack. This CL adds a second implementation
called MojoServiceVideoCaptureProvider which is essentially a wrapper for
connecting to and communicating with the new video capture service.

Changes in part1:
* Add class MojoServiceVideoCaptureProvider
* Add skeletons for classes MojoServiceVideoCaptureDeviceLauncher and
  MojoServiceLaunchedVideoCaptureDevice
* Introduce a build flag enable_mojo_video_capture to prevent the new and
  incomplete code from going into builds.

BUG=584797
TEST=
  service_unittests --gtest_filter="*Video*"
  content_unittests --gtest_filter="*Video*"
  content_browsertests --gtest_filter="VideoCaptureBrowserTest.*"

[1] https://docs.google.com/a/chromium.org/document/d/1Qw7rw1AJy0QHXjha36jZNiEuxsxWslJ_X-zpOhijvI8/edit?usp=sharing

Review-Url: https://codereview.chromium.org/2848973002
Cr-Commit-Position: refs/heads/master@{#469380}

content/browser/BUILD.gn

@@ -11,6 +11,12 @@ import("//printing/features/features.gni")
 import("//third_party/WebKit/public/public_features.gni")
 import("//tools/ipc_fuzzer/ipc_fuzzer.gni")
 
+declare_args() {
+  # Include code in the build that is only needed when using the video
+  # capture Mojo service, which is currently experimental.
+  enable_mojo_video_capture = false
+}
+
 source_set("browser") {
   # Only the public target should depend on this. All other targets (even
   # internal content ones) should depend on the public one.
@@ -1597,6 +1603,22 @@ source_set("browser") {
     ]
   }
 
+  if (enable_mojo_video_capture) {
+    sources += [
+      "renderer_host/media/service_launched_video_capture_device.cc",
+      "renderer_host/media/service_launched_video_capture_device.h",
+      "renderer_host/media/service_video_capture_device_launcher.cc",
+      "renderer_host/media/service_video_capture_device_launcher.h",
+      "renderer_host/media/service_video_capture_provider.cc",
+      "renderer_host/media/service_video_capture_provider.h",
+    ]
+
+    deps += [
+      "//services/video_capture/public/cpp",
+      "//services/video_capture/public/interfaces:constants",
+    ]
+  }
+
   # Desktop screen capture implementations, conditionally built depending on
   # the available implementations for each platform.
   if (is_linux || is_mac || is_win) {

content/browser/renderer_host/media/in_process_video_capture_provider.cc

@@ -16,6 +16,8 @@ InProcessVideoCaptureProvider::InProcessVideoCaptureProvider(
 
 InProcessVideoCaptureProvider::~InProcessVideoCaptureProvider() = default;
 
+void InProcessVideoCaptureProvider::Uninitialize() {}
+
 void InProcessVideoCaptureProvider::GetDeviceInfosAsync(
     const base::Callback<void(
         const std::vector<media::VideoCaptureDeviceInfo>&)>& result_callback) {

content/browser/renderer_host/media/in_process_video_capture_provider.h

@@ -20,6 +20,8 @@ class CONTENT_EXPORT InProcessVideoCaptureProvider
       scoped_refptr<base::SingleThreadTaskRunner> device_task_runner);
   ~InProcessVideoCaptureProvider() override;
 
+  void Uninitialize() override;
+
   void GetDeviceInfosAsync(
       const base::Callback<void(
           const std::vector<media::VideoCaptureDeviceInfo>&)>& result_callback)

content/browser/renderer_host/media/mock_video_capture_provider.h

@@ -15,6 +15,7 @@ class MockVideoCaptureProvider : public VideoCaptureProvider {
   MockVideoCaptureProvider();
   ~MockVideoCaptureProvider() override;
 
+  MOCK_METHOD0(Uninitialize, void());
   MOCK_METHOD1(GetDeviceInfosAsync,
                void(const base::Callback<
                     void(const std::vector<media::VideoCaptureDeviceInfo>&)>&

content/browser/renderer_host/media/service_launched_video_capture_device.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_launched_video_capture_device.h"
+
+namespace content {
+
+ServiceLaunchedVideoCaptureDevice::ServiceLaunchedVideoCaptureDevice(
+    video_capture::mojom::DevicePtr device)
+    : device_(std::move(device)) {}
+
+ServiceLaunchedVideoCaptureDevice::~ServiceLaunchedVideoCaptureDevice() {}
+
+void ServiceLaunchedVideoCaptureDevice::GetPhotoCapabilities(
+    media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) const {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::SetPhotoOptions(
+    media::mojom::PhotoSettingsPtr settings,
+    media::VideoCaptureDevice::SetPhotoOptionsCallback callback) {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::TakePhoto(
+    media::VideoCaptureDevice::TakePhotoCallback callback) {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::MaybeSuspendDevice() {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::ResumeDevice() {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::RequestRefreshFrame() {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::SetDesktopCaptureWindowIdAsync(
+    gfx::NativeViewId window_id,
+    base::OnceClosure done_cb) {
+  NOTIMPLEMENTED();
+}
+
+void ServiceLaunchedVideoCaptureDevice::OnUtilizationReport(
+    int frame_feedback_id,
+    double utilization) {
+  NOTIMPLEMENTED();
+}
+
+}  // namespace content

content/browser/renderer_host/media/service_launched_video_capture_device.h

+// 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_LAUNCHED_VIDEO_CAPTURE_DEVICE_H_
+#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_LAUNCHED_VIDEO_CAPTURE_DEVICE_H_
+
+#include "content/browser/renderer_host/media/video_capture_provider.h"
+#include "services/video_capture/public/interfaces/device.mojom.h"
+
+namespace content {
+
+// Implementation of LaunchedVideoCaptureDevice that uses the "video_capture"
+// service.
+class ServiceLaunchedVideoCaptureDevice : public LaunchedVideoCaptureDevice {
+ public:
+  explicit ServiceLaunchedVideoCaptureDevice(
+      video_capture::mojom::DevicePtr device);
+  ~ServiceLaunchedVideoCaptureDevice() override;
+
+  // LaunchedVideoCaptureDevice implementation.
+  void GetPhotoCapabilities(
+      media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback)
+      const override;
+  void SetPhotoOptions(
+      media::mojom::PhotoSettingsPtr settings,
+      media::VideoCaptureDevice::SetPhotoOptionsCallback callback) override;
+  void TakePhoto(
+      media::VideoCaptureDevice::TakePhotoCallback callback) override;
+  void MaybeSuspendDevice() override;
+  void ResumeDevice() override;
+  void RequestRefreshFrame() override;
+
+  void SetDesktopCaptureWindowIdAsync(gfx::NativeViewId window_id,
+                                      base::OnceClosure done_cb) override;
+
+  void OnUtilizationReport(int frame_feedback_id, double utilization) override;
+
+ private:
+  const video_capture::mojom::DevicePtr device_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_LAUNCHED_VIDEO_CAPTURE_DEVICE_H_

content/browser/renderer_host/media/service_video_capture_device_launcher.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_device_launcher.h"
+
+namespace content {
+
+ServiceVideoCaptureDeviceLauncher::ServiceVideoCaptureDeviceLauncher(
+    video_capture::mojom::DeviceFactoryPtr* device_factory)
+    : device_factory_(device_factory) {}
+
+ServiceVideoCaptureDeviceLauncher::~ServiceVideoCaptureDeviceLauncher() {}
+
+void ServiceVideoCaptureDeviceLauncher::LaunchDeviceAsync(
+    const std::string& device_id,
+    MediaStreamType stream_type,
+    const media::VideoCaptureParams& params,
+    base::WeakPtr<media::VideoFrameReceiver> receiver,
+    Callbacks* callbacks,
+    base::OnceClosure done_cb) {
+  NOTIMPLEMENTED();
+}
+
+void ServiceVideoCaptureDeviceLauncher::AbortLaunch() {
+  NOTIMPLEMENTED();
+}
+
+}  // namespace content

content/browser/renderer_host/media/service_video_capture_device_launcher.h

+// 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_VIDEO_CAPTURE_DEVICE_LAUNCHER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_VIDEO_CAPTURE_DEVICE_LAUNCHER_H_
+
+#include "content/browser/renderer_host/media/video_capture_provider.h"
+#include "content/public/common/media_stream_request.h"
+#include "services/video_capture/public/interfaces/device_factory.mojom.h"
+
+namespace content {
+
+// Implementation of VideoCaptureDeviceLauncher that uses the "video_capture"
+// service.
+class ServiceVideoCaptureDeviceLauncher : public VideoCaptureDeviceLauncher {
+ public:
+  explicit ServiceVideoCaptureDeviceLauncher(
+      video_capture::mojom::DeviceFactoryPtr* device_factory);
+  ~ServiceVideoCaptureDeviceLauncher() override;
+
+  // VideoCaptureDeviceLauncher implementation.
+  void LaunchDeviceAsync(const std::string& device_id,
+                         MediaStreamType stream_type,
+                         const media::VideoCaptureParams& params,
+                         base::WeakPtr<media::VideoFrameReceiver> receiver,
+                         Callbacks* callbacks,
+                         base::OnceClosure done_cb) override;
+  void AbortLaunch() override;
+
+  void OnUtilizationReport(int frame_feedback_id, double utilization);
+
+ private:
+  video_capture::mojom::DeviceFactoryPtr* const device_factory_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_VIDEO_CAPTURE_DEVICE_LAUNCHER_H_

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 content {
+
+ServiceVideoCaptureProvider::ServiceVideoCaptureProvider() {
+  thread_checker_.DetachFromThread();
+  DCHECK(BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  connector_ =
+      ServiceManagerConnection::GetForProcess()->GetConnector()->Clone();
+}
+
+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;
+
+  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

content/browser/renderer_host/media/service_video_capture_provider.h

+// 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.
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_VIDEO_CAPTURE_PROVIDER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_VIDEO_CAPTURE_PROVIDER_H_
+
+#include "base/threading/thread_checker.h"
+#include "content/browser/renderer_host/media/video_capture_provider.h"
+#include "services/video_capture/public/interfaces/device_factory.mojom.h"
+#include "services/video_capture/public/interfaces/device_factory_provider.mojom.h"
+
+namespace service_manager {
+class Connector;
+}
+
+namespace content {
+
+// Implementation of VideoCaptureProvider that uses the "video_capture" service.
+class CONTENT_EXPORT ServiceVideoCaptureProvider : public VideoCaptureProvider {
+ public:
+  ServiceVideoCaptureProvider();
+  ~ServiceVideoCaptureProvider() override;
+
+  void Uninitialize() override;
+
+  void GetDeviceInfosAsync(
+      const base::Callback<void(
+          const std::vector<media::VideoCaptureDeviceInfo>&)>& result_callback)
+      override;
+
+  std::unique_ptr<VideoCaptureDeviceLauncher> CreateDeviceLauncher() override;
+
+ private:
+  void LazyConnectToService();
+  void OnLostConnectionToDeviceFactory();
+
+  std::unique_ptr<service_manager::Connector> connector_;
+  // We must hold on to |device_factory_provider_| because it holds the
+  // service-side binding for |device_factory_|.
+  video_capture::mojom::DeviceFactoryProviderPtr device_factory_provider_;
+  video_capture::mojom::DeviceFactoryPtr device_factory_;
+  base::ThreadChecker thread_checker_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_SERVICE_VIDEO_CAPTURE_PROVIDER_H_

content/browser/renderer_host/media/video_capture_provider.h

@@ -72,6 +72,8 @@ class CONTENT_EXPORT VideoCaptureProvider {
  public:
   virtual ~VideoCaptureProvider() {}
 
+  virtual void Uninitialize() = 0;
+
   // The passed-in |result_callback| must guarantee that the called
   // instance stays alive until |result_callback| is invoked.
   virtual void GetDeviceInfosAsync(

services/video_capture/public/cpp/receiver_media_to_mojo_adapter.cc

@@ -109,4 +109,12 @@ void ReceiverMediaToMojoAdapter::OnLog(const std::string& message) {
   receiver_->OnLog(message);
 }
 
+void ReceiverMediaToMojoAdapter::OnStarted() {
+  receiver_->OnStarted();
+}
+
+void ReceiverMediaToMojoAdapter::OnStartedUsingGpuDecode() {
+  receiver_->OnStartedUsingGpuDecode();
+}
+
 }  // namespace video_capture

services/video_capture/public/cpp/receiver_media_to_mojo_adapter.h

@@ -29,6 +29,8 @@ class ReceiverMediaToMojoAdapter : public mojom::Receiver {
   void OnBufferRetired(int32_t buffer_id) override;
   void OnError() override;
   void OnLog(const std::string& message) override;
+  void OnStarted() override;
+  void OnStartedUsingGpuDecode() override;
 
  private:
   std::unique_ptr<media::VideoFrameReceiver> receiver_;