[Mojo Video Capture] Split interface BuildableVideoCaptureDevice

content/browser/renderer_host/media/video_capture_controller.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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_
 
 #include <list>
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/video_capture_provider.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/capture/video/video_frame_receiver.h"
 #include "media/capture/video_capture_types.h"
 
 namespace content {
 
+class VideoCaptureDeviceLaunchObserver;
+
 // Implementation of media::VideoFrameReceiver that distributes received frames
 // to potentially multiple connected clients.
 // A call to CreateAndStartDeviceAsync() asynchronously brings up the device. If
 // CreateAndStartDeviceAsync() has been called, ReleaseDeviceAsync() must be
 // called before releasing the instance.
 // Instances must be RefCountedThreadSafe, because an owner
 // (VideoCaptureManager) wants to be able to release its reference during an
 // (asynchronously executing) run of CreateAndStartDeviceAsync(). To this end,
-// the owner passes in the shared ownership as part of |context_reference| into
+// the owner passes in the shared ownership as part of |done_cb| into
 // CreateAndStartDeviceAsync().
 class CONTENT_EXPORT VideoCaptureController
     : public media::VideoFrameReceiver,
+      public VideoCaptureDeviceLauncher::Callbacks,
       public base::RefCountedThreadSafe<VideoCaptureController> {
  public:
   VideoCaptureController(
       const std::string& device_id,
       MediaStreamType stream_type,
       const media::VideoCaptureParams& params,
-      std::unique_ptr<BuildableVideoCaptureDevice> buildable_device);
+      std::unique_ptr<VideoCaptureDeviceLauncher> device_launcher);
 
   base::WeakPtr<VideoCaptureController> GetWeakPtrForIOThread();
 
-  // Factory code creating instances of VideoCaptureController may optionally
-  // set a VideoFrameConsumerFeedbackObserver. Setting the observer is done in
-  // this method separate from the constructor to allow clients to create and
-  // use instances before they can provide the observer. (This is the case with
-  // VideoCaptureManager).
-  void SetConsumerFeedbackObserver(
-      std::unique_ptr<media::VideoFrameConsumerFeedbackObserver> observer);
-
   // Start video capturing and try to use the resolution specified in |params|.
   // Buffers will be shared to the client as necessary. The client will continue
   // to receive frames from the device until RemoveClient() is called.
   void AddClient(VideoCaptureControllerID id,
                  VideoCaptureControllerEventHandler* event_handler,
                  media::VideoCaptureSessionId session_id,
                  const media::VideoCaptureParams& params);
 
   // Stop video capture. This will take back all buffers held by by
   // |event_handler|, and |event_handler| shouldn't use those buffers any more.
@@ skipping 46 matching lines @@
       std::unique_ptr<
           media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
           buffer_read_permission,
       media::mojom::VideoFrameInfoPtr frame_info) override;
   void OnBufferRetired(int buffer_id) override;
   void OnError() override;
   void OnLog(const std::string& message) override;
   void OnStarted() override;
   void OnStartedUsingGpuDecode() override;
 
-  void CreateAndStartDeviceAsync(
-      const media::VideoCaptureParams& params,
-      BuildableVideoCaptureDevice::Callbacks* callbacks,
-      base::OnceClosure done_cb);
+  // Implementation of VideoCaptureDeviceLauncher::Callbacks interface:
+  void OnDeviceLaunched(
+      std::unique_ptr<LaunchedVideoCaptureDevice> device) override;
+  void OnDeviceLaunchFailed() override;
+  void OnDeviceLaunchAborted() override;
+
+  void CreateAndStartDeviceAsync(const media::VideoCaptureParams& params,
+                                 VideoCaptureDeviceLaunchObserver* callbacks,
+                                 base::OnceClosure done_cb);
   void ReleaseDeviceAsync(base::OnceClosure done_cb);
   bool IsDeviceAlive() const;
   void GetPhotoCapabilities(
       media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback) const;
   void SetPhotoOptions(
       media::mojom::PhotoSettingsPtr settings,
       media::VideoCaptureDevice::SetPhotoOptionsCallback callback);
   void TakePhoto(media::VideoCaptureDevice::TakePhotoCallback callback);
   void MaybeSuspend();
   void Resume();
@@ skipping 79 matching lines @@
 
   using EventHandlerAction =
       base::Callback<void(VideoCaptureControllerEventHandler* client,
                           VideoCaptureControllerID id)>;
   void PerformForClientsWithOpenSession(EventHandlerAction action);
 
   const int serial_id_;
   const std::string device_id_;
   const MediaStreamType stream_type_;
   const media::VideoCaptureParams parameters_;
-  std::unique_ptr<BuildableVideoCaptureDevice> buildable_device_;
-
-  std::unique_ptr<media::VideoFrameConsumerFeedbackObserver>
-      consumer_feedback_observer_;
+  std::unique_ptr<VideoCaptureDeviceLauncher> device_launcher_;
+  std::unique_ptr<LaunchedVideoCaptureDevice> launched_device_;
+  VideoCaptureDeviceLaunchObserver* device_launch_observer_;
 
   std::vector<BufferContext> buffer_contexts_;
 
   // All clients served by this controller.
   ControllerClients controller_clients_;
 
   // Takes on only the states 'STARTING', 'STARTED' and 'ERROR'. 'ERROR' is an
   // absorbing state which stops the flow of data to clients.
   VideoCaptureState state_;
 
   int next_buffer_context_id_ = 0;
 
   // True if the controller has received a video frame from the device.
   bool has_received_frames_;
 
   base::Optional<media::VideoCaptureFormat> video_capture_format_;
 
   base::WeakPtrFactory<VideoCaptureController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureController);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_CONTROLLER_H_