[Mojo Video Capture] Introduce abstraction 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/buildable_video_capture_device.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.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 {
 
 // Implementation of media::VideoFrameReceiver that distributes received frames
 // to potentially multiple connected clients.
-class CONTENT_EXPORT VideoCaptureController : public media::VideoFrameReceiver {
+// A call to CreateAndStartDeviceAsync() asynchronously brings up the device. If
+// CreateAndStartDeviceAsync() has beend called, ReleaseDeviceAsync() must be

[emircan, 2017/03/16 20:54:03]

s/beend/been/

[chfremer, 2017/03/16 22:02:30]

Done.

+// 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
+// CreateAndStartDeviceAsync().
+class CONTENT_EXPORT VideoCaptureController
+    : public media::VideoFrameReceiver,
+      public base::RefCountedThreadSafe<VideoCaptureController> {
  public:
-  VideoCaptureController();
-  ~VideoCaptureController() override;
+  VideoCaptureController(
+      const std::string& device_id,
+      MediaStreamType stream_type,
+      const media::VideoCaptureParams& params,
+      std::unique_ptr<BuildableVideoCaptureDevice> buildable_device);
 
   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);
@@ skipping 57 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,
+                                 BuildableDeviceCallbacks* callbacks,
+                                 std::unique_ptr<Ownership> context_reference);
+  void ReleaseDeviceAsync(std::unique_ptr<Ownership> context_reference);
+  bool IsDeviceAlive() const;
+  bool CorrespondsToController(const VideoCaptureController* controller) 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();
+  void RequestRefreshFrame();
+  void SetDesktopCaptureWindowIdAsync(
+      gfx::NativeViewId window_id,
+      std::unique_ptr<Ownership> context_reference);
+  int serial_id() const { return serial_id_; }
+  const std::string& device_id() const { return device_id_; }
+  MediaStreamType stream_type() const { return stream_type_; }
+  const media::VideoCaptureParams& parameters() const { return parameters_; }
+
  private:
+  friend class base::RefCountedThreadSafe<VideoCaptureController>;
   struct ControllerClient;
   typedef std::list<std::unique_ptr<ControllerClient>> ControllerClients;
 
   class BufferContext {
    public:
     BufferContext(
         int buffer_context_id,
         int buffer_id,
         media::VideoFrameConsumerFeedbackObserver* consumer_feedback_observer,
         mojo::ScopedSharedBufferHandle handle);
@@ skipping 28 matching lines @@
     int frame_feedback_id_;
     media::VideoFrameConsumerFeedbackObserver* consumer_feedback_observer_;
     mojo::ScopedSharedBufferHandle buffer_handle_;
     double max_consumer_utilization_;
     int consumer_hold_count_;
     std::unique_ptr<
         media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>
         buffer_read_permission_;
   };
 
+  ~VideoCaptureController() override;
+
   // Find a client of |id| and |handler| in |clients|.
   ControllerClient* FindClient(VideoCaptureControllerID id,
                                VideoCaptureControllerEventHandler* handler,
                                const ControllerClients& clients);
 
   // Find a client of |session_id| in |clients|.
   ControllerClient* FindClient(int session_id,
                                const ControllerClients& clients);
 
   std::vector<BufferContext>::iterator FindBufferContextFromBufferContextId(
       int buffer_context_id);
   std::vector<BufferContext>::iterator FindUnretiredBufferContextFromBufferId(
       int buffer_id);
 
   void OnClientFinishedConsumingBuffer(ControllerClient* client,
                                        int buffer_id,
                                        double consumer_resource_utilization);
   void ReleaseBufferContext(
       const std::vector<BufferContext>::iterator& buffer_state_iter);
 
   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::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_;
 
   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_