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

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 70 matching lines @@
   // this value should be a session id previously returned by Open().
   //
   // If the device is not already started (i.e., no other client is currently
   // capturing from this device), this call will cause a VideoCaptureController
   // and VideoCaptureDevice to be created, possibly asynchronously.
   //
   // On success, the controller is returned via calling |done_cb|, indicating
   // that the client was successfully added. A NULL controller is passed to
   // the callback on failure. |done_cb| is not allowed to synchronously call
   // StopCaptureForClient().
-  void StartCaptureForClient(media::VideoCaptureSessionId session_id,
-                             const media::VideoCaptureParams& capture_params,
-                             VideoCaptureControllerID client_id,
-                             VideoCaptureControllerEventHandler* client_handler,
-                             const DoneCB& done_cb);
+  void ConnectClient(media::VideoCaptureSessionId session_id,
+                     const media::VideoCaptureParams& capture_params,
+                     VideoCaptureControllerID client_id,
+                     VideoCaptureControllerEventHandler* client_handler,
+                     const DoneCB& done_cb);
 
   // Called by VideoCaptureHost to remove |client_handler|. If this is the last
   // client of the device, the |controller| and its VideoCaptureDevice may be
   // destroyed. The client must not access |controller| after calling this
   // function.
-  void StopCaptureForClient(VideoCaptureController* controller,
-                            VideoCaptureControllerID client_id,
-                            VideoCaptureControllerEventHandler* client_handler,
-                            bool aborted_due_to_error);
+  void DisconnectClient(VideoCaptureController* controller,
+                        VideoCaptureControllerID client_id,
+                        VideoCaptureControllerEventHandler* client_handler,
+                        bool aborted_due_to_error);
 
   // Called by VideoCaptureHost to pause to update video buffer specified by
   // |client_id| and |client_handler|. If all clients of |controller| are
   // paused, the corresponding device will be closed.
   void PauseCaptureForClient(
       VideoCaptureController* controller,
       VideoCaptureControllerID client_id,
       VideoCaptureControllerEventHandler* client_handler);
 
   // Called by VideoCaptureHost to resume to update video buffer specified by
   // |client_id| and |client_handler|. The |session_id| and |params| should be
-  // same as those used in StartCaptureForClient().
+  // same as those used in ConnectClient().
   // If this is first active client of |controller|, device will be allocated
   // and it will take a little time to resume.
   // Allocating device could failed if other app holds the camera, the error
   // will be notified through VideoCaptureControllerEventHandler::OnError().
   void ResumeCaptureForClient(
       media::VideoCaptureSessionId session_id,
       const media::VideoCaptureParams& params,
       VideoCaptureController* controller,
       VideoCaptureControllerID client_id,
       VideoCaptureControllerEventHandler* client_handler);
@@ skipping 71 matching lines @@
   using EnumerationCallback =
       base::Callback<void(const media::VideoCaptureDeviceDescriptors&)>;
   void EnumerateDevices(const EnumerationCallback& client_callback);
 
   // Implementation of BuildableVideoCaptureDevice::Callbacks:
   const media::VideoCaptureDeviceDescriptor* LookupDeviceDescriptor(
       const std::string& id) override;
   void WillStartDevice(media::VideoFacingMode facing_mode) override;
   void DidStartDevice(VideoCaptureController* controller) override;
   void OnDeviceStartFailed(VideoCaptureController* controller) override;
+  void OnDeviceStartAborted() override;
 
   // Retrieves camera calibration information for a particular device. Returns
   // nullopt_t if the |device_id| is not found or camera calibration information
   // is not available for the device.  Camera calibration is cached during
   // device(s) enumeration.
   base::Optional<CameraCalibration> GetCameraCalibration(
       const std::string& device_id);
 
  private:
   class CaptureDeviceStartRequest;
@@ skipping 26 matching lines @@
 
   // Checks to see if |controller| has no clients left. If so, remove it from
   // the list of controllers, and delete it asynchronously. |controller| may be
   // freed by this function.
   void DestroyControllerIfNoClients(VideoCaptureController* controller);
 
   // Finds a VideoCaptureController 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.
   VideoCaptureController* LookupControllerBySessionId(int session_id);
-  VideoCaptureController* LookupControllerByTypeAndId(
+  VideoCaptureController* LookupControllerByMediaTypeAndDeviceId(
       MediaStreamType type,
       const std::string& device_id) const;
   bool IsControllerPointerValid(const VideoCaptureController* controller) const;
-  VideoCaptureController* LookupControllerBySerialId(int serial_id) const;
-  scoped_refptr<VideoCaptureController> GetControllerSharedRefFromSerialId(
-      int serial_id) const;
+  scoped_refptr<VideoCaptureController> GetControllerSharedRef(
+      VideoCaptureController* controller) const;
 
   // Finds the device info by |id| in |devices_info_cache_|, or nullptr.
   DeviceInfo* GetDeviceInfoById(const std::string& id);
 
   // Finds a VideoCaptureController for the indicated |capture_session_id|,
   // creating a fresh one if necessary. Returns nullptr if said
   // |capture_session_id| is invalid.
   VideoCaptureController* GetOrCreateController(
       media::VideoCaptureSessionId capture_session_id,
       const media::VideoCaptureParams& params);
 
   // Starting a capture device can take 1-2 seconds.
   // To avoid multiple unnecessary start/stop commands to the OS, each start
-  // request is queued in |device_start_queue_|.
-  // QueueStartDevice creates a new entry in |device_start_queue_| and posts a
+  // request is queued in |device_start_request_queue_|.
+  // QueueStartDevice creates a new entry in |device_start_request_queue_| and
+  // posts a
   // request to start the device on the device thread unless there is
   // another request pending start.
   void QueueStartDevice(media::VideoCaptureSessionId session_id,
                         VideoCaptureController* controller,
                         const media::VideoCaptureParams& params);
   void DoStopDevice(VideoCaptureController* controller);
-  void HandleQueuedStartRequest();
+  void ProcessDeviceStartRequestQueue();
 
   void MaybePostDesktopCaptureWindowId(media::VideoCaptureSessionId session_id);
 
 #if defined(OS_ANDROID)
   void ReleaseDevices();
   void ResumeDevices();
 
   std::unique_ptr<base::android::ApplicationStatusListener>
       app_status_listener_;
   bool application_state_has_running_activities_;
 #endif
 
   // The message loop of media stream device thread, where VCD's live.
   scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
 
   // Only accessed on Browser::IO thread.
   base::ObserverList<MediaStreamProviderListener> listeners_;
   media::VideoCaptureSessionId new_capture_session_id_;
 
   // An entry is kept in this map for every session that has been created via
   // the Open() entry point. The keys are session_id's. This map is used to
-  // determine which device to use when StartCaptureForClient() occurs. Used
+  // determine which device to use when ConnectClient() occurs. Used
   // only on the IO thread.
   SessionMap sessions_;
 
   // Currently opened VideoCaptureController instances. The device may or may
   // not be started. This member is only accessed on IO thread.
   std::vector<scoped_refptr<VideoCaptureController>> controllers_;
 
-  DeviceStartQueue device_start_queue_;
+  // TODO(chfremer): Consider using CancellableTaskTracker, see
+  // crbug.com/598465.
+  DeviceStartQueue device_start_request_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::Closure>> 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_;
 
@@ skipping 11 matching lines @@
   // 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_