Let clients interact with VideoCaptureDeviceClient instead of VideoCaptureDevice

services/video_capture/video_capture_device_proxy_impl.cc

Index: services/video_capture/video_capture_device_proxy_impl.cc
diff --git a/services/video_capture/video_capture_device_proxy_impl.cc b/services/video_capture/video_capture_device_proxy_impl.cc
index eeacf359588ea6291e4f989934966914b1be5a38..dbd4fed1abebf208344f033ecee0a42c1d47699e 100644
--- a/services/video_capture/video_capture_device_proxy_impl.cc
+++ b/services/video_capture/video_capture_device_proxy_impl.cc
@@ -2,15 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/logging.h"
-#include "services/video_capture/device_client_mojo_to_media_adapter.h"
 #include "services/video_capture/video_capture_device_proxy_impl.h"
 
+#include "base/logging.h"
+#include "media/capture/video/video_capture_buffer_pool_impl.h"
+#include "media/capture/video/video_capture_jpeg_decoder.h"
+#include "services/video_capture/buffer_tracker_factory_impl.h"
+#include "services/video_capture/receiver_mojo_to_media_adapter.h"
+
 namespace video_capture {
 
 VideoCaptureDeviceProxyImpl::VideoCaptureDeviceProxyImpl(
-    std::unique_ptr<media::VideoCaptureDevice> device)
-    : device_(std::move(device)) {}
+    std::unique_ptr<media::VideoCaptureDevice> device,
+    const media::VideoCaptureJpegDecoderFactoryCB&
+        jpeg_decoder_factory_callback)
+    : device_(std::move(device)),
+      jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback),
+      device_running_(false) {}
 
 VideoCaptureDeviceProxyImpl::~VideoCaptureDeviceProxyImpl() {
   if (device_running_)
@@ -18,20 +26,32 @@ VideoCaptureDeviceProxyImpl::~VideoCaptureDeviceProxyImpl() {
 }
 
 void VideoCaptureDeviceProxyImpl::Start(
-    const media::VideoCaptureFormat& requested_format,
+   const media::VideoCaptureFormat& requested_format,
     media::ResolutionChangePolicy resolution_change_policy,
     media::PowerLineFrequency power_line_frequency,
-    mojom::VideoCaptureDeviceClientPtr client) {
+    mojom::VideoFrameReceiverPtr receiver) {
   media::VideoCaptureParams params;
   params.requested_format = requested_format;
   params.resolution_change_policy = resolution_change_policy;
   params.power_line_frequency = power_line_frequency;
-  client.set_connection_error_handler(
+  receiver.set_connection_error_handler(
       base::Bind(&VideoCaptureDeviceProxyImpl::OnClientConnectionErrorOrClose,
                  base::Unretained(this)));
-  auto media_client =
-      base::MakeUnique<DeviceClientMojoToMediaAdapter>(std::move(client));
-  device_->AllocateAndStart(params, std::move(media_client));
+
+  auto media_receiver =
+      base::MakeUnique<ReceiverMojoToMediaAdapter>(std::move(receiver));
+
+  // Create a dedicated buffer pool for the device usage session.
+  const int kMaxBufferCount = 2;
+  auto buffer_tracker_factory = base::MakeUnique<BufferTrackerFactoryImpl>();
+  scoped_refptr<media::VideoCaptureBufferPool> buffer_pool(
+      new media::VideoCaptureBufferPoolImpl(std::move(buffer_tracker_factory),
+                                            kMaxBufferCount));
+
+  auto device_client = base::MakeUnique<media::VideoCaptureDeviceClient>(
+      std::move(media_receiver), buffer_pool, jpeg_decoder_factory_callback_);
+
+  device_->AllocateAndStart(params, std::move(device_client));
   device_running_ = true;
 }
 
@@ -41,7 +61,10 @@ void VideoCaptureDeviceProxyImpl::Stop() {
 }
 
 void VideoCaptureDeviceProxyImpl::OnClientConnectionErrorOrClose() {
-  device_->StopAndDeAllocate();
+  if (device_running_) {
+    device_->StopAndDeAllocate();
+    device_running_ = false;
+  }
 }
 
 }  // namespace video_capture