Hook up EncodedVideoSource on the browser side

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.
 // VideoCaptureManager will open OS dependent instances of VideoCaptureDevice.
 // A device can only be opened once.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_
 
 #include <list>
 #include <map>
 
 #include "base/memory/ref_counted.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/common/content_export.h"
 #include "content/common/media/media_stream_options.h"
 #include "media/video/capture/video_capture_device.h"
 #include "media/video/capture/video_capture_types.h"
 
+namespace media {
+struct RuntimeVideoEncodingParameters;
+struct VideoEncodingParameters;
+}  // namespace media
+
 namespace content {
 class MockVideoCaptureManager;
 class VideoCaptureController;
 class VideoCaptureControllerEventHandler;
 
 // VideoCaptureManager opens/closes and start/stops video capture devices.
 class CONTENT_EXPORT VideoCaptureManager : public MediaStreamProvider {
  public:
   // Calling |Start| of this id will open the first device, even though open has
   // not been called. This is used to be able to use video capture devices
@@ skipping 18 matching lines @@
   // Start allocates the device and no other application can use the device
   // before Stop is called. Captured video frames will be delivered to
   // video_capture_receiver.
   virtual void Start(const media::VideoCaptureParams& capture_params,
              media::VideoCaptureDevice::EventHandler* video_capture_receiver);
 
   // Stops capture device referenced by |capture_session_id|. No more frames
   // will be delivered to the frame receiver, and |stopped_cb| will be called.
   // |stopped_cb| can be NULL.
   virtual void Stop(const media::VideoCaptureSessionId& capture_session_id,
-            base::Closure stopped_cb);
+                    const base::Closure& stopped_cb);
+
+  // Called by VideoCaptureHost to request a parameter change in the encoded
+  // output bitstream of a capture device, if supported.
+  virtual void TryConfigureEncodedBitstream(
+      const media::VideoCaptureSessionId& session_id,
+      const media::RuntimeVideoEncodingParameters& params);
 
   // Used by unit test to make sure a fake device is used instead of a real
   // video capture device. Due to timing requirements, the function must be
   // called before EnumerateDevices and Open.
   void UseFakeDevice();
 
   // Called by VideoCaptureHost to get a controller for |capture_params|.
   // The controller is returned via calling |added_cb|.
   void AddController(
       const media::VideoCaptureParams& capture_params,
       VideoCaptureControllerEventHandler* handler,
-      base::Callback<void(VideoCaptureController*)> added_cb);
+      const base::Callback<void(VideoCaptureController*)>& added_cb);
   // Called by VideoCaptureHost to remove the |controller|.
   void RemoveController(
       VideoCaptureController* controller,
       VideoCaptureControllerEventHandler* handler);
 
+  // Called by VideoCaptureHost to request the encoding capabilities of a
+  // capture device.
+  void RequestEncodingCapability(
+      const media::VideoCaptureSessionId& session_id,
+      const base::Callback<void(
+          const media::VideoEncodingCapability&)>& caps_cb);
+
  private:
   friend class MockVideoCaptureManager;
 
   virtual ~VideoCaptureManager();
 
   typedef std::list<VideoCaptureControllerEventHandler*> Handlers;
   struct Controller;
 
   // Called by the public functions, executed on device thread.
   void OnEnumerateDevices(MediaStreamType stream_type);
   void OnOpen(int capture_session_id, const StreamDeviceInfo& device);
   void OnClose(int capture_session_id);
   void OnStart(const media::VideoCaptureParams capture_params,
                media::VideoCaptureDevice::EventHandler* video_capture_receiver);
   void OnStop(const media::VideoCaptureSessionId capture_session_id,
-              base::Closure stopped_cb);
+              const base::Closure& stopped_cb);
+  void OnTryConfigureEncodedBitstream(
+      const media::VideoCaptureSessionId& session_id,
+      const media::RuntimeVideoEncodingParameters& params);
   void DoAddControllerOnDeviceThread(
       const media::VideoCaptureParams capture_params,
       VideoCaptureControllerEventHandler* handler,
-      base::Callback<void(VideoCaptureController*)> added_cb);
+      const base::Callback<void(VideoCaptureController*)>& added_cb);
   void DoRemoveControllerOnDeviceThread(
       VideoCaptureController* controller,
       VideoCaptureControllerEventHandler* handler);
+  void DoRequestEncodingCapabilityOnDeviceThread(
+      const media::VideoCaptureSessionId& session_id,
+      const base::Callback<void(
+          const media::VideoEncodingCapability&)>& caps_cb);
 
   // Executed on Browser::IO thread to call Listener.
   void OnOpened(MediaStreamType type, int capture_session_id);
   void OnClosed(MediaStreamType type, int capture_session_id);
   void OnDevicesEnumerated(MediaStreamType stream_type,
                            scoped_ptr<StreamDeviceInfoArray> devices);
   void OnError(MediaStreamType type, int capture_session_id,
                MediaStreamProviderError error);
 
   // Executed on device thread to make sure Listener is called from
@@ skipping 40 matching lines @@
   // VideoCaptureDevice is one-to-one mapped to VideoCaptureController.
   typedef std::map<media::VideoCaptureDevice*, Controller*> Controllers;
   Controllers controllers_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_