Update constraints algorithm for video content capture.

content/renderer/media/media_stream_constraints_util_video_content_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_video_content.h"
 
 #include <cmath>
 #include <string>
 
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "media/base/limits.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 
 namespace content {
 
 namespace {
 
-const double kDefaultScreenCastAspectRatio =
-    static_cast<double>(kDefaultScreenCastWidth) /
-    static_cast<double>(kDefaultScreenCastHeight);
-
 void CheckNonResolutionDefaults(const VideoCaptureSettings& result) {
   EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
   EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
   EXPECT_EQ(std::string(), result.device_id());
 }
 
 void CheckNonFrameRateDefaults(const VideoCaptureSettings& result) {
   EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
   EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
   EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
@@ skipping 228 matching lines @@
             result.Width());
   CheckNonResolutionDefaults(result);
   EXPECT_EQ(1.0 / kHeight, result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kHeight,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinHeight) {
   constraint_factory_.Reset();
-  const int kHeight = 1000;
+  const int kHeight = 2000;
   constraint_factory_.basic().height.setMin(kHeight);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // kHeight is greater that the default, so expect kHeight.
   EXPECT_EQ(kHeight, result.Height());
   EXPECT_EQ(std::round(kHeight * kDefaultScreenCastAspectRatio),
             result.Width());
   CheckNonResolutionDefaults(result);
   EXPECT_EQ(1.0 / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
@@ skipping 11 matching lines @@
   CheckNonResolutionDefaults(result);
   EXPECT_EQ(1.0 / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kSmallHeight,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxHeight) {
   constraint_factory_.Reset();
-  const int kHeight = 1000;
-  constraint_factory_.basic().height.setMax(kHeight);
+  const int kMaxHeight = 100;
+  constraint_factory_.basic().height.setMax(kMaxHeight);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
-  // kHeight is greater that the default, so expect the default.
-  EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
-  EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
+  // kSmallHeight is less that the default, so expect kSmallHeight.

[hbos_chromium, 2017/04/07 13:16:29]

nit: comment variable name and variable name don't match.

[Guido Urdaneta, 2017/04/07 15:05:19]

Done.

+  EXPECT_EQ(kMaxHeight, result.Height());
+  EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
+            result.Width());
   CheckNonResolutionDefaults(result);
-  EXPECT_EQ(1.0 / kHeight, result.track_adapter_settings().min_aspect_ratio);
+  EXPECT_EQ(1.0 / kMaxHeight, result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(kMaxScreenCastDimension,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
-
-  const int kSmallHeight = 100;
-  constraint_factory_.basic().height.setMax(kSmallHeight);
-  result = SelectSettings();
-  EXPECT_TRUE(result.HasValue());
-  // kSmallHeight is less that the default, so expect kSmallHeight.
-  EXPECT_EQ(kSmallHeight, result.Height());
-  EXPECT_EQ(std::round(kSmallHeight * kDefaultScreenCastAspectRatio),
-            result.Width());
-  CheckNonResolutionDefaults(result);
-  EXPECT_EQ(1.0 / kSmallHeight,
-            result.track_adapter_settings().min_aspect_ratio);
-  EXPECT_EQ(kMaxScreenCastDimension,
-            result.track_adapter_settings().max_aspect_ratio);
-  CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryHeightRange) {
   constraint_factory_.Reset();
   {
     const int kMinHeight = 300;
-    const int kMaxHeight = 1000;
-    constraint_factory_.basic().height.setMin(kMinHeight);
-    constraint_factory_.basic().height.setMax(kMaxHeight);
-    auto result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    // The range includes the default, so expect the default.
-    EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
-    EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(1.0 / kMaxHeight,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-  }
-
-  {
-    const int kMinHeight = 900;
-    const int kMaxHeight = 1000;
-    constraint_factory_.basic().height.setMin(kMinHeight);
-    constraint_factory_.basic().height.setMax(kMaxHeight);
-    auto result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    // The whole range is greater than the default, so expect the range minimum.
-    EXPECT_EQ(kMinHeight, result.Height());
-    EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio),
-              result.Width());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(1.0 / kMaxHeight,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-  }
-
-  {
-    const int kMinHeight = 300;
     const int kMaxHeight = 400;

[hbos_chromium, 2017/04/07 13:16:29]

I think you shouldn't remove these test cases to make sure that max and default
behaves the way we expect it to behave, as opposed to pruning away the test due
to the knowledge of the algorithm behaving this way.

Add a comment saying we expect the max because the max should overwrite the
default.

Do the same for other tests you've removed even though the expected result will
be default overridden by max.

[Guido Urdaneta, 2017/04/07 15:05:19]

Done.

     constraint_factory_.basic().height.setMin(kMinHeight);
     constraint_factory_.basic().height.setMax(kMaxHeight);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // The whole range is less than the default, so expect the range maximum.
     EXPECT_EQ(kMaxHeight, result.Height());
     EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
               result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(1.0 / kMaxHeight,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealHeight) {
   // Unconstrained.
   {
     constraint_factory_.Reset();
     const int kIdealHeight = 1000;
     constraint_factory_.basic().height.setIdeal(kIdealHeight);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kIdealHeight, result.Height());
     // When ideal height is given, the algorithm returns a width that is closest
-    // to height * kDefaultAspectRatio.
+    // to height * kDefaultScreenCastAspectRatio.
     EXPECT_EQ(std::round(kIdealHeight * kDefaultScreenCastAspectRatio),
               result.Width());
     CheckNonResolutionDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // Ideal greater than maximum.
   {
     constraint_factory_.Reset();
     const int kIdealHeight = 1000;
     const int kMaxHeight = 800;
     constraint_factory_.basic().height.setIdeal(kIdealHeight);
     constraint_factory_.basic().height.setMax(kMaxHeight);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // Ideal height is greater than the maximum, expect maximum.
     EXPECT_EQ(kMaxHeight, result.Height());
-    // Expect closest to kMaxHeight * kDefaultAspectRatio.
+    // Expect closest to kMaxHeight * kDefaultScreenCastAspectRatio.
     EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
               result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(1.0 / kMaxHeight,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(kMaxScreenCastDimension,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal less than minimum.
   {
     constraint_factory_.Reset();
     const int kIdealHeight = 1000;
     const int kMinHeight = 1200;
     constraint_factory_.basic().height.setIdeal(kIdealHeight);
     constraint_factory_.basic().height.setMin(kMinHeight);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // Ideal height is less than the minimum, expect minimum.
     EXPECT_EQ(kMinHeight, result.Height());
-    // Expect closest to kMinHeight * kDefaultAspectRatio.
+    // Expect closest to kMinHeight * kDefaultScreenCastAspectRatio.
     EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio),
               result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(1.0 / kMaxScreenCastDimension,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal intersects a box.
   {
     constraint_factory_.Reset();
     constraint_factory_.basic().height.setMin(500);
     constraint_factory_.basic().height.setMax(1000);
     constraint_factory_.basic().width.setMin(100);
     constraint_factory_.basic().width.setMax(500);
     const int kIdealHeight = 750;
     constraint_factory_.basic().height.setIdeal(kIdealHeight);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // Ideal height is included in the bounding box.
     EXPECT_EQ(kIdealHeight, result.Height());
-    // Expect width closest to kIdealHeight * kDefaultAspectRatio, which is
-    // outside the box. Closest is max width.
-    EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width());
+    double default_aspect_ratio =
+        static_cast<double>(constraint_factory_.basic().width.max()) /
+        constraint_factory_.basic().height.max();
+    // Expect width closest to kIdealHeight * default aspect ratio.
+    EXPECT_EQ(std::round(kIdealHeight * default_aspect_ratio), result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(100.0 / 1000.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().width.setMin(1200);
-    constraint_factory_.basic().width.setMax(2000);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kIdealHeight, result.Height());
-    // kIdealHeight * kDefaultAspectRatio is outside the box. Closest is
-    // min width.
-    EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(1200.0 / 1000.0,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(2000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().width.setMin(100);
-    constraint_factory_.basic().width.setMax(500);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kIdealHeight, result.Height());
-    // kIdealHeight * kDefaultAspectRatio is outside the box. Closest is
-    // max width.
-    EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(100.0 / 1000.0, result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal outside the box, closest to the side coinciding with max height.
   {
     const int kMaxHeight = 1000;
     constraint_factory_.Reset();
     constraint_factory_.basic().height.setMin(500);
     constraint_factory_.basic().height.setMax(kMaxHeight);
     constraint_factory_.basic().width.setMin(100);
     constraint_factory_.basic().width.setMax(500);
     constraint_factory_.basic().height.setIdeal(1200);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kMaxHeight, result.Height());
-    // Expect width closest to kMaxHeight * kDefaultAspectRatio, which is
+    // Expect width closest to kMaxHeight * default aspect ratio, which is
     // outside the box. Closest it max width.
     EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(100.0 / kMaxHeight,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().width.setMin(1500);
-    constraint_factory_.basic().width.setMax(2000);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kMaxHeight, result.Height());
-    // kMaxHeight * kDefaultAspectRatio is outside the box. Closest is min
-    // width.
-    EXPECT_EQ(constraint_factory_.basic().width.min(), result.Width());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(1500.0 / kMaxHeight,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(2000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().width.setMin(100);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kMaxHeight, result.Height());
-    // kMaxHeight * kDefaultAspectRatio is within the width limits.
-    EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
-              result.Width());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(100.0 / kMaxHeight,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(2000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal outside the constrained set, closest to a single point.
   {
     constraint_factory_.Reset();
     constraint_factory_.basic().height.setMin(500);
     constraint_factory_.basic().height.setMax(1000);
     constraint_factory_.basic().width.setMin(500);
     constraint_factory_.basic().width.setMax(1000);
     constraint_factory_.basic().aspectRatio.setMin(1.0);
@@ skipping 22 matching lines @@
   CheckNonResolutionDefaults(result);
   EXPECT_EQ(static_cast<double>(kWidth) / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(static_cast<double>(kWidth) / kMinScreenCastDimension,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinWidth) {
   constraint_factory_.Reset();
-  const int kWidth = 1000;
+  const int kWidth = 3000;
   constraint_factory_.basic().width.setMin(kWidth);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // kWidth is greater that the default, so expect kWidth.
   EXPECT_EQ(kWidth, result.Width());
   EXPECT_EQ(std::round(kWidth / kDefaultScreenCastAspectRatio),
             result.Height());
   CheckNonResolutionDefaults(result);
   EXPECT_EQ(static_cast<double>(kWidth) / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
@@ skipping 13 matching lines @@
   EXPECT_EQ(static_cast<double>(kSmallWidth) / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(
       static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
       result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxWidth) {
   constraint_factory_.Reset();
-  const int kWidth = 1000;
-  constraint_factory_.basic().width.setMax(kWidth);
+  const int kMaxWidth = 100;
+  constraint_factory_.basic().width.setMax(kMaxWidth);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
-  // kWidth is greater that the default, so expect the default.
-  EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
-  EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
-  CheckNonResolutionDefaults(result);
-  EXPECT_EQ(1.0 / kMaxScreenCastDimension,
-            result.track_adapter_settings().min_aspect_ratio);
-  EXPECT_EQ(static_cast<double>(kWidth) / kMinScreenCastDimension,
-            result.track_adapter_settings().max_aspect_ratio);
-  CheckTrackAdapterSettingsEqualsFormat(result);
-
-  const int kSmallWidth = 100;
-  constraint_factory_.basic().width.setMax(kSmallWidth);
-  result = SelectSettings();
-  EXPECT_TRUE(result.HasValue());
   // kSmallWidth is less that the default, so expect kSmallWidth.
-  EXPECT_EQ(kSmallWidth, result.Width());
-  EXPECT_EQ(std::round(kSmallWidth / kDefaultScreenCastAspectRatio),
+  EXPECT_EQ(kMaxWidth, result.Width());
+  EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
             result.Height());
   CheckNonResolutionDefaults(result);
   EXPECT_EQ(1.0 / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
-  EXPECT_EQ(static_cast<double>(kSmallWidth) / kMinScreenCastDimension,
+  EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryWidthRange) {
   constraint_factory_.Reset();
-  {
-    const int kMinWidth = 300;
-    const int kMaxWidth = 1000;
-    constraint_factory_.basic().width.setMin(kMinWidth);
-    constraint_factory_.basic().width.setMax(kMaxWidth);
-    auto result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    // The range includes the default, so expect the default.
-    EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
-    EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-  }
-
-  {
-    const int kMinWidth = 900;
-    const int kMaxWidth = 1000;
-    constraint_factory_.basic().width.setMin(kMinWidth);
-    constraint_factory_.basic().width.setMax(kMaxWidth);
-    auto result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    // The whole range is greater than the default, so expect the range minimum.
-    EXPECT_EQ(kMinWidth, result.Width());
-    EXPECT_EQ(std::round(kMinWidth / kDefaultScreenCastAspectRatio),
-              result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-  }
-
-  {
-    const int kMinWidth = 300;
-    const int kMaxWidth = 400;
-    constraint_factory_.basic().width.setMin(kMinWidth);
-    constraint_factory_.basic().width.setMax(kMaxWidth);
-    auto result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    // The whole range is less than the default, so expect the range maximum.
-    EXPECT_EQ(kMaxWidth, result.Width());
-    EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
-              result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
-              result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-  }
+  const int kMinWidth = 300;
+  const int kMaxWidth = 400;
+  constraint_factory_.basic().width.setMin(kMinWidth);
+  constraint_factory_.basic().width.setMax(kMaxWidth);
+  auto result = SelectSettings();
+  EXPECT_TRUE(result.HasValue());
+  // The whole range is less than the default, so expect the range maximum.
+  EXPECT_EQ(kMaxWidth, result.Width());
+  EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
+            result.Height());
+  CheckNonResolutionDefaults(result);
+  EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
+            result.track_adapter_settings().min_aspect_ratio);
+  EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
+            result.track_adapter_settings().max_aspect_ratio);
+  CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealWidth) {
   // Unconstrained
   {
     constraint_factory_.Reset();
     const int kIdealWidth = 1000;
     constraint_factory_.basic().width.setIdeal(kIdealWidth);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kIdealWidth, result.Width());
     // When ideal width is given, the algorithm returns a height that is closest
-    // to width / kDefaultAspectRatio.
+    // to width / kDefaultScreenCastAspectRatio.
     EXPECT_EQ(std::round(kIdealWidth / kDefaultScreenCastAspectRatio),
               result.Height());
     CheckNonResolutionDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // Ideal greater than maximum.
   {
     constraint_factory_.Reset();
     const int kIdealWidth = 1000;
     const int kMaxWidth = 800;
     constraint_factory_.basic().width.setIdeal(kIdealWidth);
     constraint_factory_.basic().width.setMax(kMaxWidth);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kMaxWidth, result.Width());
-    // Expect closest to kMaxWidth / kDefaultAspectRatio.
+    // Expect closest to kMaxWidth / kDefaultScreenCastAspectRatio.
     EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
               result.Height());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(1.0 / kMaxScreenCastDimension,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal less than minimum.
   {
     constraint_factory_.Reset();
     const int kIdealWidth = 1000;
     const int kMinWidth = 1200;
     constraint_factory_.basic().width.setIdeal(kIdealWidth);
     constraint_factory_.basic().width.setMin(kMinWidth);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kMinWidth, result.Width());
-    // Expect closest to kMinWidth / kDefaultAspectRatio.
+    // Expect closest to kMinWidth / kDefaultScreenCastAspectRatio.
     EXPECT_EQ(std::round(kMinWidth / kDefaultScreenCastAspectRatio),
               result.Height());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(
         static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
         result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal intersects a box.
   {
     constraint_factory_.Reset();
     constraint_factory_.basic().width.setMin(500);
     constraint_factory_.basic().width.setMax(1000);
     constraint_factory_.basic().height.setMin(100);
     constraint_factory_.basic().height.setMax(500);
     const int kIdealWidth = 750;
     constraint_factory_.basic().width.setIdeal(kIdealWidth);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // Ideal width is included in the bounding box.
     EXPECT_EQ(kIdealWidth, result.Width());
-    // Expect height closest to kIdealWidth / kDefaultAspectRatio, which is
-    // outside the box. Closest is max height.
-    EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height());
+    // Expect height closest to kIdealWidth / default aspect ratio.
+    double default_aspect_ratio =
+        static_cast<double>(constraint_factory_.basic().width.max()) /
+        constraint_factory_.basic().height.max();
+    EXPECT_EQ(std::round(kIdealWidth / default_aspect_ratio), result.Height());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(1000.0 / 100.0, result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().height.setMin(1200);
-    constraint_factory_.basic().height.setMax(2000);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kIdealWidth, result.Width());
-    // kIdealWidth / kDefaultAspectRatio outside the box. Closest is
-    // min height.
-    EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(500.0 / 2000.0, result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(1000.0 / 1200.0,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().height.setMin(100);
-    constraint_factory_.basic().height.setMax(500);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kIdealWidth, result.Width());
-    // kIdealWidth / kDefaultAspectRatio is outside the box. Closest is max
-    // height.
-    EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(1000.0 / 100.0, result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal outside the box, closest to the side coinciding with max width.
   {
     const int kMaxWidth = 1000;
     constraint_factory_.Reset();
     constraint_factory_.basic().width.setMin(500);
     constraint_factory_.basic().width.setMax(kMaxWidth);
     constraint_factory_.basic().height.setMin(100);
     constraint_factory_.basic().height.setMax(500);
     constraint_factory_.basic().width.setIdeal(1200);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kMaxWidth, result.Width());
-    // kMaxWidth / kDefaultAspectRatio is outside the box. Closest is max
-    // height.
+    // kMaxWidth / kDefaultScreenCastAspectRatio is outside the box. Closest is
+    // max height.
     EXPECT_EQ(constraint_factory_.basic().height.max(), result.Height());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(500.0 / 500.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(static_cast<double>(kMaxWidth) / 100.0,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().height.setMin(1500);
-    constraint_factory_.basic().height.setMax(2000);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kMaxWidth, result.Width());
-    // kMaxWidth / kDefaultAspectRatio is outside the box. Closest is
-    // min height.
-    EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(500.0 / 2000.0, result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxWidth) / 1500.0,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
-
-    constraint_factory_.basic().height.setMin(100);
-    result = SelectSettings();
-    EXPECT_TRUE(result.HasValue());
-    EXPECT_EQ(kMaxWidth, result.Width());
-    // kMaxWidth / kDefaultAspectRatio is within the height limits.
-    EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
-              result.Height());
-    CheckNonResolutionDefaults(result);
-    EXPECT_EQ(500.0 / 2000.0, result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(static_cast<double>(kMaxWidth) / 100.0,
-              result.track_adapter_settings().max_aspect_ratio);
-    CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal outside the constrained set, closest to a single point.
   {
     constraint_factory_.Reset();
     constraint_factory_.basic().width.setMin(100);
     constraint_factory_.basic().width.setMax(500);
     constraint_factory_.basic().height.setMin(100);
     constraint_factory_.basic().height.setMax(500);
     constraint_factory_.basic().aspectRatio.setMax(1.0);
@@ skipping 172 matching lines @@
 
   // Ideal greater than maximum.
   {
     constraint_factory_.Reset();
     const double kIdealAspectRatio = 2.0;
     const double kMaxAspectRatio = 1.5;
     constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
     constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
-    // Ideal height is greater than the maximum, expect maximum.
-    EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
-    EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMaxAspectRatio),
-              result.Width());
+    // Ideal aspect ratio is greater than the maximum, expect maximum.
+    EXPECT_EQ(std::round(kDefaultScreenCastWidth / kMaxAspectRatio),
+              result.Height());
+    EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(
         static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension,
         result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(kMaxAspectRatio,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal less than minimum.
   {
     constraint_factory_.Reset();
     const double kIdealAspectRatio = 1.0;
     const double kMinAspectRatio = 1.5;
     constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
     constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
-    // Ideal height is greater than the maximum, expect maximum.
-    EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
-    EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMinAspectRatio),
-              result.Width());
+    // Ideal aspect ratio is less than the maximum, expect minimum.
+    EXPECT_EQ(std::round(kDefaultScreenCastWidth / kMinAspectRatio),
+              result.Height());
+    EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(kMinAspectRatio,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(
         static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
         result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal intersects a box.
@@ skipping 18 matching lines @@
     EXPECT_EQ(100.0 / 500.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(500.0 / 100.0, result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
 
     constraint_factory_.basic().height.setMin(1000);
     constraint_factory_.basic().height.setMax(5000);
     constraint_factory_.basic().width.setMin(1000);
     constraint_factory_.basic().width.setMax(5000);
     result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
-    // Ideal aspect-ratio is included in the bounding box, with the value
-    // closest to a standard width or height and largest area being the cut with
-    // the minimum height.
-    EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height());
-    EXPECT_EQ(std::round(constraint_factory_.basic().height.min() *
-                         kIdealAspectRatio),
-              result.Width());
+    // Ideal aspect-ratio is included in the bounding box.
+    EXPECT_EQ(
+        std::round(constraint_factory_.basic().width.max() / kIdealAspectRatio),
+        result.Height());
+    EXPECT_EQ(constraint_factory_.basic().width.max(), result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(1000.0 / 5000.0,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(5000.0 / 1000.0,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
 
+    constraint_factory_.Reset();
+    constraint_factory_.basic().aspectRatio.setIdeal(kIdealAspectRatio);
     constraint_factory_.basic().height.setMin(250);
-    constraint_factory_.basic().height.setMax(5000);
     constraint_factory_.basic().width.setMin(250);
-    constraint_factory_.basic().width.setMax(5000);
     result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
-    // Ideal aspect-ratio and default width and height are included in the
-    // bounding box. Preserving default height leads to larger area than
-    // preserving default width.
+    // Ideal aspect-ratio is included in the bounding box. Preserving default
+    // height leads to larger area than preserving default width.
     EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
     EXPECT_EQ(kDefaultScreenCastHeight * kIdealAspectRatio, result.Width());
     CheckNonResolutionDefaults(result);
-    EXPECT_EQ(250.0 / 5000.0, result.track_adapter_settings().min_aspect_ratio);
-    EXPECT_EQ(5000.0 / 250.0, result.track_adapter_settings().max_aspect_ratio);
+    EXPECT_EQ(250.0 / kMaxScreenCastDimension,
+              result.track_adapter_settings().min_aspect_ratio);
+    EXPECT_EQ(kMaxScreenCastDimension / 250.0,
+              result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 
   // Ideal outside the constrained area, closest to min or max aspect ratio.
   {
     const double kMinAspectRatio = 0.5;
     const double kMaxAspectRatio = 2.0;
     constraint_factory_.Reset();
     constraint_factory_.basic().height.setMin(100);
     constraint_factory_.basic().height.setMax(500);
@@ skipping 26 matching lines @@
         result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(kMinAspectRatio,
               result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(kMaxAspectRatio,
               result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
 
     // Use a box that is bigger and further from the origin to force closeness
     // to a different default dimension.
-    constraint_factory_.basic().height.setMin(1000);
-    constraint_factory_.basic().height.setMax(5000);
-    constraint_factory_.basic().width.setMin(1000);
-    constraint_factory_.basic().width.setMax(5000);
+    constraint_factory_.Reset();
+    constraint_factory_.basic().aspectRatio.setMin(kMinAspectRatio);
+    constraint_factory_.basic().aspectRatio.setMax(kMaxAspectRatio);
+    constraint_factory_.basic().height.setMin(3000);
+    constraint_factory_.basic().width.setMin(3000);
     constraint_factory_.basic().aspectRatio.setIdeal(3.0);
     result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // Ideal is closest to kMaxAspectRatio.
     EXPECT_EQ(constraint_factory_.basic().height.min(), result.Height());
     EXPECT_EQ(
         std::round(constraint_factory_.basic().height.min() * kMaxAspectRatio),
         result.Width());
     CheckNonResolutionDefaults(result);
     EXPECT_EQ(kMinAspectRatio,
@@ skipping 380 matching lines @@
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedNoiseReduction) {
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
   advanced1.width.setMin(640);
   advanced1.height.setMin(480);
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
-  advanced2.width.setMin(1920);
-  advanced2.height.setMin(1080);
+  const int kMinWidth = 4000;
+  const int kMinHeight = 2000;
+  advanced2.width.setMin(kMinWidth);
+  advanced2.height.setMin(kMinHeight);
   advanced2.googNoiseReduction.setExact(false);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
-  EXPECT_EQ(1920, result.Width());
+  EXPECT_EQ(kMinWidth, result.Width());
   // Preserves default aspect ratio.
   EXPECT_EQ(static_cast<int>(
                 std::round(result.Width() / kDefaultScreenCastAspectRatio)),
             result.Height());
   EXPECT_TRUE(result.noise_reduction() && !*result.noise_reduction());
-  EXPECT_EQ(1920.0 / static_cast<double>(kMaxScreenCastDimension),
+  EXPECT_EQ(kMinWidth / static_cast<double>(kMaxScreenCastDimension),
             result.track_adapter_settings().min_aspect_ratio);
-  EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / 1080.0,
+  EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 // The "AdvancedContradictory" tests check that advanced constraint sets that
 // contradict previous constraint sets are ignored.
 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
        AdvancedContradictoryNoiseReduction) {
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
@@ skipping 57 matching lines @@
   EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
   EXPECT_EQ(kMinScreenCastDimension / 480.0,
             result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(640.0 / kMinScreenCastDimension,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
        AdvancedContradictoryMinMaxResolutionFrameRate) {
+  const int kMinHeight = 2600;
+  const int kMinWidth = 2800;
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
-  advanced1.width.setMin(800);
-  advanced1.height.setMin(600);
+  advanced1.width.setMin(kMinWidth);
+  advanced1.height.setMin(kMinHeight);
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
   advanced2.width.setMax(640);
   advanced2.height.setMax(480);
   advanced2.frameRate.setExact(60.0);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
-  EXPECT_EQ(800, result.Width());
-  EXPECT_EQ(600, result.Height());
+  EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio),
+            result.Width());
+  EXPECT_EQ(kMinHeight, result.Height());
   EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
-  EXPECT_EQ(800.0 / kMaxScreenCastDimension,
+  EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
             result.track_adapter_settings().min_aspect_ratio);
-  EXPECT_EQ(kMaxScreenCastDimension / 600.0,
+  EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
        AdvancedContradictoryExactAspectRatio) {
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
   advanced1.aspectRatio.setExact(10.0);
@@ skipping 58 matching lines @@
   advanced2.frameRate.setMax(35.0);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   EXPECT_LE(40.0, result.FrameRate());
   CheckNonFrameRateDefaults(result);
   CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
        AdvancedContradictoryWidthFrameRate) {
+  const int kMaxWidth = 1920;
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
-  advanced1.width.setMax(1920);
+  advanced1.width.setMax(kMaxWidth);
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
   advanced2.width.setMin(2000);
   advanced2.frameRate.setExact(10.0);
   blink::WebMediaTrackConstraintSet& advanced3 =
       constraint_factory_.AddAdvanced();
   advanced3.frameRate.setExact(90.0);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
-  EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
-  EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
+  EXPECT_EQ(kMaxWidth, result.Width());
+  EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
+            result.Height());
   EXPECT_EQ(90.0, result.FrameRate());
   EXPECT_EQ(
       static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension,
       result.track_adapter_settings().min_aspect_ratio);
-  EXPECT_EQ(1920.0 / kMinScreenCastDimension,
+  EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
             result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
        AdvancedContradictoryHeightFrameRate) {
+  const int kMaxHeight = 2000;
   constraint_factory_.Reset();
   blink::WebMediaTrackConstraintSet& advanced1 =
       constraint_factory_.AddAdvanced();
-  advanced1.height.setMax(1080);
+  advanced1.height.setMax(kMaxHeight);
   blink::WebMediaTrackConstraintSet& advanced2 =
       constraint_factory_.AddAdvanced();
-  advanced2.height.setMin(1500);
+  advanced2.height.setMin(4500);
   advanced2.frameRate.setExact(10.0);
   blink::WebMediaTrackConstraintSet& advanced3 =
       constraint_factory_.AddAdvanced();
   advanced3.frameRate.setExact(60.0);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
-  EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
-  EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
+  EXPECT_EQ(kMaxHeight * kDefaultScreenCastAspectRatio, result.Width());
+  // Height defaults to explicitly given max constraint.
+  EXPECT_EQ(kMaxHeight, result.Height());
   EXPECT_EQ(60.0, result.FrameRate());
-  EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) / 1080.0,
+  EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) / kMaxHeight,
             result.track_adapter_settings().min_aspect_ratio);
   EXPECT_EQ(
       static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
       result.track_adapter_settings().max_aspect_ratio);
   CheckTrackAdapterSettingsEqualsFormat(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedDeviceID) {
   const std::string kDeviceID1 = "fake_device_1";
   const std::string kDeviceID2 = "fake_device_2";
@@ skipping 162 matching lines @@
     // Exact aspect ratio prevents the resolution from being adjusted.
     EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION,
               result.ResolutionChangePolicy());
     EXPECT_EQ(1.32, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(1.32, result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 }
 
 }  // namespace content