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

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"
+#include "content/browser/renderer_host/media/ownership.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.h"
 #include "content/browser/renderer_host/media/video_frame_receiver_on_io_thread.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/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_client.h"
@@ skipping 71 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!device_);
 }
 
 void InProcessBuildableVideoCaptureDevice::CreateAndStartDeviceAsync(
     VideoCaptureController* controller,
     const media::VideoCaptureParams& params,
     BuildableDeviceCallbacks* callbacks,
     std::unique_ptr<Ownership> context_reference) {
   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
@@ skipping 46 matching lines @@
                      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;
 }
 
 void InProcessBuildableVideoCaptureDevice::ReleaseDeviceAsync(
     VideoCaptureController* controller,
     std::unique_ptr<Ownership>) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   controller->SetConsumerFeedbackObserver(nullptr);
-  if (!device_)
-    return;
-  media::VideoCaptureDevice* device_ptr = device_.release();
-  auto device_task_runner_context_reference =
-      MakeScopedRefptrOwnership(device_task_runner_);
-  bool posting_task_succeeded = device_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&StopAndReleaseDeviceOnDeviceThread, device_ptr,
-                 base::Passed(&device_task_runner_context_reference)));
-  if (posting_task_succeeded == false) {
-    // Since posting to the task runner has failed, we attempt doing it on
-    // the calling thread instead.
-    StopAndReleaseDeviceOnDeviceThread(device_ptr, nullptr);
+  switch (state_) {
+    case State::DEVICE_START_IN_PROGRESS:
+      state_ = State::DEVICE_START_ABORTING;
+      return;
+    case State::NO_DEVICE:
+    case State::DEVICE_START_ABORTING:
+      return;
+    case State::DEVICE_STARTED:
+      media::VideoCaptureDevice* device_ptr = device_.release();
+      auto device_task_runner_context_reference =
+          MakeScopedRefptrOwnership(device_task_runner_);
+      bool posting_task_succeeded = device_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&StopAndReleaseDeviceOnDeviceThread, device_ptr,
+                     base::Passed(&device_task_runner_context_reference)));
+      if (posting_task_succeeded == false) {
+        // Since posting to the task runner has failed, we attempt doing it on
+        // the calling thread instead.
+        StopAndReleaseDeviceOnDeviceThread(device_ptr, nullptr);
+      }
+      state_ = State::NO_DEVICE;
+      return;
   }
 }
 
 bool InProcessBuildableVideoCaptureDevice::IsDeviceAlive() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return device_ != nullptr;
 }
 
 void InProcessBuildableVideoCaptureDevice::GetPhotoCapabilities(
     media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) const {
@@ skipping 75 matching lines @@
                             base::Unretained(this), device_.get(), window_id,
                             base::Passed(&context_reference)));
 }
 
 std::unique_ptr<media::VideoCaptureDeviceClient>
 InProcessBuildableVideoCaptureDevice::CreateDeviceClient(
     int buffer_pool_max_buffer_count,
     base::WeakPtr<media::VideoFrameReceiver> receiver) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  scoped_refptr<media::VideoCaptureBufferPool> buffer_pool_ =
+  scoped_refptr<media::VideoCaptureBufferPool> buffer_pool =
       new media::VideoCaptureBufferPoolImpl(
           base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
           buffer_pool_max_buffer_count);
 
   return base::MakeUnique<media::VideoCaptureDeviceClient>(
-      base::MakeUnique<VideoFrameReceiverOnIOThread>(receiver), buffer_pool_,
+      base::MakeUnique<VideoFrameReceiverOnIOThread>(receiver),
+      std::move(buffer_pool),

[miu, 2017/03/17 21:48:02]

Note: Mistakes like this can be avoided by biasing towards a more functional
style (i.e., less imperative style):

  return base::MakeUnique<media::VideoCaptureDeviceClient>(
      base::MakeUnique<VideoFrameReceiverOnIOThread>(receiver),
      new media::VideoCaptureBufferPoolImpl(
          base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
          buffer_pool_max_buffer_count),
      base::Bind(&CreateGpuJpegDecoder,
                 base::Bind(&media::VideoFrameReceiver::OnFrameReadyInBuffer,
                            receiver)));

[chfremer, 2017/03/21 22:37:23]

Done.

       base::Bind(&CreateGpuJpegDecoder,
                  base::Bind(&media::VideoFrameReceiver::OnFrameReadyInBuffer,
                             receiver)));
 }
 
 void InProcessBuildableVideoCaptureDevice::OnDeviceStarted(
     VideoCaptureController* controller,
     BuildableDeviceCallbacks* callbacks,
     std::unique_ptr<Ownership> context_reference,
     std::unique_ptr<media::VideoCaptureDevice> device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!device) {
-    callbacks->OnDeviceStartFailed(controller);
-    return;
+  switch (state_) {
+    case State::DEVICE_START_IN_PROGRESS:
+      if (!device) {
+        state_ = State::NO_DEVICE;
+        callbacks->OnDeviceStartFailed(controller);
+        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);
+      return;
+    case State::DEVICE_START_ABORTING:
+      if (device) {
+        device_ = std::move(device);
+        state_ = State::DEVICE_STARTED;
+        // We do not move our |context_reference| to this invocation, because
+        // we still need it for the remainder of this method execution.
+        // Our implementation of ReleaseDeviceAsync() does not actually need the
+        // context while releasing the device.
+        ReleaseDeviceAsync(controller, nullptr);
+      }
+      state_ = State::NO_DEVICE;
+      callbacks->OnDeviceStartAborted();
+      return;
+    case State::NO_DEVICE:
+    case State::DEVICE_STARTED:
+      NOTREACHED();
+      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);
-  callbacks->DidStartDevice(controller);
 }
 
 void InProcessBuildableVideoCaptureDevice::DoStartDeviceCaptureOnDeviceThread(
     const media::VideoCaptureDeviceDescriptor& descriptor,
     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());
 
@@ skipping 91 matching lines @@
 #if defined(ENABLE_SCREEN_CAPTURE) && BUILDFLAG(ENABLE_WEBRTC) && \
     !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
 }
 
 }  // namespace content