[Mojo Video Capture] Introduce abstraction BuildableVideoCaptureDevice

content/browser/renderer_host/media/video_capture_controller.cc

 // Copyright (c) 2012 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/video_capture_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 22 matching lines @@
 #endif
 
 using media::VideoCaptureFormat;
 using media::VideoFrame;
 using media::VideoFrameMetadata;
 
 namespace content {
 
 namespace {
 
+// Counter used for identifying a DeviceRequest to start a capture device.
+static int g_device_start_id = 0;
+
 static const int kInfiniteRatio = 99999;
 
 #define UMA_HISTOGRAM_ASPECT_RATIO(name, width, height) \
   UMA_HISTOGRAM_SPARSE_SLOWLY(                          \
       name, (height) ? ((width)*100) / (height) : kInfiniteRatio);
 
 void CallOnError(VideoCaptureControllerEventHandler* client,
                  VideoCaptureControllerID id) {
   client->OnError(id);
 }
@@ skipping 100 matching lines @@
     max_consumer_utilization_ =
         media::VideoFrameConsumerFeedbackObserver::kNoUtilizationRecorded;
   }
 }
 
 mojo::ScopedSharedBufferHandle
 VideoCaptureController::BufferContext::CloneHandle() {
   return buffer_handle_->Clone();
 }
 
-VideoCaptureController::VideoCaptureController()
-    : consumer_feedback_observer_(nullptr),
+VideoCaptureController::VideoCaptureController(
+    const std::string& device_id,
+    MediaStreamType stream_type,
+    const media::VideoCaptureParams& params,
+    std::unique_ptr<BuildableVideoCaptureDevice> buildable_device)
+    : serial_id_(g_device_start_id++),
+      device_id_(device_id),
+      stream_type_(stream_type),
+      parameters_(params),
+      buildable_device_(std::move(buildable_device)),
+      consumer_feedback_observer_(nullptr),
       state_(VIDEO_CAPTURE_STATE_STARTING),
       has_received_frames_(false),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 VideoCaptureController::~VideoCaptureController() = default;
 
 base::WeakPtr<VideoCaptureController>
 VideoCaptureController::GetWeakPtrForIOThread() {
@@ skipping 302 matching lines @@
 void VideoCaptureController::OnStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_STARTED;
   PerformForClientsWithOpenSession(base::Bind(&CallOnStarted));
 }
 
 void VideoCaptureController::OnStartedUsingGpuDecode() {
   PerformForClientsWithOpenSession(base::Bind(&CallOnStartedUsingGpuDecode));
 }
 
+void VideoCaptureController::CreateAndStartDeviceAsync(
+    const media::VideoCaptureParams& params,
+    BuildableDeviceCallbacks* callbacks,
+    std::unique_ptr<Ownership> context_reference) {
+  buildable_device_->CreateAndStartDeviceAsync(this, this, params, callbacks,
+                                               std::move(context_reference));
+}
+
+void VideoCaptureController::ReleaseDeviceAsync(
+    std::unique_ptr<Ownership> context_reference) {
+  buildable_device_->ReleaseDeviceAsync(this, std::move(context_reference));
+}
+
+bool VideoCaptureController::IsDeviceAlive() const {
+  return buildable_device_->IsDeviceAlive();
+}
+
+bool VideoCaptureController::CorrespondsToController(
+    const VideoCaptureController* controller) const {
+  return controller == this;
+}
+
+void VideoCaptureController::GetPhotoCapabilities(
+    media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) const {
+  buildable_device_->GetPhotoCapabilities(std::move(callback));
+}
+
+void VideoCaptureController::SetPhotoOptions(
+    media::mojom::PhotoSettingsPtr settings,
+    media::VideoCaptureDevice::SetPhotoOptionsCallback callback) {
+  buildable_device_->SetPhotoOptions(std::move(settings), std::move(callback));
+}
+
+void VideoCaptureController::TakePhoto(
+    media::VideoCaptureDevice::TakePhotoCallback callback) {
+  buildable_device_->TakePhoto(std::move(callback));
+}
+
+void VideoCaptureController::MaybeSuspend() {
+  buildable_device_->MaybeSuspendDevice();
+}
+
+void VideoCaptureController::Resume() {
+  buildable_device_->ResumeDevice();
+}
+
+void VideoCaptureController::RequestRefreshFrame() {
+  buildable_device_->RequestRefreshFrame();
+}
+
+void VideoCaptureController::SetDesktopCaptureWindowIdAsync(
+    gfx::NativeViewId window_id,
+    std::unique_ptr<Ownership> context_reference) {
+  buildable_device_->SetDesktopCaptureWindowIdAsync(
+      window_id, std::move(context_reference));
+}
+
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
       return client.get();
   }
   return nullptr;
 }
@@ skipping 63 matching lines @@
     EventHandlerAction action) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const auto& client : controller_clients_) {
     if (client->session_closed)
       continue;
     action.Run(client->event_handler, client->controller_id);
   }
 }
 
 }  // namespace content