[Mojo Video Capture] Introduce abstraction VideoCaptureSystem

content/browser/renderer_host/media/in_process_buildable_video_capture_device.cc

 // Copyright 2017 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/in_process_buildable_video_capture_device.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/browser/media/capture/web_contents_video_capture_device.h"
@@ skipping 66 matching lines @@
 // TODO(miu): The value for tab capture should be determined programmatically.
 // http://crbug.com/460318
 const int kMaxNumberOfBuffersForTabCapture = 10;
 
 }  // anonymous namespace
 
 namespace content {
 
 InProcessBuildableVideoCaptureDevice::InProcessBuildableVideoCaptureDevice(
     scoped_refptr<base::SingleThreadTaskRunner> device_task_runner,
-    media::VideoCaptureDeviceFactory* device_factory)
+    media::VideoCaptureSystem* device_factory)
     : device_task_runner_(std::move(device_task_runner)),
       device_factory_(device_factory) {}
 
 InProcessBuildableVideoCaptureDevice::~InProcessBuildableVideoCaptureDevice() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!device_);
 }
 
 void InProcessBuildableVideoCaptureDevice::CreateAndStartDeviceAsync(
     VideoCaptureController* controller,
     const media::VideoCaptureParams& params,
     BuildableDeviceCallbacks* callbacks,
     base::OnceClosure done_cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(state_ == State::NO_DEVICE);
 
   const int max_buffers = (controller->stream_type() == MEDIA_TAB_VIDEO_CAPTURE
                                ? kMaxNumberOfBuffersForTabCapture
                                : kMaxNumberOfBuffers);
 
   auto device_client =
       CreateDeviceClient(max_buffers, controller->GetWeakPtrForIOThread());
 
   base::Closure start_capture_closure;
+  // Use of Unretained() is safe, because |context_reference| guarantees that
+  // |this| stays alive.
+  ReceiveDeviceCallback after_start_capture_callback = media::BindToCurrentLoop(
+      base::Bind(&InProcessBuildableVideoCaptureDevice::OnDeviceStarted,
+                 base::Unretained(this), controller, callbacks,
+                 base::Passed(&done_cb)));
+
   switch (controller->stream_type()) {
     case MEDIA_DEVICE_VIDEO_CAPTURE: {
-      const media::VideoCaptureDeviceDescriptor* descriptor =
-          callbacks->LookupDeviceDescriptor(controller->device_id());
-      if (descriptor) {
-        controller->OnLog(
-            base::StringPrintf("Starting device: id: %s, name: %s, api: %s",
-                               descriptor->device_id.c_str(),
-                               descriptor->GetNameAndModel().c_str(),
-                               descriptor->GetCaptureApiTypeString()));
-
-        callbacks->WillStartDevice(descriptor->facing);
-
-        // Use of Unretained() is safe, because |context_reference| guarantees
-        // that |this| stays alive.
-        ReceiveDeviceCallback after_start_capture_callback =
-            media::BindToCurrentLoop(base::Bind(
-                &InProcessBuildableVideoCaptureDevice::OnDeviceStarted,
-                base::Unretained(this), controller, callbacks,
-                base::Passed(&done_cb)));
-        start_capture_closure =
-            base::Bind(&InProcessBuildableVideoCaptureDevice::
-                           DoStartDeviceCaptureOnDeviceThread,
-                       base::Unretained(this), *descriptor, params,
-                       base::Passed(std::move(device_client)),
-                       std::move(after_start_capture_callback));
-      } else {
-        callbacks->OnDeviceStartFailed(controller);
-        std::move(done_cb).Run();
-        return;
-      }
+      start_capture_closure =
+          base::Bind(&InProcessBuildableVideoCaptureDevice::
+                         DoStartDeviceCaptureOnDeviceThread,
+                     base::Unretained(this), controller->device_id(), params,
+                     base::Passed(std::move(device_client)),
+                     std::move(after_start_capture_callback));
       break;
     }
-    case MEDIA_TAB_VIDEO_CAPTURE: {
-      // Use of Unretained() is safe, because |context_reference| guarantees
-      // that |this| stays alive.
-      ReceiveDeviceCallback after_start_capture_callback =
-          media::BindToCurrentLoop(
-              base::Bind(&InProcessBuildableVideoCaptureDevice::OnDeviceStarted,
-                         base::Unretained(this), controller, callbacks,
-                         base::Passed(&done_cb)));
+    case MEDIA_TAB_VIDEO_CAPTURE:
       start_capture_closure =
           base::Bind(&InProcessBuildableVideoCaptureDevice::
                          DoStartTabCaptureOnDeviceThread,
                      base::Unretained(this), controller->device_id(), params,
                      base::Passed(std::move(device_client)),
                      std::move(after_start_capture_callback));
       break;
-    }
-    case MEDIA_DESKTOP_VIDEO_CAPTURE: {
-      // Use of Unretained() is safe, because |context_reference| guarantees
-      // that |this| stays alive.
-      ReceiveDeviceCallback after_start_capture_callback =
-          media::BindToCurrentLoop(
-              base::Bind(&InProcessBuildableVideoCaptureDevice::OnDeviceStarted,
-                         base::Unretained(this), controller, callbacks,
-                         base::Passed(&done_cb)));
+
+    case MEDIA_DESKTOP_VIDEO_CAPTURE:
       start_capture_closure =
           base::Bind(&InProcessBuildableVideoCaptureDevice::
                          DoStartDesktopCaptureOnDeviceThread,
                      base::Unretained(this), controller->device_id(), params,
                      base::Passed(std::move(device_client)),
                      std::move(after_start_capture_callback));
       break;
-    }
+
     default: {
       NOTIMPLEMENTED();
       return;
     }
   }
 
   device_task_runner_->PostTask(FROM_HERE, start_capture_closure);
   state_ = State::DEVICE_START_IN_PROGRESS;
 }
 
@@ skipping 134 matching lines @@
     VideoCaptureController* controller,
     BuildableDeviceCallbacks* callbacks,
     base::OnceClosure done_cb,
     std::unique_ptr<media::VideoCaptureDevice> device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   switch (state_) {
     case State::DEVICE_START_IN_PROGRESS:
       if (!device) {
         state_ = State::NO_DEVICE;
         callbacks->OnDeviceStartFailed(controller);
-        std::move(done_cb).Run();
         return;
       }
       // Passing raw pointer |device.get()| to the controller is safe,
       // because we take ownership of |device| and we call
       // controller->SetConsumerFeedbackObserver(nullptr) before releasing
       // |device|.
       controller->SetConsumerFeedbackObserver(
           base::MakeUnique<VideoFrameConsumerFeedbackObserverOnTaskRunner>(
               device.get(), device_task_runner_));
       device_ = std::move(device);
       state_ = State::DEVICE_STARTED;
-      callbacks->DidStartDevice(controller);
+      callbacks->OnDeviceStarted(controller);
       std::move(done_cb).Run();
       return;
     case State::DEVICE_START_ABORTING:
       if (device) {
         device_ = std::move(device);
         state_ = State::DEVICE_STARTED;
         // We do not move our |done_cb| to this invocation, because
         // we still need it to stay alive for the remainder of this method
         // execution. Our implementation of ReleaseDeviceAsync() does not
         // actually need the context while releasing the device.
         ReleaseDeviceAsync(controller, base::Bind([]() {}));
       }
       state_ = State::NO_DEVICE;
       callbacks->OnDeviceStartAborted();
       std::move(done_cb).Run();
       return;
     case State::NO_DEVICE:
     case State::DEVICE_STARTED:
       NOTREACHED();
       return;
   }
 }
 
 void InProcessBuildableVideoCaptureDevice::DoStartDeviceCaptureOnDeviceThread(
-    const media::VideoCaptureDeviceDescriptor& descriptor,
+    const std::string& device_id,
     const media::VideoCaptureParams& params,
     std::unique_ptr<media::VideoCaptureDeviceClient> device_client,
     ReceiveDeviceCallback result_callback) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(device_task_runner_->BelongsToCurrentThread());
 
   std::unique_ptr<media::VideoCaptureDevice> video_capture_device =
-      device_factory_->CreateDevice(descriptor);
+      device_factory_->CreateDevice(device_id);
 
   if (!video_capture_device) {
     result_callback.Run(nullptr);
     return;
   }
 
   video_capture_device->AllocateAndStart(params, std::move(device_client));
   result_callback.Run(std::move(video_capture_device));
 }
 
@@ skipping 79 matching lines @@
     !defined(OS_ANDROID)
   DesktopCaptureDevice* desktop_device =
       static_cast<DesktopCaptureDevice*>(device);
   desktop_device->SetNotificationWindowId(window_id);
   VLOG(2) << "Screen capture notification window passed on device thread.";
 #endif
   std::move(done_cb).Run();
 }
 
 }  // namespace content