Change MediaStreamVideoSource to output different resolutions to different tracks depending on the …

content/renderer/media/media_stream_video_source.h

 // Copyright 2014 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_RENDERER_MEDIA_MEDIA_STREAM_VIDEO_SOURCE_H_
 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_VIDEO_SOURCE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/threading/non_thread_safe.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
 #include "content/renderer/media/media_stream_source.h"
-#include "content/renderer/media/video_frame_deliverer.h"
 #include "media/base/video_frame.h"
 #include "media/video/capture/video_capture_types.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 
 namespace content {
 
 class MediaStreamVideoTrack;
+class VideoTrackAdapter;
 
 // MediaStreamVideoSource is an interface used for sending video frames to a
 // MediaStreamVideoTrack.
 // http://dev.w3.org/2011/webrtc/editor/getusermedia.html
 // The purpose of this base class is to be able to implement different
 // MediaStreaVideoSources such as local video capture, video sources received
 // on a PeerConnection or a source created in NaCl.
 // All methods calls will be done from the main render thread.
 //
 // When  the first track is added to the source by calling AddTrack
 // the MediaStreamVideoSource implementation calls GetCurrentSupportedFormats.
 // the source implementation must call OnSupportedFormats.
 // MediaStreamVideoSource then match the constraints provided in AddTrack with
 // the formats and call StartSourceImpl. The source implementation must call
-// OnStartDone when the underlying source has been started or failed to
-// start.
+// OnStartDone when the underlying source has been started or failed to start.
 class CONTENT_EXPORT MediaStreamVideoSource
     : public MediaStreamSource,
       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
   MediaStreamVideoSource();
   virtual ~MediaStreamVideoSource();
 
   // Returns the MediaStreamVideoSource object owned by |source|.
   static MediaStreamVideoSource* GetVideoSource(
       const blink::WebMediaStreamSource& source);
@@ skipping 68 matching lines @@
     STARTED,
     ENDED
   };
   State state() const { return state_; }
 
  private:
   void OnSupportedFormats(const media::VideoCaptureFormats& formats);
 
   // Finds the first constraints in |requested_constraints_| that can be
   // fulfilled. |best_format| is set to the video resolution that can be
-  // fulfilled. |frame_output_size| is the requested frame size after cropping.
-  // |resulting_constraints| is set to the found constraints in
-  // |requested_constraints_|.
+  // fulfilled.
   bool FindBestFormatWithConstraints(
       const media::VideoCaptureFormats& formats,
-      media::VideoCaptureFormat* best_format,
-      gfx::Size* frame_output_size,
-      blink::WebMediaConstraints* resulting_constraints);
+      media::VideoCaptureFormat* best_format);
 
   // Trigger all cached callbacks from AddTrack. AddTrack is successful
   // if the capture delegate has started and the constraints provided in
   // AddTrack match the format that was used to start the device.
   // Note that it must be ok to delete the MediaStreamVideoSource object
   // in the context of the callback. If gUM fail, the implementation will
   // simply drop the references to the blink source and track which will lead
   // to that this object is deleted.
   void FinalizeAddTrack();
 
   State state_;
 
   media::VideoCaptureFormat current_format_;
-  blink::WebMediaConstraints current_constraints_;
-  // |max_frame_output_size_| is the maximum frame size allowed by
-  // |current_constraints_|.
-  gfx::Size max_frame_output_size_;
 
   struct RequestedConstraints {
     RequestedConstraints(MediaStreamVideoTrack* track,
                          const VideoCaptureDeliverFrameCB& frame_callback,
                          const blink::WebMediaConstraints& constraints,
                          const ConstraintsCallback& callback);
     ~RequestedConstraints();
 
     MediaStreamVideoTrack* track;
     VideoCaptureDeliverFrameCB frame_callback;
     blink::WebMediaConstraints constraints;
     ConstraintsCallback callback;
   };
   std::vector<RequestedConstraints> requested_constraints_;
 
   media::VideoCaptureFormats supported_formats_;
 
-  // |FrameDeliverer| is an internal helper object used for delivering video
-  // frames using callbacks to all registered tracks on the IO thread.
-  class FrameDeliverer;
-  scoped_refptr<FrameDeliverer> frame_deliverer_;
+  // |track_adapter_| delivers video frames to the tracks on the IO-thread.
+  scoped_refptr<VideoTrackAdapter> track_adapter_;
 
-  // Tracks that currently are receiving video frames.
+  // Tracks that currently are connected to this source.
   std::vector<MediaStreamVideoTrack*> tracks_;
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaStreamVideoSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamVideoSource);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_VIDEO_SOURCE_H_