Reland: ImageCapture: Queue up requests while device not ready

content/browser/renderer_host/media/video_capture_manager.h

   // 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.
 
 // VideoCaptureManager is used to open/close, start/stop, enumerate available
 // video capture devices, and manage VideoCaptureController's.
 // All functions are expected to be called from Browser::IO thread. Some helper
 // functions (*OnDeviceThread) will dispatch operations to the device thread.
 // VideoCaptureManager will open OS dependent instances of VideoCaptureDevice.
 // A device can only be opened once.
@@ skipping 147 matching lines @@
   }
 
   void GetPhotoCapabilities(
       int session_id,
       VideoCaptureDevice::GetPhotoCapabilitiesCallback callback);
   void SetPhotoOptions(int session_id,
                        media::mojom::PhotoSettingsPtr settings,
                        VideoCaptureDevice::SetPhotoOptionsCallback callback);
   void TakePhoto(int session_id,
                  VideoCaptureDevice::TakePhotoCallback callback);
+
 #if defined(OS_ANDROID)
   // Some devices had troubles when stopped and restarted quickly, so the device
   // is only stopped when Chrome is sent to background and not when, e.g., a tab
   // is hidden, see http://crbug.com/582295.
   void OnApplicationStateChange(base::android::ApplicationState state);
 #endif
 
  private:
   class CaptureDeviceStartRequest;
   class DeviceEntry;
@@ skipping 26 matching lines @@
       base::Callback<void(const DeviceInfos&)> on_devices_enumerated_callback,
       MediaStreamType stream_type,
       const DeviceInfos& old_device_info_cache,
       std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors_snapshot);
 
   // Checks to see if |entry| has no clients left on its controller. If so,
   // remove it from the list of devices, and delete it asynchronously. |entry|
   // may be freed by this function.
   void DestroyDeviceEntryIfNoClients(DeviceEntry* entry);
 
-  // Retrieve the VideoCaptureDevice associated to |session_id|, or nullptr
-  // if not found.
-  VideoCaptureDevice* GetVideoCaptureDeviceBySessionId(int session_id);
-
-  // Finds a DeviceEntry in different ways: by its |device_id| and |type| (if it
-  // is already opened), by its |controller| or by its |serial_id|. In all
-  // cases, if not found, nullptr is returned.
+  // Finds a DeviceEntry in different ways: by |session_id|, by its |device_id|
+  // and |type| (if it is already opened), by its |controller| or by its
+  // |serial_id|. In all cases, if not found, nullptr is returned.
+  DeviceEntry* GetDeviceEntryBySessionId(int session_id);
   DeviceEntry* GetDeviceEntryByTypeAndId(MediaStreamType type,
                                          const std::string& device_id) const;
   DeviceEntry* GetDeviceEntryByController(
       const VideoCaptureController* controller) const;
   DeviceEntry* GetDeviceEntryBySerialId(int serial_id) const;
 
   // Finds the device info by |id| in |devices_info_cache_|, or nullptr.
   DeviceInfo* GetDeviceInfoById(const std::string& id);
 
   // Finds a DeviceEntry entry for the indicated |capture_session_id|, creating
@@ skipping 37 matching lines @@
       std::unique_ptr<VideoCaptureDevice::Client> client);
 
   // Stops and destroys the VideoCaptureDevice held in |device|.
   void DoStopDeviceOnDeviceThread(std::unique_ptr<VideoCaptureDevice> device);
 
   void MaybePostDesktopCaptureWindowId(media::VideoCaptureSessionId session_id);
   void SetDesktopCaptureWindowIdOnDeviceThread(
       media::VideoCaptureDevice* device,
       gfx::NativeViewId window_id);
 
+  // Internal versions of the Image Capture public ones, for delayed execution.
+  void DoGetPhotoCapabilities(
+      VideoCaptureDevice::GetPhotoCapabilitiesCallback callback,
+      VideoCaptureDevice* device);
+  void DoSetPhotoOptions(
+      VideoCaptureDevice::SetPhotoOptionsCallback callback,
+      media::mojom::PhotoSettingsPtr settings,
+      VideoCaptureDevice* device);
+  void DoTakePhoto(VideoCaptureDevice::TakePhotoCallback callback,
+                   VideoCaptureDevice* device);
+
 #if defined(OS_MACOSX)
   // Called on the IO thread after the device layer has been initialized on Mac.
   // Sets |capture_device_api_initialized_| to true and then executes and_then.
   void OnDeviceLayerInitialized(const base::Closure& and_then);
 
   // Returns true if the current operation needs to be preempted by a call to
   // InitializeCaptureDeviceApiOnUIThread.
   // Called on the IO thread.
   bool NeedToInitializeCaptureDeviceApi(MediaStreamType stream_type);
 
@@ skipping 29 matching lines @@
   // only on the IO thread.
   SessionMap sessions_;
 
   // Currently opened DeviceEntry instances (each owning a VideoCaptureDevice -
   // VideoCaptureController pair). The device may or may not be started. This
   // member is only accessed on IO thread.
   DeviceEntries devices_;
 
   DeviceStartQueue device_start_queue_;
 
+  // Queue to keep photo-associated requests waiting for a device to initialize,
+  // bundles a session id integer and an associated photo-related request.
+  std::list<std::pair<int, base::Callback<void(media::VideoCaptureDevice*)>>>
+      photo_request_queue_;
+
   // Device creation factory injected on construction from MediaStreamManager or
   // from the test harness.
   std::unique_ptr<media::VideoCaptureDeviceFactory>
       video_capture_device_factory_;
 
   // Local cache of the enumerated video capture devices' names and capture
   // supported formats. A snapshot of the current devices and their capabilities
   // is composed in VideoCaptureDeviceFactory::EnumerateDeviceNames() and
   // ConsolidateDevicesInfoOnDeviceThread(), and this snapshot is used to update
   // this list in OnDevicesInfoEnumerated(). GetDeviceSupportedFormats() will
   // use this list if the device is not started, otherwise it will retrieve the
   // active device capture format from the VideoCaptureController associated.
   DeviceInfos devices_info_cache_;
 
   // Map used by DesktopCapture.
   std::map<media::VideoCaptureSessionId, gfx::NativeViewId>
       notification_window_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_