[Mojo Video Capture] Split interface BuildableVideoCaptureDevice

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/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"
 #include "media/capture/video/video_capture_device.h"
 #include "media/capture/video/video_capture_device_client.h"
@@ skipping 240 matching lines @@
   // 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. See crbug.com/708251
   if (controller->stream_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
     const media::VideoCaptureDeviceInfo* device_info =
         GetDeviceInfoById(controller->device_id());
     if (!device_info) {
-      OnDeviceStartFailed(controller);
+      OnDeviceLaunchFailed(controller);
       return;
     }
     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<BuildableVideoCaptureDevice::Callbacks*>(this),
+      request->params(), static_cast<VideoCaptureDeviceLaunchObserver*>(this),
       base::Bind([](scoped_refptr<VideoCaptureManager>,
                     scoped_refptr<VideoCaptureController>) {},
                  scoped_refptr<VideoCaptureManager>(this),
                  GetControllerSharedRef(controller)));
 }
 
-void VideoCaptureManager::OnDeviceStarted(VideoCaptureController* controller) {
+void VideoCaptureManager::OnDeviceLaunched(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++;
     VideoCaptureController* maybe_entry =
         LookupControllerBySessionId(request->first);
     if (maybe_entry && maybe_entry->IsDeviceAlive()) {
       request->second.Run();
       photo_request_queue_.erase(request);
     }
   }
 
   device_start_request_queue_.pop_front();
   ProcessDeviceStartRequestQueue();
 }
 
-void VideoCaptureManager::OnDeviceStartFailed(
+void VideoCaptureManager::OnDeviceLaunchFailed(
     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_request_queue_.pop_front();
   ProcessDeviceStartRequestQueue();
 }
 
-void VideoCaptureManager::OnDeviceStartAborted() {
+void VideoCaptureManager::OnDeviceLaunchAborted() {
   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) {
@@ skipping 413 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,
-                                 video_capture_provider_->CreateBuildableDevice(
-                                     device_info.id, device_info.type));
+  VideoCaptureController* new_controller = new VideoCaptureController(
+      device_info.id, device_info.type, params,
+      video_capture_provider_->CreateDeviceLauncher());
   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