Fix Bug: Video with Variable Frame Rate plays at incorrect speed.

media/filters/video_cadence_estimator_unittest.cc

Index: media/filters/video_cadence_estimator_unittest.cc
diff --git a/media/filters/video_cadence_estimator_unittest.cc b/media/filters/video_cadence_estimator_unittest.cc
index a8a4b5c15cc54efff947930f4a14b5f09f40a9a3..e128dc7d6004b9189b6dc6946f893d9cde61edc7 100644
--- a/media/filters/video_cadence_estimator_unittest.cc
+++ b/media/filters/video_cadence_estimator_unittest.cc
@@ -40,10 +40,11 @@ std::vector<int> CreateCadenceFromString(const std::string& cadence) {
   return result;
 }
 
-static void VerifyCadenceVectorWithCustomDrift(
+static void VerifyCadenceVectorWithCustomDeviationAndDrift(
     VideoCadenceEstimator* estimator,
     double frame_hertz,
     double render_hertz,
+    base::TimeDelta deviation,
     base::TimeDelta acceptable_drift,
     const std::string& expected_cadence) {
   SCOPED_TRACE(base::StringPrintf("Checking %.03f fps into %0.03f", frame_hertz,
@@ -54,7 +55,8 @@ static void VerifyCadenceVectorWithCustomDrift(
 
   estimator->Reset();
   const bool cadence_changed = estimator->UpdateCadenceEstimate(
-      Interval(render_hertz), Interval(frame_hertz), acceptable_drift);
+      Interval(render_hertz), Interval(frame_hertz), deviation,
+      acceptable_drift);
   EXPECT_EQ(cadence_changed, estimator->has_cadence());
   EXPECT_EQ(expected_cadence_vector.empty(), !estimator->has_cadence());
 
@@ -72,14 +74,39 @@ static void VerifyCadenceVectorWithCustomDrift(
   }
 }
 
+static void VerifyCadenceVectorWithCustomDrift(
+    VideoCadenceEstimator* estimator,
+    double frame_hertz,
+    double render_hertz,
+    base::TimeDelta acceptable_drift,
+    const std::string& expected_cadence) {
+  VerifyCadenceVectorWithCustomDeviationAndDrift(
+      estimator, frame_hertz, render_hertz, base::TimeDelta(), acceptable_drift,
+      expected_cadence);
+}
+
+static void VerifyCadenceVectorWithCustomDeviation(
+    VideoCadenceEstimator* estimator,
+    double frame_hertz,
+    double render_hertz,
+    base::TimeDelta deviation,
+    const std::string& expected_cadence) {
+  const base::TimeDelta acceptable_drift =
+      std::max(Interval(frame_hertz) / 2, Interval(render_hertz));
+  VerifyCadenceVectorWithCustomDeviationAndDrift(
+      estimator, frame_hertz, render_hertz, deviation, acceptable_drift,
+      expected_cadence);
+}
+
 static void VerifyCadenceVector(VideoCadenceEstimator* estimator,
                                 double frame_hertz,
                                 double render_hertz,
                                 const std::string& expected_cadence) {
   const base::TimeDelta acceptable_drift =
       std::max(Interval(frame_hertz) / 2, Interval(render_hertz));
-  VerifyCadenceVectorWithCustomDrift(estimator, frame_hertz, render_hertz,
-                                     acceptable_drift, expected_cadence);
+  VerifyCadenceVectorWithCustomDeviationAndDrift(
+      estimator, frame_hertz, render_hertz, base::TimeDelta(), acceptable_drift,
+      expected_cadence);
 }
 
 // Spot check common display and frame rate pairs for correctness.
@@ -160,6 +187,22 @@ TEST(VideoCadenceEstimatorTest, CadenceCalculationWithLargeDrift) {
   VerifyCadenceVectorWithCustomDrift(&estimator, 90, 60, drift, "[1]");
 }
 
+// Check the case that the estimator excludes variable FPS case from Cadence.
+TEST(VideoCadenceEstimatorTest, CadenceCalculationWithLargeDeviation) {
+  VideoCadenceEstimator estimator(
+      base::TimeDelta::FromSeconds(kMinimumAcceptableTimeBetweenGlitchesSecs));
+  estimator.set_cadence_hysteresis_threshold_for_testing(base::TimeDelta());
+
+  const base::TimeDelta deviation = base::TimeDelta::FromMilliseconds(30);
+  VerifyCadenceVectorWithCustomDeviation(&estimator, 1, 60, deviation, "[]");
+  VerifyCadenceVectorWithCustomDeviation(&estimator, 30, 60, deviation, "[]");
+  VerifyCadenceVectorWithCustomDeviation(&estimator, 25, 60, deviation, "[]");
+
+  // Test cases for cadence with low refresh rate.
+  VerifyCadenceVectorWithCustomDeviation(&estimator, 60, 12, deviation,
+                                         "[1:0:0:0:0]");
+}
+
 TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableDrift) {
   VideoCadenceEstimator estimator(
       base::TimeDelta::FromSeconds(kMinimumAcceptableTimeBetweenGlitchesSecs));
@@ -169,15 +212,15 @@ TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableDrift) {
   const base::TimeDelta frame_interval = Interval(120);
 
   base::TimeDelta acceptable_drift = frame_interval / 2;
-  EXPECT_FALSE(estimator.UpdateCadenceEstimate(render_interval, frame_interval,
-                                               acceptable_drift));
+  EXPECT_FALSE(estimator.UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_FALSE(estimator.has_cadence());
 
   // Increasing the acceptable drift should be result in more permissive
   // detection of cadence.
   acceptable_drift = render_interval;
-  EXPECT_TRUE(estimator.UpdateCadenceEstimate(render_interval, frame_interval,
-                                              acceptable_drift));
+  EXPECT_TRUE(estimator.UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator.has_cadence());
   EXPECT_EQ("[1:0]", estimator.GetCadenceForTesting());
 }
@@ -191,8 +234,8 @@ TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableGlitchTime) {
   const base::TimeDelta frame_interval = Interval(120);
   const base::TimeDelta acceptable_drift = frame_interval / 2;
 
-  EXPECT_FALSE(estimator->UpdateCadenceEstimate(render_interval, frame_interval,
-                                                acceptable_drift));
+  EXPECT_FALSE(estimator->UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_FALSE(estimator->has_cadence());
 
   // Decreasing the acceptable glitch time should be result in more permissive
@@ -200,8 +243,8 @@ TEST(VideoCadenceEstimatorTest, CadenceVariesWithAcceptableGlitchTime) {
   estimator.reset(new VideoCadenceEstimator(base::TimeDelta::FromSeconds(
       kMinimumAcceptableTimeBetweenGlitchesSecs / 2)));
   estimator->set_cadence_hysteresis_threshold_for_testing(base::TimeDelta());
-  EXPECT_TRUE(estimator->UpdateCadenceEstimate(render_interval, frame_interval,
-                                               acceptable_drift));
+  EXPECT_TRUE(estimator->UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator->has_cadence());
   EXPECT_EQ("[1:0]", estimator->GetCadenceForTesting());
 }
@@ -216,33 +259,36 @@ TEST(VideoCadenceEstimatorTest, CadenceHystersisPreventsOscillation) {
   estimator->set_cadence_hysteresis_threshold_for_testing(render_interval * 2);
 
   // Cadence hysteresis should prevent the cadence from taking effect yet.
-  EXPECT_FALSE(estimator->UpdateCadenceEstimate(render_interval, frame_interval,
-                                                acceptable_drift));
+  EXPECT_FALSE(estimator->UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_FALSE(estimator->has_cadence());
 
   // A second call should exceed cadence hysteresis and take into effect.
-  EXPECT_TRUE(estimator->UpdateCadenceEstimate(render_interval, frame_interval,
-                                               acceptable_drift));
+  EXPECT_TRUE(estimator->UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator->has_cadence());
 
   // One bad interval shouldn't cause cadence to drop
-  EXPECT_FALSE(estimator->UpdateCadenceEstimate(
-      render_interval, frame_interval * 0.75, acceptable_drift));
+  EXPECT_FALSE(
+      estimator->UpdateCadenceEstimate(render_interval, frame_interval * 0.75,
+                                       base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator->has_cadence());
 
   // Resumption of cadence should clear bad interval count.
-  EXPECT_FALSE(estimator->UpdateCadenceEstimate(render_interval, frame_interval,
-                                                acceptable_drift));
+  EXPECT_FALSE(estimator->UpdateCadenceEstimate(
+      render_interval, frame_interval, base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator->has_cadence());
 
   // So one more bad interval shouldn't cause cadence to drop
-  EXPECT_FALSE(estimator->UpdateCadenceEstimate(
-      render_interval, frame_interval * 0.75, acceptable_drift));
+  EXPECT_FALSE(
+      estimator->UpdateCadenceEstimate(render_interval, frame_interval * 0.75,
+                                       base::TimeDelta(), acceptable_drift));
   EXPECT_TRUE(estimator->has_cadence());
 
   // Two bad intervals should.
-  EXPECT_TRUE(estimator->UpdateCadenceEstimate(
-      render_interval, frame_interval * 0.75, acceptable_drift));
+  EXPECT_TRUE(
+      estimator->UpdateCadenceEstimate(render_interval, frame_interval * 0.75,
+                                       base::TimeDelta(), acceptable_drift));
   EXPECT_FALSE(estimator->has_cadence());
 }