Introduce SelectSettings algorithm for MediaStream video tracks.

content/renderer/media/media_stream_constraints_util_sets.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_sets.h"
 
 #include <cmath>
 
 #include "content/renderer/media/media_stream_constraints_util.h"
-#include "content/renderer/media/media_stream_video_source.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 
 namespace content {
 
 using Point = ResolutionSet::Point;
 
 namespace {
 
 constexpr double kTolerance = 1e-5;
 
-constexpr int kDefaultHeight = MediaStreamVideoSource::kDefaultHeight;
-constexpr int kDefaultWidth = MediaStreamVideoSource::kDefaultWidth;
-constexpr double kDefaultAspectRatio =
-    MediaStreamVideoSource::kDefaultAspectRatio;
-
 // Not perfect, but good enough for this application.
 bool AreApproximatelyEqual(double d1, double d2) {
   if (std::fabs((d1 - d2)) <= kTolerance)
     return true;
 
   return d1 == d2 || (std::fabs((d1 - d2) / d1) <= kTolerance &&
                       std::fabs((d1 - d2) / d2) <= kTolerance);
 }
 
 bool IsLess(double d1, double d2) {
@@ skipping 231 matching lines @@
 ResolutionSet ResolutionSet::Intersection(const ResolutionSet& other) const {
   return ResolutionSet(std::max(min_height_, other.min_height_),
                        std::min(max_height_, other.max_height_),
                        std::max(min_width_, other.min_width_),
                        std::min(max_width_, other.max_width_),
                        std::max(min_aspect_ratio_, other.min_aspect_ratio_),
                        std::min(max_aspect_ratio_, other.max_aspect_ratio_));
 }
 
 Point ResolutionSet::SelectClosestPointToIdeal(
-    const blink::WebMediaTrackConstraintSet& constraint_set) const {
+    const blink::WebMediaTrackConstraintSet& constraint_set,
+    int default_height,
+    int default_width) const {
+  DCHECK_GE(default_height, 1);
+  DCHECK_GE(default_width, 1);
+  double default_aspect_ratio =
+      static_cast<double>(default_width) / static_cast<double>(default_height);
+
   DCHECK(!IsEmpty());
   int num_ideals = 0;
   if (constraint_set.height.hasIdeal())
     ++num_ideals;
   if (constraint_set.width.hasIdeal())
     ++num_ideals;
   if (constraint_set.aspectRatio.hasIdeal())
     ++num_ideals;
 
   switch (num_ideals) {
     case 0:
-      return SelectClosestPointToIdealAspectRatio(kDefaultAspectRatio);
+      return SelectClosestPointToIdealAspectRatio(
+          default_aspect_ratio, default_height, default_width);
 
     case 1:
       // This case requires a point closest to a line.
       // In all variants, if the ideal line intersects the polygon, select the
       // point in the intersection that is closest to preserving the default
       // aspect ratio or a default dimension.
       // If the ideal line is outside the polygon, there is either a single
       // vertex or a polygon side closest to the ideal line. If a single vertex,
       // select that vertex. If a polygon side, select the point on that side
       // that is closest to preserving the default aspect ratio or a default
       // dimension.
       if (constraint_set.height.hasIdeal()) {
         int ideal_height = ToValidDimension(constraint_set.height.ideal());
         ResolutionSet ideal_line = ResolutionSet::FromExactHeight(ideal_height);
         ResolutionSet intersection = Intersection(ideal_line);
         if (!intersection.IsEmpty()) {
           return intersection.ClosestPointTo(
-              Point(ideal_height, ideal_height * kDefaultAspectRatio));
+              Point(ideal_height, ideal_height * default_aspect_ratio));
         }
         std::vector<Point> closest_vertices =
             GetClosestVertices(&Point::height, ideal_height);
         Point ideal_point(closest_vertices[0].height(),
-                          closest_vertices[0].height() * kDefaultAspectRatio);
+                          closest_vertices[0].height() * default_aspect_ratio);
         return GetClosestPointToVertexOrSide(closest_vertices, ideal_point);
       } else if (constraint_set.width.hasIdeal()) {
         int ideal_width = ToValidDimension(constraint_set.width.ideal());
         ResolutionSet ideal_line = ResolutionSet::FromExactWidth(ideal_width);
         ResolutionSet intersection = Intersection(ideal_line);
         if (!intersection.IsEmpty()) {
           return intersection.ClosestPointTo(
-              Point(ideal_width / kDefaultAspectRatio, ideal_width));
+              Point(ideal_width / default_aspect_ratio, ideal_width));
         }
         std::vector<Point> closest_vertices =
             GetClosestVertices(&Point::width, ideal_width);
-        Point ideal_point(closest_vertices[0].width() / kDefaultAspectRatio,
+        Point ideal_point(closest_vertices[0].width() / default_aspect_ratio,
                           closest_vertices[0].width());
         return GetClosestPointToVertexOrSide(closest_vertices, ideal_point);
       } else {
         DCHECK(constraint_set.aspectRatio.hasIdeal());
         double ideal_aspect_ratio =
             ToValidAspectRatio(constraint_set.aspectRatio.ideal());
-        return SelectClosestPointToIdealAspectRatio(ideal_aspect_ratio);
+        return SelectClosestPointToIdealAspectRatio(
+            ideal_aspect_ratio, default_height, default_width);
       }
 
     case 2:
     case 3:
       double ideal_height;
       double ideal_width;
       if (constraint_set.height.hasIdeal()) {
         ideal_height = ToValidDimension(constraint_set.height.ideal());
         ideal_width =
             constraint_set.width.hasIdeal()
@@ skipping 10 matching lines @@
       return ClosestPointTo(Point(ideal_height, ideal_width));
 
     default:
       NOTREACHED();
   }
   NOTREACHED();
   return Point(-1, -1);
 }
 
 Point ResolutionSet::SelectClosestPointToIdealAspectRatio(
-    double ideal_aspect_ratio) const {
+    double ideal_aspect_ratio,
+    int default_height,
+    int default_width) const {
   ResolutionSet intersection =
       Intersection(ResolutionSet::FromExactAspectRatio(ideal_aspect_ratio));
   if (!intersection.IsEmpty()) {
-    Point default_height_point(kDefaultHeight,
-                               kDefaultHeight * ideal_aspect_ratio);
-    Point default_width_point(kDefaultWidth / ideal_aspect_ratio,
-                              kDefaultWidth);
+    Point default_height_point(default_height,
+                               default_height * ideal_aspect_ratio);
+    Point default_width_point(default_width / ideal_aspect_ratio,
+                              default_width);
     return SelectPointWithLargestArea(
         intersection.ClosestPointTo(default_height_point),
         intersection.ClosestPointTo(default_width_point));
   }
   std::vector<Point> closest_vertices =
       GetClosestVertices(&Point::AspectRatio, ideal_aspect_ratio);
   double actual_aspect_ratio = closest_vertices[0].AspectRatio();
-  Point default_height_point(kDefaultHeight,
-                             kDefaultHeight * actual_aspect_ratio);
-  Point default_width_point(kDefaultWidth / actual_aspect_ratio, kDefaultWidth);
+  Point default_height_point(default_height,
+                             default_height * actual_aspect_ratio);
+  Point default_width_point(default_width / actual_aspect_ratio, default_width);
   return SelectPointWithLargestArea(
       GetClosestPointToVertexOrSide(closest_vertices, default_height_point),
       GetClosestPointToVertexOrSide(closest_vertices, default_width_point));
 }
 
 Point ResolutionSet::ClosestPointTo(const Point& point) const {
   DCHECK(std::numeric_limits<double>::has_infinity);
+  DCHECK(std::isfinite(point.height()));
+  DCHECK(std::isfinite(point.width()));
 
   if (ContainsPoint(point))
     return point;
 
   auto vertices = ComputeVertices();
   DCHECK_GE(vertices.size(), 1U);
   Point best_candidate(0, 0);
   double best_distance = HUGE_VAL;
   for (size_t i = 0; i < vertices.size(); ++i) {
     Point candidate = Point::ClosestPointInSegment(
@@ skipping 123 matching lines @@
   return ResolutionSet(
       MinDimensionFromConstraint(constraint_set.height),
       MaxDimensionFromConstraint(constraint_set.height),
       MinDimensionFromConstraint(constraint_set.width),
       MaxDimensionFromConstraint(constraint_set.width),
       MinAspectRatioFromConstraint(constraint_set.aspectRatio),
       MaxAspectRatioFromConstraint(constraint_set.aspectRatio));
 }
 
 }  // namespace content