Remove support for old getUserMedia video constraints algorithm.

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 <memory>
 #include <vector>
 
@@ skipping 12 matching lines @@
 #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;
 struct VideoTrackAdapterSettings;
 
-CONTENT_EXPORT bool IsOldVideoConstraints();
-
 // 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.

[hbos_chromium, 2017/06/30 15:04:12]

Update comment after removing GetCurrentSupportedFormats.

[Guido Urdaneta, 2017/07/03 18:43:16]

Acknowledged. Will do in follow-up CL.

 // 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.
 class CONTENT_EXPORT MediaStreamVideoSource : public MediaStreamSource {
  public:
   enum {
     // Default resolution. If no constraints are specified and the delegate
     // support it, this is the resolution that will be used.
     kDefaultWidth = 640,
@@ skipping 11 matching lines @@
 
   // Returns the MediaStreamVideoSource object owned by |source|.
   static MediaStreamVideoSource* GetVideoSource(
       const blink::WebMediaStreamSource& source);
 
   // Puts |track| in the registered tracks list.
   void AddTrack(MediaStreamVideoTrack* track,
                 const VideoTrackAdapterSettings& track_adapter_settings,
                 const VideoCaptureDeliverFrameCB& frame_callback,
                 const ConstraintsCallback& callback);
-  // TODO(guidou): Remove this method. http://crbug.com/706408
-  void AddTrackLegacy(MediaStreamVideoTrack* track,
-                      const VideoCaptureDeliverFrameCB& frame_callback,
-                      const blink::WebMediaConstraints& constraints,
-                      const ConstraintsCallback& callback);
   void RemoveTrack(MediaStreamVideoTrack* track);
 
   // Called by |track| to notify the source whether it has any paths to a
   // consuming endpoint.
   void UpdateHasConsumers(MediaStreamVideoTrack* track, bool has_consumers);
 
   void UpdateCapturingLinkSecure(MediaStreamVideoTrack* track, bool is_secure);
 
   // Request underlying source to capture a new frame.
   virtual void RequestRefreshFrame() {}
@@ skipping 21 matching lines @@
   // |max_requested_height| and |max_requested_width| is the max height and
   // width set as a mandatory constraint if set when calling
   // MediaStreamVideoSource::AddTrack. If max height and max width is not set
   // |max_requested_height| and |max_requested_width| are 0.
   // TODO(guidou): Remove when the standard constraints code stabilizes.
   // http://crbug.com/706408
   virtual void GetCurrentSupportedFormats(
       int max_requested_width,
       int max_requested_height,
       double max_requested_frame_rate,
       const VideoCaptureDeviceFormatsCB& callback) = 0;

[hbos_chromium, 2017/06/30 15:04:12]

This was only used by AddTrackLegacy; remove it.

[Guido Urdaneta, 2017/07/03 18:43:16]

Will remove it in a follow-up CL together with other interface changes.

 
   // TODO(guidou): Rename to GetCurrentFormat. http://crbug.com/706804
   virtual base::Optional<media::VideoCaptureFormat> GetCurrentFormatImpl()
       const;
 
   // An implementation must start capturing frames using the requested
   // |format|. The fulfilled |constraints| are provided as additional context,
   // and may be used to modify the behavior of the source. When the source has
   // started or the source failed to start OnStartDone must be called. An
   // implementation must call |frame_callback| on the IO thread with the
@@ skipping 16 matching lines @@
   // frames, giving it the option of running in an "idle" state to minimize
   // resource usage.
   virtual void OnHasConsumers(bool has_consumers) {}
 
   // Optionally overridden by subclasses to act on whether the capturing link
   // has become secure or insecure.
   virtual void OnCapturingLinkSecured(bool is_secure) {}
 
   enum State {
     NEW,
-    // TODO(guidou): Remove this state. http://crbug.com/706408
-    RETRIEVING_CAPABILITIES,
     STARTING,
     STARTED,
     ENDED
   };
   State state() const { return state_; }
 
   SEQUENCE_CHECKER(sequence_checker_);
 
  private:
-  void OnSupportedFormats(const media::VideoCaptureFormats& formats);
-
-  // Finds the first WebMediaConstraints in |track_descriptors_| that allows
-  // the use of one of the |formats|.  |best_format| and |fulfilled_constraints|
-  // are set to the results of this search-and-match operation.  Returns false
-  // if no WebMediaConstraints allow the use any of the |formats|.
-  bool FindBestFormatWithConstraints(
-      const media::VideoCaptureFormats& formats,
-      media::VideoCaptureFormat* best_format,
-      blink::WebMediaConstraints* fulfilled_constraints);
-
   // 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 fails, the implementation will
   // simply drop the references to the blink source and track which will lead
   // to this object being deleted.
   void FinalizeAddTrack();
-  // TODO(guidou): Remove this method. http://crbug.com/706408
-  void FinalizeAddTrackLegacy();
 
   State state_;
 
-  // TODO(guidou): Remove this field. http://crbug.com/706408
-  media::VideoCaptureFormat current_format_;
-
   struct TrackDescriptor {
     TrackDescriptor(MediaStreamVideoTrack* track,
                     const VideoCaptureDeliverFrameCB& frame_callback,
-                    const blink::WebMediaConstraints& constraints,
-                    const ConstraintsCallback& callback);
-    TrackDescriptor(MediaStreamVideoTrack* track,
-                    const VideoCaptureDeliverFrameCB& frame_callback,
                     std::unique_ptr<VideoTrackAdapterSettings> adapter_settings,
                     const ConstraintsCallback& callback);
     TrackDescriptor(TrackDescriptor&& other);
     TrackDescriptor& operator=(TrackDescriptor&& other);
     ~TrackDescriptor();
 
     MediaStreamVideoTrack* track;
     VideoCaptureDeliverFrameCB frame_callback;
-    // TODO(guidou): remove this field. http://crbug.com/706408
-    blink::WebMediaConstraints constraints;
     // TODO(guidou): Make |adapter_settings| a regular field instead of a
     // unique_ptr.
     std::unique_ptr<VideoTrackAdapterSettings> adapter_settings;
     ConstraintsCallback callback;
   };
   std::vector<TrackDescriptor> track_descriptors_;
 
   media::VideoCaptureFormats supported_formats_;

[hbos_chromium, 2017/06/30 15:04:12]

Remove, I don't think it's used anymore now that RETRIEVING_CAPABILITIES /
OnSupportedFormats is gone.

[Guido Urdaneta, 2017/07/03 18:43:16]

Done.

 
   // |track_adapter_| delivers video frames to the tracks on the IO-thread.
   const scoped_refptr<VideoTrackAdapter> track_adapter_;
 
   // Tracks that currently are connected to this source.
   std::vector<MediaStreamVideoTrack*> tracks_;
 
   // Tracks that have no paths to a consuming endpoint, and so do not need
   // frames delivered from the source. This is a subset of |tracks_|.
   std::vector<MediaStreamVideoTrack*> suspended_tracks_;
 
   // This is used for tracking if all connected video sinks are secure.
   SecureDisplayLinkTracker<MediaStreamVideoTrack> secure_tracker_;
 
   // 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_