Update constraints processing 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/common/media/media_stream_options.h"
 #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 {
 
 void CheckNonResolutionDefaults(const VideoCaptureSettings& result) {
   EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
+  EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+  EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
   EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
   EXPECT_EQ(std::string(), result.device_id());
-  EXPECT_EQ(0.0, result.min_frame_rate());
+  EXPECT_FALSE(result.min_frame_rate().has_value());
 }
 
 void CheckNonFrameRateDefaults(const VideoCaptureSettings& result) {
   EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
   EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
   EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
   EXPECT_EQ(std::string(), result.device_id());
 }
 
 void CheckTrackAdapterSettingsEqualsFormat(const VideoCaptureSettings& result) {
@@ skipping 1210 matching lines @@
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactFrameRate) {
   constraint_factory_.Reset();
   const double kFrameRate = 45.0;
   constraint_factory_.basic().frame_rate.SetExact(kFrameRate);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   EXPECT_EQ(kFrameRate, result.FrameRate());
+  EXPECT_EQ(kFrameRate, result.min_frame_rate());
+  EXPECT_EQ(kFrameRate, result.max_frame_rate());
   CheckNonFrameRateDefaults(result);
   CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinFrameRate) {
   constraint_factory_.Reset();
   const double kFrameRate = 45.0;
   constraint_factory_.basic().frame_rate.SetMin(kFrameRate);
   auto result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // kFrameRate is greater that the default, so expect kFrameRate.
   EXPECT_EQ(kFrameRate, result.FrameRate());
+  EXPECT_EQ(kFrameRate, result.min_frame_rate());
+  EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
   CheckNonFrameRateDefaults(result);
   CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
 
   const double kSmallFrameRate = 5.0;
   constraint_factory_.basic().frame_rate.SetMin(kSmallFrameRate);
   result = SelectSettings();
   EXPECT_TRUE(result.HasValue());
   // kFrameRate is greater that the default, so expect kFrameRate.
   EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
+  EXPECT_EQ(kSmallFrameRate, result.min_frame_rate());
+  EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
   CheckNonFrameRateDefaults(result);
   CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxFrameRate) {
   constraint_factory_.Reset();
   // kMaxFrameRate greater than default
   {
     const double kMaxFrameRate = 45.0;
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // If max frame rate is provided, it is used as default.
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // kMaxFrameRate less than default
   {
     const double kMaxFrameRate = 5.0;
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // If max frame rate is provided, it is used as default.
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // kMaxFrameRate greater than the maximum allowed
   {
     const double kMaxFrameRate = kMaxScreenCastFrameRate + 0.1;
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // Expect the default, since the given maximum is invalid.
     EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+    EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // kMaxFrameRate equal to the maximum allowed
   {
     const double kMaxFrameRate = kMaxScreenCastFrameRate;
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // If max frame rate is provided, it is used as default.
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeFrameRate) {
   constraint_factory_.Reset();
   {
     const double kMinFrameRate = 15.0;
     const double kMaxFrameRate = 45.0;
-    constraint_factory_.basic().frame_rate.SetMax(kMinFrameRate);
+    constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // If max frame rate is provided, it is used as default.
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   {
     const double kMinFrameRate = 45.0;
     const double kMaxFrameRate = 55.0;
-    constraint_factory_.basic().frame_rate.SetMax(kMinFrameRate);
+    constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // If max frame rate is provided, it is used as default.
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   {
     const double kMinFrameRate = 10.0;
     const double kMaxFrameRate = 15.0;
-    constraint_factory_.basic().frame_rate.SetMax(kMinFrameRate);
+    constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     // If max frame rate is provided, it is used as default.
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 }
 
 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealFrameRate) {
   // Unconstrained.
   {
     constraint_factory_.Reset();
     const double kIdealFrameRate = 45.0;
     constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kIdealFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+    EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // Ideal greater than maximum.
   {
     constraint_factory_.Reset();
     const double kIdealFrameRate = 45.0;
     const double kMaxFrameRate = 30.0;
     constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kMaxFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // Ideal less than minimum.
   {
     constraint_factory_.Reset();
     const double kIdealFrameRate = 45.0;
     const double kMinFrameRate = 50.0;
     constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
     constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kMinFrameRate, result.FrameRate());
+    EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 
   // Ideal within range.
   {
     constraint_factory_.Reset();
     const double kIdealFrameRate = 45.0;
     const double kMinFrameRate = 35.0;
     const double kMaxFrameRate = 50.0;
     constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
     constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
     constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
     auto result = SelectSettings();
     EXPECT_TRUE(result.HasValue());
     EXPECT_EQ(kIdealFrameRate, result.FrameRate());
+    EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
+    EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
     CheckNonFrameRateDefaults(result);
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
 }
 
 // The "Advanced" tests check selection criteria involving advanced constraint
 // sets.
 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
        AdvancedMinMaxResolutionFrameRate) {
   constraint_factory_.Reset();
@@ skipping 627 matching lines @@
     // Only specifying a maximum resolution allows resolution adjustment.
     EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
               result.ResolutionChangePolicy());
     EXPECT_EQ(1.0 / 4000, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(4000.0, result.track_adapter_settings().max_aspect_ratio);
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
 }
 
 }  // namespace content