Queue commands to the Os to start a video device.

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 <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 100 matching lines @@
 
 VideoCaptureManager::VideoCaptureManager(
     scoped_ptr<media::VideoCaptureDeviceFactory> factory)
     : listener_(NULL),
       new_capture_session_id_(1),
       video_capture_device_factory_(factory.Pass()) {
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
+  DCHECK(device_start_queue_.empty());
 }
 
 void VideoCaptureManager::Register(
     MediaStreamProviderListener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!listener_);
   DCHECK(!device_task_runner_.get());
   listener_ = listener;
   device_task_runner_ = device_task_runner;
@@ skipping 78 matching lines @@
     DestroyDeviceEntryIfNoClients(existing_device);
   }
 
   // Notify listeners asynchronously, and forget the session.
   base::MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureManager::OnClosed, this, session_it->second.type,
                  capture_session_id));
   sessions_.erase(session_it);
 }
 
+// Creates a start request.
+VideoCaptureManager::
+CaptureDeviceStartRequest::CaptureDeviceStartRequest(

[tommi (sloooow) - chröme, 2014/12/15 16:25:05]

no need to wrap?

[perkj_chrome, 2014/12/16 20:15:05]

media::VideoCaptureSessionId session_id, does not fit.

[tommi (sloooow) - chröme, 2014/12/16 22:31:25]

I meant the function:

VideoCaptureManager::CaptureDeviceStartRequest::CaptureDeviceStartRequest(

+    DeviceEntry* device_entry,
+    media::VideoCaptureSessionId session_id,
+    const media::VideoCaptureParams& params)
+    : device_entry(device_entry),
+      session_id(session_id),
+      params(params) {
+}
+
+void VideoCaptureManager::QueueStartDevice(
+    media::VideoCaptureSessionId session_id,
+    DeviceEntry* entry,
+    const media::VideoCaptureParams& params) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(entry->video_capture_controller.get());
+  DVLOG(3) << "QueueStartDevice, device = " << entry->id;
+
+  device_start_queue_.push_back(
+      CaptureDeviceStartRequest(entry, session_id, params));
+  if (device_start_queue_.size() == 1) {
+    HandleQueuedStartRequest();
+  }
+}
+
+void VideoCaptureManager::DoStopDevice(DeviceEntry* entry, bool delete_entry) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // Check if the start request has not yet been sent to the device thread.
+  // If so, delete the request.
+  if (device_start_queue_.size() > 1) {
+    for (DeviceStartQueue::iterator request = ++device_start_queue_.begin();
+         request != device_start_queue_.end(); ++request) {
+      if (request->device_entry->id == entry->id &&
+          request->device_entry->stream_type == entry->stream_type) {
+        device_start_queue_.erase(request);
+        DVLOG(3) << "DoStopDevice, erasing start request for device "
+                 << entry->id << ".";
+        if (delete_entry) {
+          delete entry;

[tommi (sloooow) - chröme, 2014/12/15 16:25:05]

can we use a scoped_ptr<> for this instead?

+        }
+        return;
+      }
+    }
+  }
+
+  DVLOG(3) << "DoStopDevice. Send stop request for device " << entry->id << ".";
+  if (delete_entry) {

[tommi (sloooow) - chröme, 2014/12/15 16:25:05]

FYI - here there are two call sites + bindings for essentially the same
callback. There's quite a bit of code involved for each of these call stacks, so
you could do something like this instead:

device_task_runner_->PostTask(... delete_entry ? base::Owned(entry) :
base::Unretained(entry));

However, I wonder if we should be using scoped_ptr, scoped_refptr or shared_ptr
here... passing around raw pointers seems fragile to me :-/

+    device_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
+                   base::Owned(entry)));
+  } else {
+    device_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
+                   base::Unretained(entry)));
+  }
+}
+
+void VideoCaptureManager::HandleQueuedStartRequest() {
+  auto request = device_start_queue_.begin();
+  if (request == device_start_queue_.end())
+    return;
+
+  DVLOG(3) << "HandleQueuedStartRequest, Post start to device thread, device = "
+           << request->device_entry->id;
+
+  device_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(
+          &VideoCaptureManager::DoStartDeviceOnDeviceThread,
+          this,
+          request->session_id,
+          request->device_entry,
+          request->params,
+          base::Passed(request->device_entry->video_capture_controller->
+                       NewDeviceClient())),
+          base::Bind(&VideoCaptureManager::OnDeviceStarted, this));
+}
+
+void VideoCaptureManager::OnDeviceStarted() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(3) << "OnDeviceStarted";
+  device_start_queue_.pop_front();
+  HandleQueuedStartRequest();
+}
+
 void VideoCaptureManager::DoStartDeviceOnDeviceThread(
     media::VideoCaptureSessionId session_id,
     DeviceEntry* entry,
     const media::VideoCaptureParams& params,
     scoped_ptr<media::VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   scoped_ptr<media::VideoCaptureDevice> video_capture_device;
   switch (entry->stream_type) {
@@ skipping 70 matching lines @@
   }
 
   DCHECK(entry->video_capture_controller);
 
   LogVideoCaptureEvent(VIDEO_CAPTURE_START_CAPTURE);
 
   // First client starts the device.
   if (entry->video_capture_controller->GetActiveClientCount() == 0) {
     DVLOG(1) << "VideoCaptureManager starting device (type = "
              << entry->stream_type << ", id = " << entry->id << ")";
-
-    device_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &VideoCaptureManager::DoStartDeviceOnDeviceThread,
-            this,
-            session_id,
-            entry,
-            params,
-            base::Passed(entry->video_capture_controller->NewDeviceClient())));
+    QueueStartDevice(session_id, entry, params);
   }
   // Run the callback first, as AddClient() may trigger OnFrameInfo().
   done_cb.Run(entry->video_capture_controller->GetWeakPtr());
   entry->video_capture_controller->AddClient(
       client_id, client_handler, client_render_process, session_id, params);
 }
 
 void VideoCaptureManager::StopCaptureForClient(
     VideoCaptureController* controller,
     VideoCaptureControllerID client_id,
@@ skipping 56 matching lines @@
   // We only pause the MEDIA_DEVICE_VIDEO_CAPTURE entry to release camera to
   // system.
   if (entry->stream_type != MEDIA_DEVICE_VIDEO_CAPTURE)
     return;
 
   controller->PauseOrResumeClient(client_id, client_handler, true);
   if (controller->GetActiveClientCount() != 0)
     return;
 
   // There is no more client, release the camera.
-  device_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
-                 base::Unretained(entry)));
+  DoStopDevice(entry, false);
 }
 
 void VideoCaptureManager::ResumeCaptureForClient(
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params,
     VideoCaptureController* controller,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(controller);
   DCHECK(client_handler);
 
   DeviceEntry* entry = GetDeviceEntryForController(controller);
   if (!entry) {
     NOTREACHED();
     return;
   }
 
   // We only pause/resume the MEDIA_DEVICE_VIDEO_CAPTURE entry.
   if (entry->stream_type != MEDIA_DEVICE_VIDEO_CAPTURE)
     return;
 
   controller->PauseOrResumeClient(client_id, client_handler, false);
   if (controller->GetActiveClientCount() != 1)
     return;
 
   // This is first active client, allocate the camera.
-  device_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &VideoCaptureManager::DoStartDeviceOnDeviceThread,
-          this,
-          session_id,
-          entry,
-          params,
-          base::Passed(entry->video_capture_controller->NewDeviceClient())));
+  QueueStartDevice(session_id, entry, params);
 }
 
 bool VideoCaptureManager::GetDeviceSupportedFormats(
     media::VideoCaptureSessionId capture_session_id,
     media::VideoCaptureFormats* supported_formats) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(supported_formats->empty());
 
   SessionMap::iterator it = sessions_.find(capture_session_id);
   if (it == sessions_.end())
@@ skipping 203 matching lines @@
   if (entry->video_capture_controller->GetClientCount() == 0) {
     DVLOG(1) << "VideoCaptureManager stopping device (type = "
              << entry->stream_type << ", id = " << entry->id << ")";
 
     // The DeviceEntry is removed from |devices_| immediately. The controller is
     // deleted immediately, and the device is freed asynchronously. After this
     // point, subsequent requests to open this same device ID will create a new
     // DeviceEntry, VideoCaptureController, and VideoCaptureDevice.
     devices_.erase(entry);
     entry->video_capture_controller.reset();
-    device_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
-                   base::Owned(entry)));
+    DoStopDevice(entry, true);
   }
 }
 
 VideoCaptureManager::DeviceEntry* VideoCaptureManager::GetOrCreateDeviceEntry(
     media::VideoCaptureSessionId capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   SessionMap::iterator session_it = sessions_.find(capture_session_id);
   if (session_it == sessions_.end()) {
     return NULL;
@@ skipping 48 matching lines @@
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
   DCHECK(notification_window_ids_.find(session_id) ==
          notification_window_ids_.end());
   notification_window_ids_[session_id] = window_id;
   VLOG(2) << "Screen capture notification window saved for session "
           << session_id << " on device thread.";
 }
 
 }  // namespace content