Introduce SelectSettings algorithm for MediaStream video tracks.

content/renderer/media/media_stream_constraints_util_sets_unittest.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 <string>
 #include <vector>
 
-#include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 using Point = ResolutionSet::Point;
 
 namespace {
 
+const int kDefaultWidth = 640;
+const int kDefaultHeight = 480;
+constexpr double kDefaultAspectRatio =
+    static_cast<double>(kDefaultWidth) / static_cast<double>(kDefaultHeight);
+
 // Defined as macro in order to get more informative line-number information
 // when a test fails.
 #define EXPECT_POINT_EQ(p1, p2)                     \
   do {                                              \
     EXPECT_DOUBLE_EQ((p1).height(), (p2).height()); \
     EXPECT_DOUBLE_EQ((p1).width(), (p2).width());   \
   } while (0)
 
 // Checks if |point| is an element of |vertices| using
 // Point::IsApproximatelyEqualTo() to test for equality.
@@ skipping 76 matching lines @@
   double projection_height = projection_length * std::cos(segment_angle);
   double projection_width = projection_length * std::sin(segment_angle);
   return Point(projection_height, projection_width);
 }
 
 }  // namespace
 
 class MediaStreamConstraintsUtilSetsTest : public testing::Test {
  protected:
   using P = Point;
+
+  Point SelectClosestPointToIdeal(const ResolutionSet& set) {
+    return set.SelectClosestPointToIdeal(
+        factory_.CreateWebMediaConstraints().basic(), kDefaultHeight,
+        kDefaultWidth);
+  }
+
   MockConstraintFactory factory_;
 };
 
 // This test tests the test-harness function AreValidVertices.
 TEST_F(MediaStreamConstraintsUtilSetsTest, VertexListValidity) {
   EXPECT_TRUE(AreCounterclockwise({P(1, 1)}));
   EXPECT_TRUE(AreCounterclockwise({P(1, 1)}));
   EXPECT_TRUE(AreCounterclockwise({P(1, 0), P(0, 1)}));
   EXPECT_TRUE(AreCounterclockwise({P(1, 1), P(0, 0), P(1, 0)}));
 
@@ skipping 448 matching lines @@
   ResolutionSet set(100, 1000, 100, 1000, 0.5, 2.0);
 
   int kIdealHeight = 500;
   int kIdealWidth = 1000;
   double kIdealAspectRatio = 1.5;
 
   // Ideal height.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
-    EXPECT_POINT_EQ(
-        Point(kIdealHeight,
-              kIdealHeight * MediaStreamVideoSource::kDefaultAspectRatio),
-        point);
+    Point point = SelectClosestPointToIdeal(set);
+    EXPECT_POINT_EQ(Point(kIdealHeight, kIdealHeight * kDefaultAspectRatio),
+                    point);
   }
 
   // Ideal width.
   {
     factory_.Reset();
     factory_.basic().width.setIdeal(kIdealWidth);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
-    EXPECT_POINT_EQ(
-        Point(kIdealWidth / MediaStreamVideoSource::kDefaultAspectRatio,
-              kIdealWidth),
-        point);
+    Point point = SelectClosestPointToIdeal(set);
+    EXPECT_POINT_EQ(Point(kIdealWidth / kDefaultAspectRatio, kIdealWidth),
+                    point);
   }
 
   // Ideal aspect ratio.
   {
     factory_.Reset();
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
-    EXPECT_DOUBLE_EQ(MediaStreamVideoSource::kDefaultHeight, point.height());
-    EXPECT_DOUBLE_EQ(MediaStreamVideoSource::kDefaultHeight * kIdealAspectRatio,
-                     point.width());
+    Point point = SelectClosestPointToIdeal(set);
+    EXPECT_DOUBLE_EQ(kDefaultHeight, point.height());
+    EXPECT_DOUBLE_EQ(kDefaultHeight * kIdealAspectRatio, point.width());
   }
 
   // Ideal height and width.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
     factory_.basic().width.setIdeal(kIdealWidth);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(kIdealHeight, kIdealWidth), point);
   }
 
   // Ideal height and aspect-ratio.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(kIdealHeight, kIdealHeight * kIdealAspectRatio),
                     point);
   }
 
   // Ideal width and aspect-ratio.
   {
     factory_.Reset();
     factory_.basic().width.setIdeal(kIdealWidth);
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(kIdealWidth / kIdealAspectRatio, kIdealWidth), point);
   }
 
   // Ideal height, width and aspect-ratio.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
     factory_.basic().width.setIdeal(kIdealWidth);
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     // Ideal aspect ratio should be ignored.
     EXPECT_POINT_EQ(Point(kIdealHeight, kIdealWidth), point);
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilSetsTest, ResolutionIdealOutsideSinglePoint) {
   // This set is a triangle with vertices (100,100), (1000,100) and (1000,1000).
   ResolutionSet set(100, 1000, 100, 1000, 0.0, 1.0);
 
   int kIdealHeight = 50;
   int kIdealWidth = 1100;
   double kIdealAspectRatio = 0.09;
   Point kVertex1(100, 100);
   Point kVertex2(1000, 100);
   Point kVertex3(1000, 1000);
 
   // Ideal height.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(kVertex1, point);
   }
 
   // Ideal width.
   {
     factory_.Reset();
     factory_.basic().width.setIdeal(kIdealWidth);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(kVertex3, point);
   }
 
   // Ideal aspect ratio.
   {
     factory_.Reset();
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(kVertex2, point);
   }
 
   // Ideal height and width.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
     factory_.basic().width.setIdeal(kIdealWidth);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     Point expected = set.ClosestPointTo(Point(kIdealHeight, kIdealWidth));
     EXPECT_POINT_EQ(expected, point);
   }
 
   // Ideal height and aspect-ratio.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     Point expected = set.ClosestPointTo(
         Point(kIdealHeight, kIdealHeight * kIdealAspectRatio));
     EXPECT_POINT_EQ(expected, point);
   }
 
   // Ideal width and aspect-ratio.
   {
     factory_.Reset();
     factory_.basic().width.setIdeal(kIdealWidth);
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     Point expected =
         set.ClosestPointTo(Point(kIdealWidth / kIdealAspectRatio, kIdealWidth));
     EXPECT_POINT_EQ(expected, point);
   }
 
   // Ideal height, width and aspect-ratio.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
     factory_.basic().width.setIdeal(kIdealWidth);
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     // kIdealAspectRatio is ignored if all three ideals are given.
     Point expected = set.ClosestPointTo(Point(kIdealHeight, kIdealWidth));
     EXPECT_POINT_EQ(expected, point);
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilSetsTest,
        ResolutionIdealOutsideMultiplePoints) {
   // This set is a triangle with vertices (100,100), (1000,100) and (1000,1000).
   ResolutionSet set(100, 1000, 100, 1000, 0.0, 1.0);
 
   int kIdealHeight = 1100;
   int kIdealWidth = 50;
   double kIdealAspectRatio = 11.0;
   Point kVertex1(100, 100);
   Point kVertex2(1000, 100);
   Point kVertex3(1000, 1000);
 
   // Ideal height.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(kIdealHeight);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     // Parallel to the side between kVertex2 and kVertex3. Point closest to
     // default aspect ratio is kVertex3.
     EXPECT_POINT_EQ(kVertex3, point);
   }
 
   // Ideal width.
   {
     factory_.Reset();
     factory_.basic().width.setIdeal(kIdealWidth);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     // Parallel to the side between kVertex1 and kVertex2. Point closest to
     // default aspect ratio is kVertex1.
     EXPECT_POINT_EQ(kVertex1, point);
   }
 
   // Ideal aspect ratio.
   {
     factory_.Reset();
     factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     // The side between kVertex1 and kVertex3 is closest. The points closest to
     // default dimensions are (kDefaultHeight, kDefaultHeight * AR)
     // and (kDefaultWidth / AR, kDefaultWidth). Since the aspect ratio of the
     // polygon side is less than the default, the algorithm preserves the
     // default width.
-    Point expected(
-        MediaStreamVideoSource::kDefaultWidth / kVertex1.AspectRatio(),
-        MediaStreamVideoSource::kDefaultWidth);
+    Point expected(kDefaultWidth / kVertex1.AspectRatio(), kDefaultWidth);
     EXPECT_POINT_EQ(expected, point);
     EXPECT_TRUE(set.ContainsPoint(expected));
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilSetsTest,
        ResolutionUnconstrainedExtremeIdeal) {
   ResolutionSet set;
 
   // Ideal height.
   {
     factory_.Reset();
     factory_.basic().height.setIdeal(std::numeric_limits<long>::max());
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(
         Point(ResolutionSet::kMaxDimension, ResolutionSet::kMaxDimension),
         point);
     factory_.basic().height.setIdeal(0);
-    point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(0, 0), point);
   }
 
   // Ideal width.
   {
     factory_.Reset();
     factory_.basic().width.setIdeal(std::numeric_limits<long>::max());
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
-    EXPECT_POINT_EQ(Point(ResolutionSet::kMaxDimension /
-                              MediaStreamVideoSource::kDefaultAspectRatio,
+    Point point = SelectClosestPointToIdeal(set);
+    EXPECT_POINT_EQ(Point(ResolutionSet::kMaxDimension / kDefaultAspectRatio,
                           ResolutionSet::kMaxDimension),
                     point);
     factory_.basic().width.setIdeal(0);
-    point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(0, 0), point);
   }
 
   // Ideal Aspect Ratio.
   {
     factory_.Reset();
     factory_.basic().aspectRatio.setIdeal(HUGE_VAL);
-    Point point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    Point point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(0, ResolutionSet::kMaxDimension), point);
     factory_.basic().aspectRatio.setIdeal(0.0);
-    point = set.SelectClosestPointToIdeal(
-        factory_.CreateWebMediaConstraints().basic());
+    point = SelectClosestPointToIdeal(set);
     EXPECT_POINT_EQ(Point(ResolutionSet::kMaxDimension, 0), point);
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilSetsTest, ResolutionVertices) {
   // Empty set.
   {
     ResolutionSet set(1000, 100, 1000, 100, 0.5, 1.5);
     ASSERT_TRUE(set.IsEmpty());
     auto vertices = set.ComputeVertices();
@@ skipping 417 matching lines @@
   EXPECT_TRUE(intersection.Contains(true));
   EXPECT_TRUE(intersection.Contains(true));
 
   // Empty intersection.
   set = BoolSet({true});
   intersection = set.Intersection(BoolSet({false}));
   EXPECT_TRUE(intersection.IsEmpty());
 }
 
 }  // namespace content