[Mojo Video Capture] Split interface 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 149 matching lines @@
 
 mojo::ScopedSharedBufferHandle
 VideoCaptureController::BufferContext::CloneHandle() {
   return buffer_handle_->Clone();
 }
 
 VideoCaptureController::VideoCaptureController(
     const std::string& device_id,
     MediaStreamType stream_type,
     const media::VideoCaptureParams& params,
-    std::unique_ptr<BuildableVideoCaptureDevice> buildable_device)
+    std::unique_ptr<VideoCaptureDeviceLauncher> device_launcher)
     : 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),
+      device_launcher_(std::move(device_launcher)),
+      device_launch_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() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-void VideoCaptureController::SetConsumerFeedbackObserver(
-    std::unique_ptr<media::VideoFrameConsumerFeedbackObserver>
-        consumer_feedback_observer) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  consumer_feedback_observer_ = std::move(consumer_feedback_observer);
-  // Update existing BufferContext entries.
-  for (auto& entry : buffer_contexts_)
-    entry.set_consumer_feedback_observer(consumer_feedback_observer_.get());
-}
-
 void VideoCaptureController::AddClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::AddClient() -- id=" << id
            << ", session_id=" << session_id << ", params.requested_format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
 
@@ skipping 168 matching lines @@
 }
 
 void VideoCaptureController::OnNewBufferHandle(
     int buffer_id,
     std::unique_ptr<media::VideoCaptureDevice::Client::Buffer::HandleProvider>
         handle_provider) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(FindUnretiredBufferContextFromBufferId(buffer_id) ==
          buffer_contexts_.end());
   buffer_contexts_.emplace_back(
-      next_buffer_context_id_++, buffer_id, consumer_feedback_observer_.get(),
+      next_buffer_context_id_++, buffer_id, launched_device_.get(),
       handle_provider->GetHandleForInterProcessTransit());
 }
 
 void VideoCaptureController::OnFrameReadyInBuffer(
     int buffer_id,
     int frame_feedback_id,
     std::unique_ptr<
         media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
         buffer_read_permission,
     media::mojom::VideoFrameInfoPtr frame_info) {
@@ skipping 91 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::OnDeviceLaunched(
+    std::unique_ptr<LaunchedVideoCaptureDevice> device) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  launched_device_ = std::move(device);
+  for (auto& entry : buffer_contexts_)
+    entry.set_consumer_feedback_observer(launched_device_.get());
+  if (device_launch_observer_) {
+    device_launch_observer_->OnDeviceLaunched(this);
+    device_launch_observer_ = nullptr;
+  }
+}
+
+void VideoCaptureController::OnDeviceLaunchFailed() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (device_launch_observer_) {
+    device_launch_observer_->OnDeviceLaunchFailed(this);
+    device_launch_observer_ = nullptr;
+  }
+}
+
+void VideoCaptureController::OnDeviceLaunchAborted() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (device_launch_observer_) {
+    device_launch_observer_->OnDeviceLaunchAborted();
+    device_launch_observer_ = nullptr;
+  }
+}
+
 void VideoCaptureController::CreateAndStartDeviceAsync(
     const media::VideoCaptureParams& params,
-    BuildableVideoCaptureDevice::Callbacks* callbacks,
+    VideoCaptureDeviceLaunchObserver* observer,
     base::OnceClosure done_cb) {
-  buildable_device_->CreateAndStartDeviceAsync(this, params, callbacks,
-                                               std::move(done_cb));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  device_launch_observer_ = observer;
+  device_launcher_->LaunchDeviceAsync(device_id_, stream_type_, params,
+                                      GetWeakPtrForIOThread(), this,
+                                      std::move(done_cb));
 }
 
 void VideoCaptureController::ReleaseDeviceAsync(base::OnceClosure done_cb) {
-  buildable_device_->ReleaseDeviceAsync(this, std::move(done_cb));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!launched_device_) {
+    device_launcher_->AbortLaunch();
+    return;
+  }
+  launched_device_.reset();
 }
 
 bool VideoCaptureController::IsDeviceAlive() const {
-  return buildable_device_->IsDeviceAlive();
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  return launched_device_ != nullptr;
 }
 
 void VideoCaptureController::GetPhotoCapabilities(
     media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) const {
-  buildable_device_->GetPhotoCapabilities(std::move(callback));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_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));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_device_->SetPhotoOptions(std::move(settings), std::move(callback));
 }
 
 void VideoCaptureController::TakePhoto(
     media::VideoCaptureDevice::TakePhotoCallback callback) {
-  buildable_device_->TakePhoto(std::move(callback));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_device_->TakePhoto(std::move(callback));
 }
 
 void VideoCaptureController::MaybeSuspend() {
-  buildable_device_->MaybeSuspendDevice();
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_device_->MaybeSuspendDevice();
 }
 
 void VideoCaptureController::Resume() {
-  buildable_device_->ResumeDevice();
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_device_->ResumeDevice();
 }
 
 void VideoCaptureController::RequestRefreshFrame() {
-  buildable_device_->RequestRefreshFrame();
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_device_->RequestRefreshFrame();
 }
 
 void VideoCaptureController::SetDesktopCaptureWindowIdAsync(
     gfx::NativeViewId window_id,
     base::OnceClosure done_cb) {
-  buildable_device_->SetDesktopCaptureWindowIdAsync(window_id,
-                                                    std::move(done_cb));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(launched_device_);
+  launched_device_->SetDesktopCaptureWindowIdAsync(window_id,
+                                                   std::move(done_cb));
 }
 
 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();
   }
@@ skipping 65 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