Update constraints processing for video content capture.

content/renderer/media/media_stream_constraints_util_video_content.cc

 // Copyright 2017 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.
 
 #include "content/renderer/media/media_stream_constraints_util_video_content.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 60 matching lines @@
   return BoolSet({constraint.Exact()});
 }
 
 using DoubleRangeSet = NumericRangeSet<double>;
 
 class VideoContentCaptureCandidates {
  public:
   VideoContentCaptureCandidates()
       : has_explicit_max_height_(false),
         has_explicit_max_width_(false),
+        has_explicit_min_frame_rate_(false),
         has_explicit_max_frame_rate_(false),
         device_id_set_(StringSet::UniversalSet()),
         noise_reduction_set_(BoolSet::UniversalSet()) {}
   explicit VideoContentCaptureCandidates(
       const blink::WebMediaTrackConstraintSet& constraint_set)
       : resolution_set_(ResolutionSet::FromConstraintSet(constraint_set)),
         has_explicit_max_height_(ConstraintHasMax(constraint_set.height) &&
                                  ConstraintMax(constraint_set.height) <=
                                      kMaxScreenCastDimension),
         has_explicit_max_width_(ConstraintHasMax(constraint_set.width) &&
                                 ConstraintMax(constraint_set.width) <=
                                     kMaxScreenCastDimension),
         frame_rate_set_(
             DoubleRangeSet::FromConstraint(constraint_set.frame_rate)),
+        has_explicit_min_frame_rate_(
+            ConstraintHasMin(constraint_set.frame_rate) &&
+            ConstraintMin(constraint_set.frame_rate) >= 0.0),
         has_explicit_max_frame_rate_(
             ConstraintHasMax(constraint_set.frame_rate) &&
             ConstraintMax(constraint_set.frame_rate) <=
                 kMaxScreenCastFrameRate),
         device_id_set_(StringSetFromConstraint(constraint_set.device_id)),
         noise_reduction_set_(
             BoolSetFromConstraint(constraint_set.goog_noise_reduction)) {}
 
   VideoContentCaptureCandidates(VideoContentCaptureCandidates&& other) =
       default;
   VideoContentCaptureCandidates& operator=(
       VideoContentCaptureCandidates&& other) = default;
 
   bool IsEmpty() const {
     return resolution_set_.IsEmpty() || frame_rate_set_.IsEmpty() ||
            device_id_set_.IsEmpty() || noise_reduction_set_.IsEmpty();
   }
 
   VideoContentCaptureCandidates Intersection(
       const VideoContentCaptureCandidates& other) {
     VideoContentCaptureCandidates intersection;
     intersection.resolution_set_ =
         resolution_set_.Intersection(other.resolution_set_);
     intersection.has_explicit_max_height_ =
         has_explicit_max_height_ || other.has_explicit_max_height_;
     intersection.has_explicit_max_width_ =
         has_explicit_max_width_ || other.has_explicit_max_width_;
     intersection.frame_rate_set_ =
         frame_rate_set_.Intersection(other.frame_rate_set_);
+    intersection.has_explicit_min_frame_rate_ =
+        has_explicit_min_frame_rate_ || other.has_explicit_min_frame_rate_;
     intersection.has_explicit_max_frame_rate_ =
         has_explicit_max_frame_rate_ || other.has_explicit_max_frame_rate_;
     intersection.device_id_set_ =
         device_id_set_.Intersection(other.device_id_set_);
     intersection.noise_reduction_set_ =
         noise_reduction_set_.Intersection(other.noise_reduction_set_);
     return intersection;
   }
 
   const ResolutionSet& resolution_set() const { return resolution_set_; }
   bool has_explicit_max_height() const { return has_explicit_max_height_; }
   bool has_explicit_max_width() const { return has_explicit_max_width_; }
   const DoubleRangeSet& frame_rate_set() const { return frame_rate_set_; }
+  bool has_explicit_min_frame_rate() const {
+    return has_explicit_min_frame_rate_;
+  }
   bool has_explicit_max_frame_rate() const {
     return has_explicit_max_frame_rate_;
   }
   const StringSet& device_id_set() const { return device_id_set_; }
   const BoolSet& noise_reduction_set() const { return noise_reduction_set_; }
   void set_resolution_set(const ResolutionSet& set) { resolution_set_ = set; }
   void set_frame_rate_set(const DoubleRangeSet& set) { frame_rate_set_ = set; }
 
  private:
   ResolutionSet resolution_set_;
   bool has_explicit_max_height_;
   bool has_explicit_max_width_;
   DoubleRangeSet frame_rate_set_;
+  bool has_explicit_min_frame_rate_;
   bool has_explicit_max_frame_rate_;
   StringSet device_id_set_;
   BoolSet noise_reduction_set_;
 };
 
 ResolutionSet ScreenCastResolutionCapabilities() {
   return ResolutionSet(kMinScreenCastDimension, kMaxScreenCastDimension,
                        kMinScreenCastDimension, kMaxScreenCastDimension,
                        kMinScreenCastAspectRatio, kMaxScreenCastAspectRatio);
 }
@@ skipping 183 matching lines @@
       candidates.noise_reduction_set(), basic_constraint_set);
 
   // Using false because the resolution policy for content capture can produce
   // frames in various sizes.
   bool expect_source_native_size = false;
   auto track_adapter_settings = SelectVideoTrackAdapterSettings(
       basic_constraint_set, candidates.resolution_set(),
       candidates.frame_rate_set(), capture_params.requested_format,
       expect_source_native_size);
 
+  base::Optional<double> min_frame_rate;
+  if (candidates.has_explicit_min_frame_rate())
+    min_frame_rate = candidates.frame_rate_set().Min();
+
+  base::Optional<double> max_frame_rate;
+  if (candidates.has_explicit_max_frame_rate())
+    max_frame_rate = candidates.frame_rate_set().Max();
+
   return VideoCaptureSettings(std::move(device_id), capture_params,
                               noise_reduction, track_adapter_settings,
-                              candidates.frame_rate_set().Min());
+                              min_frame_rate, max_frame_rate);
 }
 
 VideoCaptureSettings UnsatisfiedConstraintsResult(
     const VideoContentCaptureCandidates& candidates,
     const blink::WebMediaTrackConstraintSet& constraint_set) {
   DCHECK(candidates.IsEmpty());
   if (candidates.resolution_set().IsHeightEmpty()) {
     return VideoCaptureSettings(constraint_set.height.GetName());
   } else if (candidates.resolution_set().IsWidthEmpty()) {
     return VideoCaptureSettings(constraint_set.width.GetName());
@@ skipping 33 matching lines @@
     if (!intersection.IsEmpty())
       candidates = std::move(intersection);
   }
 
   DCHECK(!candidates.IsEmpty());
   return SelectResultFromCandidates(candidates, constraints.Basic(),
                                     stream_source);
 }
 
 }  // namespace content