[Mojo Video Capture] Create abstraction VideoCaptureProvider

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/browser/media/capture/web_contents_video_capture_device.h"
 #include "content/browser/media/media_internals.h"
-#include "content/browser/renderer_host/media/in_process_buildable_video_capture_device.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_facing.h"
 #include "media/capture/video/video_capture_buffer_pool_impl.h"
 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h"
@@ skipping 58 matching lines @@
   const media::VideoCaptureParams params_;
 };
 
 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::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_system_(std::move(video_capture_system)) {}
+    std::unique_ptr<VideoCaptureProvider> video_capture_provider)
+    : new_capture_session_id_(1),
+      video_capture_provider_(std::move(video_capture_provider)) {}
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(controllers_.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() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   capture_observers_.Clear();
 }
 
 void VideoCaptureManager::RegisterListener(
     MediaStreamProviderListener* listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(listener);
-  DCHECK(device_task_runner_);
   listeners_.AddObserver(listener);
 #if defined(OS_ANDROID)
   application_state_has_running_activities_ = true;
   app_status_listener_.reset(new base::android::ApplicationStatusListener(
       base::Bind(&VideoCaptureManager::OnApplicationStateChange,
                  base::Unretained(this))));
 #endif
 }
 
 void VideoCaptureManager::UnregisterListener(
     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";
 
-  // 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::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))));
+  // Pass a timer for UMA histogram collection.
+  video_capture_provider_->GetDeviceInfosAsync(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 615 matching lines @@
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   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_system_.get()));
+  VideoCaptureController* new_controller =
+      new VideoCaptureController(device_info.id, device_info.type, params,
+                                 video_capture_provider_->CreateBuildableDevice(
+                                     device_info.id, device_info.type));
   controllers_.emplace_back(new_controller);
   return new_controller;
 }
 
 base::Optional<CameraCalibration> VideoCaptureManager::GetCameraCalibration(
     const std::string& device_id) {
   media::VideoCaptureDeviceInfo* info = GetDeviceInfoById(device_id);
   if (!info)
     return base::Optional<CameraCalibration>();
   return info->descriptor.camera_calibration;
@@ skipping 51 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