Reland: ImageCapture: Queue up requests while device not ready

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>
 
@@ skipping 500 matching lines @@
   base::PostTaskAndReplyWithResult(
       device_task_runner_.get(), FROM_HERE, start_capture_function,
       base::Bind(&VideoCaptureManager::OnDeviceStarted, this,
                  request->serial_id()));
 }
 
 void VideoCaptureManager::OnDeviceStarted(
     int serial_id,
     std::unique_ptr<VideoCaptureDevice> device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(serial_id == device_start_queue_.begin()->serial_id());
-  DVLOG(3) << "OnDeviceStarted";
+  DCHECK_EQ(serial_id, device_start_queue_.begin()->serial_id());
+  DVLOG(3) << __func__;
   if (device_start_queue_.front().abort_start()) {
     // |device| can be null if creation failed in
     // DoStartDeviceCaptureOnDeviceThread.
     // The device is no longer wanted. Stop the device again.
     DVLOG(3) << "OnDeviceStarted but start request have been aborted.";
     media::VideoCaptureDevice* device_ptr = device.get();
     base::Closure closure =
         base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
                    base::Passed(&device));
     if (device_ptr && !device_task_runner_->PostTask(FROM_HERE, closure)) {
       // PostTask failed. The device must be stopped anyway.
       device_ptr->StopAndDeAllocate();
     }
   } else {
     DeviceEntry* const entry = GetDeviceEntryBySerialId(serial_id);
     DCHECK(entry);
     DCHECK(!entry->video_capture_device());
     entry->SetVideoCaptureDevice(std::move(device));
 
     if (entry->stream_type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
       const media::VideoCaptureSessionId session_id =
           device_start_queue_.front().session_id();
       DCHECK(session_id != kFakeSessionId);
       MaybePostDesktopCaptureWindowId(session_id);
     }
+
+    auto request = photo_request_queue_.begin();
+    while(request != photo_request_queue_.end()) {
+      if (GetDeviceEntryBySessionId(request->first)->video_capture_device()) {
+        request->second.Run(entry->video_capture_device());
+        photo_request_queue_.erase(request);
+      }
+      ++request;
+    }
   }
 
   device_start_queue_.pop_front();
   HandleQueuedStartRequest();
 }
 
 std::unique_ptr<media::VideoCaptureDevice>
 VideoCaptureManager::DoStartDeviceCaptureOnDeviceThread(
     const VideoCaptureDeviceDescriptor& descriptor,
     const media::VideoCaptureParams& params,
@@ skipping 298 matching lines @@
                  existing_device->video_capture_device(),
                  window_id_it->second));
 
   notification_window_ids_.erase(window_id_it);
 }
 
 void VideoCaptureManager::GetPhotoCapabilities(
     int session_id,
     VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  VideoCaptureDevice* device = GetVideoCaptureDeviceBySessionId(session_id);
-  if (!device)
+
+  const DeviceEntry* entry = GetDeviceEntryBySessionId(session_id);
+  if (!entry)
     return;
-  // Unretained(device) is safe to use here because |device| would be null if it
-  // was scheduled for shutdown and destruction, and because this task is
-  // guaranteed to run before the task that destroys the |device|.
-  device_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoCaptureDevice::GetPhotoCapabilities,
-                            base::Unretained(device), base::Passed(&callback)));
+  VideoCaptureDevice* device = entry->video_capture_device();
+  if (device) {
+    VideoCaptureManager::DoGetPhotoCapabilities(std::move(callback), device);
+    return;
+  }
+  // |entry| is known but |device| is nullptr, queue up a request for later.
+  photo_request_queue_.emplace_back(
+      session_id, base::Bind(&VideoCaptureManager::DoGetPhotoCapabilities, this,
+                             base::Passed(&callback)));
 }
 
 void VideoCaptureManager::SetPhotoOptions(
     int session_id,
     media::mojom::PhotoSettingsPtr settings,
     VideoCaptureDevice::SetPhotoOptionsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  VideoCaptureDevice* device = GetVideoCaptureDeviceBySessionId(session_id);
-  if (!device)
+
+  const DeviceEntry* entry = GetDeviceEntryBySessionId(session_id);
+  if (!entry)
     return;
-  device_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoCaptureDevice::SetPhotoOptions, base::Unretained(device),
-                 base::Passed(&settings), base::Passed(&callback)));
+  VideoCaptureDevice* device = entry->video_capture_device();
+  if (device) {
+    VideoCaptureManager::DoSetPhotoOptions(std::move(callback),
+                                           std::move(settings), device);
+    return;
+  }
+  // |entry| is known but |device| is nullptr, queue up a request for later.
+  photo_request_queue_.emplace_back(
+      session_id, base::Bind(&VideoCaptureManager::DoSetPhotoOptions, this,
+                             base::Passed(&callback), base::Passed(&settings)));
 }
 
 void VideoCaptureManager::TakePhoto(
     int session_id,
     VideoCaptureDevice::TakePhotoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  VideoCaptureDevice* device = GetVideoCaptureDeviceBySessionId(session_id);
-  if (!device)
+
+  const DeviceEntry* entry = GetDeviceEntryBySessionId(session_id);
+  if (!entry)
     return;
-  // Unretained(device) is safe to use here because |device| would be null if it
-  // was scheduled for shutdown and destruction, and because this task is
-  // guaranteed to run before the task that destroys the |device|.
-  device_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoCaptureDevice::TakePhoto,
-                            base::Unretained(device), base::Passed(&callback)));
+  VideoCaptureDevice* device = entry->video_capture_device();
+  if (device) {
+    VideoCaptureManager::DoTakePhoto(std::move(callback), device);
+    return;
+  }
+  // |entry| is known but |device| is nullptr, queue up a request for later.
+  photo_request_queue_.emplace_back(
+      session_id, base::Bind(&VideoCaptureManager::DoTakePhoto, this,
+                             base::Passed(&callback)));
 }
 
 void VideoCaptureManager::DoStopDeviceOnDeviceThread(
     std::unique_ptr<VideoCaptureDevice> device) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StopDeviceTime");
   DCHECK(IsOnDeviceThread());
   device->StopAndDeAllocate();
   DVLOG(3) << "DoStopDeviceOnDeviceThread";
 }
 
@@ skipping 104 matching lines @@
     // TODO(mcasas): use a helper function https://crbug.com/624854.
     DeviceEntries::iterator device_it =
         std::find_if(devices_.begin(), devices_.end(),
                      [entry](const std::unique_ptr<DeviceEntry>& device_entry) {
                        return device_entry.get() == entry;
                      });
     devices_.erase(device_it);
   }
 }
 
-media::VideoCaptureDevice*
-VideoCaptureManager::GetVideoCaptureDeviceBySessionId(int session_id) {
+VideoCaptureManager::DeviceEntry*
+VideoCaptureManager::GetDeviceEntryBySessionId(int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SessionMap::const_iterator session_it = sessions_.find(session_id);
   if (session_it == sessions_.end())
     return nullptr;
 
-  DeviceEntry* const device_info =
-      GetDeviceEntryByTypeAndId(session_it->second.type, session_it->second.id);
-  return device_info ? device_info->video_capture_device() : nullptr;
+  return GetDeviceEntryByTypeAndId(session_it->second.type,
+                                   session_it->second.id);
 }
 
 VideoCaptureManager::DeviceEntry*
 VideoCaptureManager::GetDeviceEntryByTypeAndId(
     MediaStreamType type,
     const std::string& device_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const std::unique_ptr<DeviceEntry>& device : devices_) {
     if (type == device->stream_type && device_id == device->id)
@@ skipping 70 matching lines @@
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
 #if defined(ENABLE_SCREEN_CAPTURE)
   DesktopCaptureDevice* desktop_device =
       static_cast<DesktopCaptureDevice*>(device);
   desktop_device->SetNotificationWindowId(window_id);
   VLOG(2) << "Screen capture notification window passed on device thread.";
 #endif
 }
 
+void VideoCaptureManager::DoGetPhotoCapabilities(
+    VideoCaptureDevice::GetPhotoCapabilitiesCallback callback,
+    VideoCaptureDevice* device) {
+  // Unretained() is safe to use here because |device| would be null if it
+  // was scheduled for shutdown and destruction, and because this task is
+  // guaranteed to run before the task that destroys the |device|.
+  device_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoCaptureDevice::GetPhotoCapabilities,
+                            base::Unretained(device), base::Passed(&callback)));
+}
+
+void VideoCaptureManager::DoSetPhotoOptions(
+    VideoCaptureDevice::SetPhotoOptionsCallback callback,
+    media::mojom::PhotoSettingsPtr settings,
+    VideoCaptureDevice* device) {
+  // Unretained() is safe to use here because |device| would be null if it
+  // was scheduled for shutdown and destruction, and because this task is
+  // guaranteed to run before the task that destroys the |device|.
+  device_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoCaptureDevice::SetPhotoOptions, base::Unretained(device),
+                 base::Passed(&settings), base::Passed(&callback)));
+}
+
+void VideoCaptureManager::DoTakePhoto(
+    VideoCaptureDevice::TakePhotoCallback callback,
+    VideoCaptureDevice* device) {
+  // Unretained() is safe to use here because |device| would be null if it
+  // was scheduled for shutdown and destruction, and because this task is
+  // guaranteed to run before the task that destroys the |device|.
+  device_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoCaptureDevice::TakePhoto,
+                            base::Unretained(device), base::Passed(&callback)));
+}
+
 #if defined(OS_MACOSX)
 void VideoCaptureManager::OnDeviceLayerInitialized(
     const base::Closure& and_then) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   capture_device_api_initialized_ = true;
   and_then.Run();
 }
 
 bool VideoCaptureManager::NeedToInitializeCaptureDeviceApi(
     MediaStreamType stream_type) {
@@ skipping 64 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content