[Mojo Video Capture] Add support to BuildableVideoCaptureDevice for aborting the device start.

content/browser/renderer_host/media/video_capture_manager.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_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 124 matching lines @@
   ~DeviceInfo();
   DeviceInfo& operator=(const DeviceInfo& other);
 
   media::VideoCaptureDeviceDescriptor descriptor;
   media::VideoCaptureFormats supported_formats;
 };
 
 // Class used for queuing request for starting a device.
 class VideoCaptureManager::CaptureDeviceStartRequest {
  public:
-  CaptureDeviceStartRequest(int serial_id,
+  CaptureDeviceStartRequest(VideoCaptureController* controller,
                             media::VideoCaptureSessionId session_id,
                             const media::VideoCaptureParams& params);
-  int serial_id() const { return serial_id_; }
+  VideoCaptureController* controller() const { return controller_; }
   media::VideoCaptureSessionId session_id() const { return session_id_; }
   media::VideoCaptureParams params() const { return params_; }
 
-  // Set to true if the device should be stopped before it has successfully
-  // been started.
-  bool abort_start() const { return abort_start_; }
-  void set_abort_start() { abort_start_ = true; }
-
  private:
-  const int serial_id_;
+  VideoCaptureController* const controller_;
   const media::VideoCaptureSessionId session_id_;
   const media::VideoCaptureParams params_;
-  // Set to true if the device should be stopped before it has successfully
-  // been started.
-  bool abort_start_;
 };
 
 VideoCaptureManager::DeviceInfo::DeviceInfo() = default;
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     media::VideoCaptureDeviceDescriptor descriptor)
     : descriptor(descriptor) {}
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     const VideoCaptureManager::DeviceInfo& other) = default;
 
 VideoCaptureManager::DeviceInfo::~DeviceInfo() = default;
 
 VideoCaptureManager::DeviceInfo& VideoCaptureManager::DeviceInfo::operator=(
     const VideoCaptureManager::DeviceInfo& other) = default;
 
 VideoCaptureManager::CaptureDeviceStartRequest::CaptureDeviceStartRequest(
-    int serial_id,
+    VideoCaptureController* controller,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params)
-    : serial_id_(serial_id),
-      session_id_(session_id),
-      params_(params),
-      abort_start_(false) {}
+    : controller_(controller), session_id_(session_id), params_(params) {}
 
 VideoCaptureManager::VideoCaptureManager(
     std::unique_ptr<media::VideoCaptureDeviceFactory> factory,
     scoped_refptr<base::SingleThreadTaskRunner> device_task_runner)
     : device_task_runner_(std::move(device_task_runner)),
       new_capture_session_id_(1),
       video_capture_device_factory_(std::move(factory)) {}
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(controllers_.empty());
-  DCHECK(device_start_queue_.empty());
+  DCHECK(device_start_request_queue_.empty());
 }
 
 void VideoCaptureManager::AddVideoCaptureObserver(
     media::VideoCaptureObserver* observer) {
   DCHECK(observer);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   capture_observers_.AddObserver(observer);
 }
 
 void VideoCaptureManager::RemoveAllVideoCaptureObservers() {
@@ skipping 76 matching lines @@
 void VideoCaptureManager::Close(int capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureManager::Close, id " << capture_session_id;
 
   SessionMap::iterator session_it = sessions_.find(capture_session_id);
   if (session_it == sessions_.end()) {
     NOTREACHED();
     return;
   }
 
-  VideoCaptureController* const existing_device = LookupControllerByTypeAndId(
-      session_it->second.type, session_it->second.id);
+  VideoCaptureController* const existing_device =
+      LookupControllerByMediaTypeAndDeviceId(session_it->second.type,
+                                             session_it->second.id);
   if (existing_device) {
     // Remove any client that is still using the session. This is safe to call
     // even if there are no clients using the session.
     existing_device->StopSession(capture_session_id);
 
     // StopSession() may have removed the last client, so we might need to
     // close the device.
     DestroyControllerIfNoClients(existing_device);
   }
 
   // Notify listeners asynchronously, and forget the session.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureManager::OnClosed, this,
                             session_it->second.type, capture_session_id));
   sessions_.erase(session_it);
 }
 
 void VideoCaptureManager::QueueStartDevice(
     media::VideoCaptureSessionId session_id,
     VideoCaptureController* controller,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  device_start_queue_.push_back(
-      CaptureDeviceStartRequest(controller->serial_id(), session_id, params));
-  if (device_start_queue_.size() == 1)
-    HandleQueuedStartRequest();
+  device_start_request_queue_.push_back(
+      CaptureDeviceStartRequest(controller, session_id, params));
+  if (device_start_request_queue_.size() == 1)
+    ProcessDeviceStartRequestQueue();
 }
 
 void VideoCaptureManager::DoStopDevice(VideoCaptureController* controller) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(mcasas): use a helper function https://crbug.com/624854.
   DCHECK(std::find_if(
              controllers_.begin(), controllers_.end(),
              [controller](
                  const scoped_refptr<VideoCaptureController>& device_entry) {
                return device_entry.get() == controller;
              }) != controllers_.end());
 
-  // Find the matching start request.
-  for (DeviceStartQueue::reverse_iterator request =
-           device_start_queue_.rbegin();
-       request != device_start_queue_.rend(); ++request) {
-    if (request->serial_id() == controller->serial_id()) {
-      request->set_abort_start();
-      DVLOG(3) << "DoStopDevice, aborting start request for device "
-               << controller->device_id()
-               << " serial_id = " << controller->serial_id();
+  // If start request has not yet started processing, i.e. if it is not at the
+  // beginning of the queue, remove it from the queue.
+  auto request_iter = device_start_request_queue_.begin();
+  if (request_iter != device_start_request_queue_.end()) {
+    request_iter =
+        std::find_if(++request_iter, device_start_request_queue_.end(),
+                     [controller](const CaptureDeviceStartRequest& request) {
+                       return request.controller() == controller;
+                     });
+    if (request_iter != device_start_request_queue_.end()) {
+      device_start_request_queue_.erase(request_iter);
       return;
     }
   }
 
   const DeviceInfo* device_info = GetDeviceInfoById(controller->device_id());
   if (device_info != nullptr) {
     for (auto& observer : capture_observers_)
       observer.OnVideoCaptureStopped(device_info->descriptor.facing);
   }
 
   DVLOG(3) << "DoStopDevice. Send stop request for device = "
            << controller->device_id()
            << " serial_id = " << controller->serial_id() << ".";
   controller->OnLog(base::StringPrintf("Stopping device: id: %s",
                                        controller->device_id().c_str()));
 
-  if (controller->IsDeviceAlive()) {
-    // Since we may be removing |controller| from |controllers_| while
-    // ReleaseDeviceAsnyc() is executing, we pass it shared ownership to
-    // |controller|.
-    controller->ReleaseDeviceAsync(base::Bind(
-        [](scoped_refptr<VideoCaptureController>) {},
-        GetControllerSharedRefFromSerialId(controller->serial_id())));
-  }
+  // Since we may be removing |controller| from |controllers_| while
+  // ReleaseDeviceAsnyc() is executing, we pass it shared ownership to
+  // |controller|.
+  controller->ReleaseDeviceAsync(
+      base::Bind([](scoped_refptr<VideoCaptureController>) {},
+                 GetControllerSharedRef(controller)));
 }
 
-void VideoCaptureManager::HandleQueuedStartRequest() {
+void VideoCaptureManager::ProcessDeviceStartRequestQueue() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  // Remove all start requests that have been aborted.
-  while (device_start_queue_.begin() != device_start_queue_.end() &&
-         device_start_queue_.begin()->abort_start()) {
-    device_start_queue_.pop_front();
-  }
-  DeviceStartQueue::iterator request = device_start_queue_.begin();
-  if (request == device_start_queue_.end())
+  DeviceStartQueue::iterator request = device_start_request_queue_.begin();
+  if (request == device_start_request_queue_.end())
     return;
 
-  const int serial_id = request->serial_id();
-  VideoCaptureController* const controller =
-      LookupControllerBySerialId(serial_id);
-  DCHECK(controller);
+  VideoCaptureController* const controller = request->controller();
 
   DVLOG(3) << "HandleQueuedStartRequest, Post start to device thread, device = "
            << controller->device_id()
            << " start id = " << controller->serial_id();
 
   // The method CreateAndStartDeviceAsync() is going to run asynchronously.
   // Since we may be removing the controller while it is executing, we need to
   // pass it shared ownership to itself so that it stays alive while executing.
   // And since the execution may make callbacks into |this|, we also need
   // to pass it shared ownership to |this|.
   // TODO(chfremer): Check if request->params() can actually be different from
   // controller->parameters, and simplify if this is not the case.
   controller->CreateAndStartDeviceAsync(
       request->params(), static_cast<BuildableDeviceCallbacks*>(this),
       base::Bind([](scoped_refptr<VideoCaptureManager>,
                     scoped_refptr<VideoCaptureController>) {},
                  scoped_refptr<VideoCaptureManager>(this),
-                 GetControllerSharedRefFromSerialId(serial_id)));
+                 GetControllerSharedRef(controller)));
 }
 
 void VideoCaptureManager::WillStartDevice(media::VideoFacingMode facing_mode) {
   for (auto& observer : capture_observers_)
     observer.OnVideoCaptureStarted(facing_mode);
 }
 
 void VideoCaptureManager::DidStartDevice(VideoCaptureController* controller) {
   DVLOG(3) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!device_start_request_queue_.empty());
+  DCHECK_EQ(controller, device_start_request_queue_.begin()->controller());
   DCHECK(controller);
-  DCHECK_EQ(controller->serial_id(), device_start_queue_.begin()->serial_id());
-  if (device_start_queue_.front().abort_start()) {
-    // A request to release the device may have arrived during the asynchronous
-    // device startup.
-    DVLOG(3) << "Device release request has been issued while device was "
-             << "starting up asynchronously.";
-    controller->ReleaseDeviceAsync(base::Bind(
-        [](scoped_refptr<VideoCaptureController>) {},
-        GetControllerSharedRefFromSerialId(controller->serial_id())));
-  } else {
-    if (controller->stream_type() == MEDIA_DESKTOP_VIDEO_CAPTURE) {
-      const media::VideoCaptureSessionId session_id =
-          device_start_queue_.front().session_id();
-      DCHECK(session_id != kFakeSessionId);
-      MaybePostDesktopCaptureWindowId(session_id);
-    }
+  if (controller->stream_type() == MEDIA_DESKTOP_VIDEO_CAPTURE) {
+    const media::VideoCaptureSessionId session_id =
+        device_start_request_queue_.front().session_id();
+    DCHECK(session_id != kFakeSessionId);
+    MaybePostDesktopCaptureWindowId(session_id);
+  }
 
-    auto it = photo_request_queue_.begin();
-    while (it != photo_request_queue_.end()) {
-      auto request = it++;
-      VideoCaptureController* maybe_entry =
-          LookupControllerBySessionId(request->first);
-      if (maybe_entry && maybe_entry->IsDeviceAlive()) {
-        request->second.Run();
-        photo_request_queue_.erase(request);
-      }
+  auto it = photo_request_queue_.begin();
+  while (it != photo_request_queue_.end()) {
+    auto request = it++;
+    VideoCaptureController* maybe_entry =
+        LookupControllerBySessionId(request->first);
+    if (maybe_entry && maybe_entry->IsDeviceAlive()) {
+      request->second.Run();
+      photo_request_queue_.erase(request);
     }
   }
 
-  device_start_queue_.pop_front();
-  HandleQueuedStartRequest();
+  device_start_request_queue_.pop_front();
+  ProcessDeviceStartRequestQueue();
 }
 
 void VideoCaptureManager::OnDeviceStartFailed(
     VideoCaptureController* controller) {
   const std::string log_message = base::StringPrintf(
       "Starting device %s has failed. Maybe recently disconnected?",
       controller->device_id().c_str());
   DLOG(ERROR) << log_message;
   controller->OnLog(log_message);
   controller->OnError();
 
-  device_start_queue_.pop_front();
-  HandleQueuedStartRequest();
+  device_start_request_queue_.pop_front();
+  ProcessDeviceStartRequestQueue();
 }
 
-void VideoCaptureManager::StartCaptureForClient(
+void VideoCaptureManager::OnDeviceStartAborted() {
+  device_start_request_queue_.pop_front();
+  ProcessDeviceStartRequestQueue();
+}
+
+void VideoCaptureManager::ConnectClient(
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler,
     const DoneCB& done_cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << __func__ << ", session_id = " << session_id << ", request: "
            << media::VideoCaptureFormat::ToString(params.requested_format);
 
   VideoCaptureController* controller =
       GetOrCreateController(session_id, params);
   if (!controller) {
     done_cb.Run(base::WeakPtr<VideoCaptureController>());
     return;
   }
 
   LogVideoCaptureEvent(VIDEO_CAPTURE_START_CAPTURE);
 
   // First client starts the device.
   if (!controller->HasActiveClient() && !controller->HasPausedClient()) {
     DVLOG(1) << "VideoCaptureManager starting device (id = "
              << controller->device_id() << ")";
     QueueStartDevice(session_id, controller, params);
   }
   // Run the callback first, as AddClient() may trigger OnFrameInfo().
   done_cb.Run(controller->GetWeakPtrForIOThread());
   controller->AddClient(client_id, client_handler, session_id, params);
 }
 
-void VideoCaptureManager::StopCaptureForClient(
+void VideoCaptureManager::DisconnectClient(
     VideoCaptureController* controller,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler,
     bool aborted_due_to_error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(controller);
   DCHECK(client_handler);
 
   if (!IsControllerPointerValid(controller)) {
     NOTREACHED();
@@ skipping 127 matching lines @@
 }
 
 bool VideoCaptureManager::GetDeviceFormatsInUse(
     MediaStreamType stream_type,
     const std::string& device_id,
     media::VideoCaptureFormats* formats_in_use) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(formats_in_use->empty());
   // Return the currently in-use format(s) of the device, if it's started.
   VideoCaptureController* device_in_use =
-      LookupControllerByTypeAndId(stream_type, device_id);
+      LookupControllerByMediaTypeAndDeviceId(stream_type, device_id);
   if (device_in_use) {
     // Currently only one format-in-use is supported at the VCC level.
     formats_in_use->push_back(device_in_use->GetVideoCaptureFormat());
   }
   return true;
 }
 
 void VideoCaptureManager::SetDesktopCaptureWindowId(
     media::VideoCaptureSessionId session_id,
     gfx::NativeViewId window_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(2) << "SetDesktopCaptureWindowId called for session " << session_id;
 
   notification_window_ids_[session_id] = window_id;
   MaybePostDesktopCaptureWindowId(session_id);
 }
 
 void VideoCaptureManager::MaybePostDesktopCaptureWindowId(
     media::VideoCaptureSessionId session_id) {
   SessionMap::iterator session_it = sessions_.find(session_id);
   if (session_it == sessions_.end())
     return;
 
-  VideoCaptureController* const existing_device = LookupControllerByTypeAndId(
-      session_it->second.type, session_it->second.id);
+  VideoCaptureController* const existing_device =
+      LookupControllerByMediaTypeAndDeviceId(session_it->second.type,
+                                             session_it->second.id);
   if (!existing_device) {
     DVLOG(2) << "Failed to find an existing screen capture device.";
     return;
   }
 
   if (!existing_device->IsDeviceAlive()) {
     DVLOG(2) << "Screen capture device not yet started.";
     return;
   }
 
@@ skipping 176 matching lines @@
   }
 }
 
 VideoCaptureController* VideoCaptureManager::LookupControllerBySessionId(
     int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SessionMap::const_iterator session_it = sessions_.find(session_id);
   if (session_it == sessions_.end())
     return nullptr;
 
-  return LookupControllerByTypeAndId(session_it->second.type,
-                                     session_it->second.id);
+  return LookupControllerByMediaTypeAndDeviceId(session_it->second.type,
+                                                session_it->second.id);
 }
 
-VideoCaptureController* VideoCaptureManager::LookupControllerByTypeAndId(
+VideoCaptureController*
+VideoCaptureManager::LookupControllerByMediaTypeAndDeviceId(
     MediaStreamType type,
     const std::string& device_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& entry : controllers_) {
     if (type == entry->stream_type() && device_id == entry->device_id())
       return entry.get();
   }
   return nullptr;
 }
 
 bool VideoCaptureManager::IsControllerPointerValid(
     const VideoCaptureController* controller) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return base::ContainsValue(controllers_, controller);
 }
 
-VideoCaptureController* VideoCaptureManager::LookupControllerBySerialId(
-    int serial_id) const {
+scoped_refptr<VideoCaptureController>
+VideoCaptureManager::GetControllerSharedRef(
+    VideoCaptureController* controller) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& entry : controllers_) {
-    if (entry->serial_id() == serial_id)
-      return entry.get();
-  }
-  return nullptr;
-}
-
-scoped_refptr<VideoCaptureController>
-VideoCaptureManager::GetControllerSharedRefFromSerialId(int serial_id) const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  for (const auto& entry : controllers_) {
-    if (entry->serial_id() == serial_id)
+    if (entry.get() == controller)
       return entry;
   }
   return nullptr;
 }
 
 VideoCaptureManager::DeviceInfo* VideoCaptureManager::GetDeviceInfoById(
     const std::string& id) {
   for (auto& it : devices_info_cache_) {
     if (it.descriptor.device_id == id)
       return &it;
   }
   return nullptr;
 }
 
 VideoCaptureController* VideoCaptureManager::GetOrCreateController(
     media::VideoCaptureSessionId capture_session_id,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   SessionMap::iterator session_it = sessions_.find(capture_session_id);
   if (session_it == sessions_.end())
     return nullptr;
   const MediaStreamDevice& device_info = session_it->second;
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   VideoCaptureController* const existing_device =
-      LookupControllerByTypeAndId(device_info.type, device_info.id);
+      LookupControllerByMediaTypeAndDeviceId(device_info.type, device_info.id);
   if (existing_device) {
     DCHECK_EQ(device_info.type, existing_device->stream_type());
     return existing_device;
   }
 
-  VideoCaptureController* new_device_entry = new VideoCaptureController(
+  VideoCaptureController* new_controller = new VideoCaptureController(
       device_info.id, device_info.type, params,
       base::MakeUnique<InProcessBuildableVideoCaptureDevice>(
           device_task_runner_, video_capture_device_factory_.get()));
-  controllers_.emplace_back(new_device_entry);
-  return new_device_entry;
+  controllers_.emplace_back(new_controller);
+  return new_controller;
 }
 
 base::Optional<CameraCalibration> VideoCaptureManager::GetCameraCalibration(
     const std::string& device_id) {
   VideoCaptureManager::DeviceInfo* info = GetDeviceInfoById(device_id);
   if (!info)
     return base::Optional<CameraCalibration>();
   return info->descriptor.camera_calibration;
 }
 
@@ skipping 31 matching lines @@
 
   for (auto& controller : controllers_) {
     // Do not resume Content Video Capture devices, e.g. Tab or Screen capture.
     // Do not try to restart already running devices.
     if (controller->stream_type() != MEDIA_DEVICE_VIDEO_CAPTURE ||
         controller->IsDeviceAlive())
       continue;
 
     // Check if the device is already in the start queue.
     bool device_in_queue = false;
-    for (auto& request : device_start_queue_) {
+    for (auto& request : device_start_request_queue_) {
       if (request.serial_id() == controller->serial_id()) {
         device_in_queue = true;
         break;
       }
     }
 
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, controller.get(),
                        controller->parameters());
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content