[Mojo Video Capture] Introduce abstraction VideoCaptureSystem

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 40 matching lines @@
 #endif
 
 #if defined(OS_ANDROID)
 #include "content/browser/media/capture/screen_capture_device_android.h"
 #endif
 
 #endif  // defined(ENABLE_SCREEN_CAPTURE)
 
 namespace {
 
-// Compares two VideoCaptureFormat by checking smallest frame_size area, then
-// by _largest_ frame_rate. Used to order a VideoCaptureFormats vector so that
-// the first entry for a given resolution has the largest frame rate, as needed
-// by the ConsolidateCaptureFormats() method.
-bool IsCaptureFormatSmaller(const media::VideoCaptureFormat& format1,
-                            const media::VideoCaptureFormat& format2) {
-  DCHECK(format1.frame_size.GetCheckedArea().IsValid());
-  DCHECK(format2.frame_size.GetCheckedArea().IsValid());
-  if (format1.frame_size.GetCheckedArea().ValueOrDefault(0) ==
-      format2.frame_size.GetCheckedArea().ValueOrDefault(0)) {
-    return format1.frame_rate > format2.frame_rate;
-  }
-  return format1.frame_size.GetCheckedArea().ValueOrDefault(0) <
-         format2.frame_size.GetCheckedArea().ValueOrDefault(0);
-}
-
-bool IsCaptureFormatSizeEqual(const media::VideoCaptureFormat& format1,
-                              const media::VideoCaptureFormat& format2) {
-  DCHECK(format1.frame_size.GetCheckedArea().IsValid());
-  DCHECK(format2.frame_size.GetCheckedArea().IsValid());
-  return format1.frame_size.GetCheckedArea().ValueOrDefault(0) ==
-         format2.frame_size.GetCheckedArea().ValueOrDefault(0);
-}
-
-// This function receives a list of capture formats, removes duplicated
-// resolutions while keeping the highest frame rate for each, and forcing I420
-// pixel format.
-void ConsolidateCaptureFormats(media::VideoCaptureFormats* formats) {
-  if (formats->empty())
-    return;
-  std::sort(formats->begin(), formats->end(), IsCaptureFormatSmaller);
-  // Due to the ordering imposed, the largest frame_rate is kept while removing
-  // duplicated resolutions.
-  media::VideoCaptureFormats::iterator last =
-      std::unique(formats->begin(), formats->end(), IsCaptureFormatSizeEqual);
-  formats->erase(last, formats->end());
-  // Mark all formats as I420, since this is what the renderer side will get
-  // anyhow: the actual pixel format is decided at the device level.
-  // Don't do this for Y16 format as it is handled separatelly.
-  for (auto& format : *formats) {
-    if (format.pixel_format != media::PIXEL_FORMAT_Y16)
-      format.pixel_format = media::PIXEL_FORMAT_I420;
-  }
-}
-
 // Used for logging capture events.
 // Elements in this enum should not be deleted or rearranged; the only
 // permitted operation is to add new elements before NUM_VIDEO_CAPTURE_EVENT.
 enum VideoCaptureEvent {
   VIDEO_CAPTURE_START_CAPTURE = 0,
   VIDEO_CAPTURE_STOP_CAPTURE_OK = 1,
   VIDEO_CAPTURE_STOP_CAPTURE_DUE_TO_ERROR = 2,
   VIDEO_CAPTURE_STOP_CAPTURE_OK_NO_FRAMES_PRODUCED_BY_DEVICE = 3,
   VIDEO_CAPTURE_STOP_CAPTURE_OK_NO_FRAMES_PRODUCED_BY_DESKTOP_OR_TAB = 4,
   NUM_VIDEO_CAPTURE_EVENT
 };
 
 void LogVideoCaptureEvent(VideoCaptureEvent event) {
   UMA_HISTOGRAM_ENUMERATION("Media.VideoCaptureManager.Event", event,
                             NUM_VIDEO_CAPTURE_EVENT);
 }
 
 const media::VideoCaptureSessionId kFakeSessionId = -1;
 
 }  // namespace
 
 namespace content {
 
-// Bundles a media::VideoCaptureDeviceDescriptor with corresponding supported
-// video formats.
-struct VideoCaptureManager::DeviceInfo {
-  DeviceInfo();
-  DeviceInfo(media::VideoCaptureDeviceDescriptor descriptor);
-  DeviceInfo(const DeviceInfo& other);
-  ~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(VideoCaptureController* controller,
                             media::VideoCaptureSessionId session_id,
                             const media::VideoCaptureParams& params);
   VideoCaptureController* controller() const { return controller_; }
   media::VideoCaptureSessionId session_id() const { return session_id_; }
   media::VideoCaptureParams params() const { return params_; }
 
  private:
   VideoCaptureController* const controller_;
   const media::VideoCaptureSessionId session_id_;
   const media::VideoCaptureParams params_;
 };
 
-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(
     VideoCaptureController* controller,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params)
     : controller_(controller), session_id_(session_id), params_(params) {}
 
 VideoCaptureManager::VideoCaptureManager(
-    std::unique_ptr<media::VideoCaptureDeviceFactory> factory,
+    std::unique_ptr<media::VideoCaptureSystem> video_capture_system,
     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)) {}
+      video_capture_system_(std::move(video_capture_system)) {}
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(controllers_.empty());
   DCHECK(device_start_request_queue_.empty());
 }
 
 void VideoCaptureManager::AddVideoCaptureObserver(
     media::VideoCaptureObserver* observer) {
   DCHECK(observer);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 23 matching lines @@
     MediaStreamProviderListener* listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   listeners_.RemoveObserver(listener);
 }
 
 void VideoCaptureManager::EnumerateDevices(
     const EnumerationCallback& client_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureManager::EnumerateDevices";
 
-  // Bind a callback to ConsolidateDevicesInfoOnDeviceThread() with an argument
-  // for another callback to OnDevicesInfoEnumerated() to be run in the current
-  // loop, i.e. IO loop. Pass a timer for UMA histogram collection.
-  base::Callback<void(std::unique_ptr<VideoCaptureDeviceDescriptors>)>
-      devices_enumerated_callback = base::Bind(
-          &VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread, this,
-          media::BindToCurrentLoop(base::Bind(
-              &VideoCaptureManager::OnDevicesInfoEnumerated, this,
-              base::Owned(new base::ElapsedTimer()), client_callback)),
-          devices_info_cache_);
-  // OK to use base::Unretained() since we own the VCDFactory and |this| is
-  // bound in |devices_enumerated_callback|.
+  // OK to use base::Unretained(video_capture_system_) since we own the
+  // |video_capture_system_| and |this| is bound in
+  // |devices_enumerated_callback|.
   device_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&media::VideoCaptureDeviceFactory::EnumerateDeviceDescriptors,
-                 base::Unretained(video_capture_device_factory_.get()),
-                 devices_enumerated_callback));
-}
-
-const media::VideoCaptureDeviceDescriptor*
-VideoCaptureManager::LookupDeviceDescriptor(const std::string& id) {
-  const DeviceInfo* info = GetDeviceInfoById(id);
-  return info ? (&info->descriptor) : nullptr;
+      base::Bind(&media::VideoCaptureSystem::GetDeviceInfosAsync,
+                 base::Unretained(video_capture_system_.get()),
+                 // Pass a timer for UMA histogram collection.
+                 media::BindToCurrentLoop(base::Bind(
+                     &VideoCaptureManager::OnDeviceInfosReceived, this,
+                     base::Owned(new base::ElapsedTimer()), client_callback))));
 }
 
 int VideoCaptureManager::Open(const MediaStreamDevice& device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Generate a new id for the session being opened.
   const media::VideoCaptureSessionId capture_session_id =
       new_capture_session_id_++;
 
   DCHECK(sessions_.find(capture_session_id) == sessions_.end());
@@ skipping 70 matching lines @@
         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());
+  const media::VideoCaptureDeviceInfo* 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()));
@@ skipping 10 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeviceStartQueue::iterator request = device_start_request_queue_.begin();
   if (request == device_start_request_queue_.end())
     return;
 
   VideoCaptureController* const controller = request->controller();
 
   DVLOG(3) << "HandleQueuedStartRequest, Post start to device thread, device = "
            << controller->device_id()
            << " start id = " << controller->serial_id();
+  // The unit test VideoCaptureManagerTest.OpenNotExisting requires us to fail
+  // synchronously if the stream_type is MEDIA_DEVICE_VIDEO_CAPTURE and no
+  // DeviceInfo matching the requested id is present (which is the case when
+  // requesting a device with a bogus id). Note, that since other types of
+  // failure during startup of the device are allowed to be reported
+  // asynchronously, this requirement is questionable.
+  // TODO(chfremer): Check if any production code actually depends on this
+  // requirement. If not, relax the requirement in the test and remove the below
+  // if block.
+  if (controller->stream_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
+    const media::VideoCaptureDeviceInfo* device_info =
+        GetDeviceInfoById(controller->device_id());
+    if (!device_info) {
+      OnDeviceStartFailed(controller);
+      return;
+    }
+  }
+
+  media::VideoCaptureDeviceInfo* device_info =
+      GetDeviceInfoById(controller->device_id());
+  DCHECK(device_info);
+  for (auto& observer : capture_observers_)
+    observer.OnVideoCaptureStarted(device_info->descriptor.facing);
 
   // 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),
                  GetControllerSharedRef(controller)));
 }
 
-void VideoCaptureManager::WillStartDevice(media::VideoFacingMode facing_mode) {
-  for (auto& observer : capture_observers_)
-    observer.OnVideoCaptureStarted(facing_mode);
-}
-
-void VideoCaptureManager::DidStartDevice(VideoCaptureController* controller) {
+void VideoCaptureManager::OnDeviceStarted(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);
+
   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++;
@@ skipping 170 matching lines @@
   return GetDeviceSupportedFormats(it->second.id, supported_formats);
 }
 
 bool VideoCaptureManager::GetDeviceSupportedFormats(
     const std::string& device_id,
     media::VideoCaptureFormats* supported_formats) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(supported_formats->empty());
 
   // Return all available formats of the device, regardless its started state.
-  DeviceInfo* existing_device = GetDeviceInfoById(device_id);
+  media::VideoCaptureDeviceInfo* existing_device = GetDeviceInfoById(device_id);
   if (existing_device)
     *supported_formats = existing_device->supported_formats;
   return true;
 }
 
 bool VideoCaptureManager::GetDeviceFormatsInUse(
     media::VideoCaptureSessionId capture_session_id,
     media::VideoCaptureFormats* formats_in_use) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(formats_in_use->empty());
@@ skipping 137 matching lines @@
 }
 
 void VideoCaptureManager::OnClosed(
     MediaStreamType stream_type,
     media::VideoCaptureSessionId capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (auto& listener : listeners_)
     listener.Closed(stream_type, capture_session_id);
 }
 
-void VideoCaptureManager::OnDevicesInfoEnumerated(
+void VideoCaptureManager::OnDeviceInfosReceived(
     base::ElapsedTimer* timer,
     const EnumerationCallback& client_callback,
-    const VideoCaptureManager::DeviceInfos& new_devices_info_cache) {
+    const std::vector<media::VideoCaptureDeviceInfo>& device_infos) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UMA_HISTOGRAM_TIMES(
       "Media.VideoCaptureManager.GetAvailableDevicesInfoOnDeviceThreadTime",
       timer->Elapsed());
-  devices_info_cache_ = new_devices_info_cache;
+  devices_info_cache_ = device_infos;
 
   // Walk the |devices_info_cache_| and produce a
-  // media::VideoCaptureDeviceDescriptors for return purposes.
+  // media::VideoCaptureDeviceDescriptors for |client_callback|.
   media::VideoCaptureDeviceDescriptors devices;
   std::vector<std::tuple<media::VideoCaptureDeviceDescriptor,
                          media::VideoCaptureFormats>>
       descriptors_and_formats;
   for (const auto& it : devices_info_cache_) {
     devices.emplace_back(it.descriptor);
     descriptors_and_formats.emplace_back(it.descriptor, it.supported_formats);
     MediaInternals::GetInstance()->UpdateVideoCaptureDeviceCapabilities(
         descriptors_and_formats);
   }
 
   client_callback.Run(devices);
 }
 
-void VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread(
-    base::Callback<void(const VideoCaptureManager::DeviceInfos&)>
-        on_devices_enumerated_callback,
-    const VideoCaptureManager::DeviceInfos& old_device_info_cache,
-    std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors_snapshot) {
-  DCHECK(device_task_runner_->BelongsToCurrentThread());
-  // Construct |new_devices_info_cache| with the cached devices that are still
-  // present in the system, and remove their names from |names_snapshot|, so we
-  // keep there the truly new devices.
-  VideoCaptureManager::DeviceInfos new_devices_info_cache;
-  for (const auto& device_info : old_device_info_cache) {
-    for (VideoCaptureDeviceDescriptors::iterator it =
-             descriptors_snapshot->begin();
-         it != descriptors_snapshot->end(); ++it) {
-      if (device_info.descriptor.device_id == it->device_id) {
-        new_devices_info_cache.push_back(device_info);
-        descriptors_snapshot->erase(it);
-        break;
-      }
-    }
-  }
-
-  // Get the device info for the new devices in |names_snapshot|.
-  for (const auto& it : *descriptors_snapshot) {
-    DeviceInfo device_info(it);
-    video_capture_device_factory_->GetSupportedFormats(
-        it, &device_info.supported_formats);
-    ConsolidateCaptureFormats(&device_info.supported_formats);
-    new_devices_info_cache.push_back(device_info);
-  }
-
-  on_devices_enumerated_callback.Run(new_devices_info_cache);
-}
-
 void VideoCaptureManager::DestroyControllerIfNoClients(
     VideoCaptureController* controller) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Removal of the last client stops the device.
   if (!controller->HasActiveClient() && !controller->HasPausedClient()) {
     DVLOG(1) << "VideoCaptureManager stopping device (type = "
              << controller->stream_type()
              << ", id = " << controller->device_id() << ")";
 
     // The VideoCaptureController is removed from |controllers_| immediately.
@@ skipping 48 matching lines @@
     VideoCaptureController* controller) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& entry : controllers_) {
     if (entry.get() == controller)
       return entry;
   }
   return nullptr;
 }
 
-VideoCaptureManager::DeviceInfo* VideoCaptureManager::GetDeviceInfoById(
+media::VideoCaptureDeviceInfo* 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,
@@ skipping 10 matching lines @@
   VideoCaptureController* const existing_device =
       LookupControllerByMediaTypeAndDeviceId(device_info.type, device_info.id);
   if (existing_device) {
     DCHECK_EQ(device_info.type, existing_device->stream_type());
     return existing_device;
   }
 
   VideoCaptureController* new_controller = new VideoCaptureController(
       device_info.id, device_info.type, params,
       base::MakeUnique<InProcessBuildableVideoCaptureDevice>(
-          device_task_runner_, video_capture_device_factory_.get()));
+          device_task_runner_, video_capture_system_.get()));
   controllers_.emplace_back(new_controller);
   return new_controller;
 }
 
 base::Optional<CameraCalibration> VideoCaptureManager::GetCameraCalibration(
     const std::string& device_id) {
-  VideoCaptureManager::DeviceInfo* info = GetDeviceInfoById(device_id);
+  media::VideoCaptureDeviceInfo* info = GetDeviceInfoById(device_id);
   if (!info)
     return base::Optional<CameraCalibration>();
   return info->descriptor.camera_calibration;
 }
 
 #if defined(OS_ANDROID)
 void VideoCaptureManager::OnApplicationStateChange(
     base::android::ApplicationState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 44 matching lines @@
       // 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