Revert of Tab/Desktop Capture: Use requests instead of timer-based refreshing.

media/capture/content/smooth_event_sampler_unittest.cc

 // Copyright (c) 2015 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 "media/capture/content/smooth_event_sampler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
@@ skipping 10 matching lines @@
   return sampler->ShouldSample();
 }
 
 void SteadyStateSampleAndAdvance(base::TimeDelta vsync,
                                  SmoothEventSampler* sampler,
                                  base::TimeTicks* t) {
   ASSERT_TRUE(AddEventAndConsiderSampling(sampler, *t));
   ASSERT_TRUE(sampler->HasUnrecordedEvent());
   sampler->RecordSample();
   ASSERT_FALSE(sampler->HasUnrecordedEvent());
+  ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
   *t += vsync;
+  ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
 }
 
 void SteadyStateNoSampleAndAdvance(base::TimeDelta vsync,
                                    SmoothEventSampler* sampler,
                                    base::TimeTicks* t) {
   ASSERT_FALSE(AddEventAndConsiderSampling(sampler, *t));
   ASSERT_TRUE(sampler->HasUnrecordedEvent());
+  ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
   *t += vsync;
+  ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
 }
 
 base::TimeTicks InitialTestTimeTicks() {
   return base::TimeTicks() + base::TimeDelta::FromSeconds(1);
 }
 
+void TestRedundantCaptureStrategy(base::TimeDelta capture_period,
+                                  int redundant_capture_goal,
+                                  SmoothEventSampler* sampler,
+                                  base::TimeTicks* t) {
+  // Before any events have been considered, we're overdue for sampling.
+  ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t));
+
+  // Consider the first event.  We want to sample that.
+  ASSERT_FALSE(sampler->HasUnrecordedEvent());
+  ASSERT_TRUE(AddEventAndConsiderSampling(sampler, *t));
+  ASSERT_TRUE(sampler->HasUnrecordedEvent());
+  sampler->RecordSample();
+  ASSERT_FALSE(sampler->HasUnrecordedEvent());
+
+  // After more than 250 ms has passed without considering an event, we should
+  // repeatedly be overdue for sampling.  However, once the redundant capture
+  // goal is achieved, we should no longer be overdue for sampling.
+  *t += base::TimeDelta::FromMilliseconds(250);
+  for (int i = 0; i < redundant_capture_goal; i++) {
+    SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
+    ASSERT_FALSE(sampler->HasUnrecordedEvent());
+    ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t))
+        << "Should sample until redundant capture goal is hit";
+    sampler->RecordSample();
+    *t += capture_period;  // Timer fires once every capture period.
+  }
+  ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t))
+      << "Should not be overdue once redundant capture goal achieved.";
+}
 
 }  // namespace
 
 // 60Hz sampled at 30Hz should produce 30Hz.  In addition, this test contains
 // much more comprehensive before/after/edge-case scenarios than the others.
 TEST(SmoothEventSamplerTest, Sample60HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
+  const int redundant_capture_goal = 200;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60;
 
-  SmoothEventSampler sampler(capture_period);
+  SmoothEventSampler sampler(capture_period, redundant_capture_goal);
   base::TimeTicks t = InitialTestTimeTicks();
 
+  TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler,
+                               &t);
+
   // Steady state, we should capture every other vsync, indefinitely.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
   // case we are adding events but not sampling them.
   for (int i = 0; i < 20; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
+    ASSERT_EQ(i >= 14, sampler.IsOverdueForSamplingAt(t));
     ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
     ASSERT_TRUE(sampler.HasUnrecordedEvent());
     t += vsync;
   }
 
   // Now suppose we can sample again. We should be back in the steady state,
   // but at a different phase.
+  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
 // 50Hz sampled at 30Hz should produce a sequence where some frames are skipped.
 TEST(SmoothEventSamplerTest, Sample50HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
+  const int redundant_capture_goal = 2;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 50;
 
-  SmoothEventSampler sampler(capture_period);
+  SmoothEventSampler sampler(capture_period, redundant_capture_goal);
   base::TimeTicks t = InitialTestTimeTicks();
 
+  TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler,
+                               &t);
+
   // Steady state, we should capture 1st, 2nd and 4th frames out of every five
   // frames, indefinitely.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
   // case we are adding events but not sampling them.
   for (int i = 0; i < 20; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
+    ASSERT_EQ(i >= 11, sampler.IsOverdueForSamplingAt(t));
     ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
     t += vsync;
   }
 
   // Now suppose we can sample again. We should be back in the steady state
   // again.
+  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
 // 75Hz sampled at 30Hz should produce a sequence where some frames are skipped.
 TEST(SmoothEventSamplerTest, Sample75HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
+  const int redundant_capture_goal = 32;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 75;
 
-  SmoothEventSampler sampler(capture_period);
+  SmoothEventSampler sampler(capture_period, redundant_capture_goal);
   base::TimeTicks t = InitialTestTimeTicks();
 
+  TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler,
+                               &t);
+
   // Steady state, we should capture 1st and 3rd frames out of every five
   // frames, indefinitely.
   SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
   // case we are adding events but not sampling them.
   for (int i = 0; i < 20; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
+    ASSERT_EQ(i >= 16, sampler.IsOverdueForSamplingAt(t));
     ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
     t += vsync;
   }
 
   // Now suppose we can sample again. We capture the next frame, and not the one
   // after that, and then we're back in the steady state again.
+  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
   SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
 // 30Hz sampled at 30Hz should produce 30Hz.
 TEST(SmoothEventSamplerTest, Sample30HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
+  const int redundant_capture_goal = 1;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 30;
 
-  SmoothEventSampler sampler(capture_period);
+  SmoothEventSampler sampler(capture_period, redundant_capture_goal);
   base::TimeTicks t = InitialTestTimeTicks();
 
+  TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler,
+                               &t);
+
   // Steady state, we should capture every vsync, indefinitely.
   for (int i = 0; i < 200; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
   // case we are adding events but not sampling them.
   for (int i = 0; i < 10; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
+    ASSERT_EQ(i >= 7, sampler.IsOverdueForSamplingAt(t));
     ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
     t += vsync;
   }
 
   // Now suppose we can sample again. We should be back in the steady state.
+  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
 // 24Hz sampled at 30Hz should produce 24Hz.
 TEST(SmoothEventSamplerTest, Sample24HertzAt30Hertz) {
   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
+  const int redundant_capture_goal = 333;
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 24;
 
-  SmoothEventSampler sampler(capture_period);
+  SmoothEventSampler sampler(capture_period, redundant_capture_goal);
   base::TimeTicks t = InitialTestTimeTicks();
 
+  TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler,
+                               &t);
+
   // Steady state, we should capture every vsync, indefinitely.
   for (int i = 0; i < 200; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
   // case we are adding events but not sampling them.
   for (int i = 0; i < 10; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
+    ASSERT_EQ(i >= 6, sampler.IsOverdueForSamplingAt(t));
     ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
     t += vsync;
   }
 
   // Now suppose we can sample again. We should be back in the steady state.
+  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
 // Tests that changing the minimum capture period during usage results in the
 // desired behavior.
 TEST(SmoothEventSamplerTest, Sample60HertzWithVariedCapturePeriods) {
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60;
   const base::TimeDelta one_to_one_period = vsync;
   const base::TimeDelta two_to_one_period = vsync * 2;
   const base::TimeDelta two_and_three_to_one_period =
       base::TimeDelta::FromSeconds(1) / 24;
+  const int redundant_capture_goal = 1;
 
-  SmoothEventSampler sampler(one_to_one_period);
+  SmoothEventSampler sampler(one_to_one_period, redundant_capture_goal);
   base::TimeTicks t = InitialTestTimeTicks();
 
+  TestRedundantCaptureStrategy(one_to_one_period, redundant_capture_goal,
+                               &sampler, &t);
+
   // With the capture rate at 60 Hz, we should capture every vsync.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 
   // Now change to the capture rate to 30 Hz, and we should capture every other
   // vsync.
   sampler.SetMinCapturePeriod(two_to_one_period);
   for (int i = 0; i < 100; i++) {
@@ skipping 16 matching lines @@
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
   }
 }
 
+TEST(SmoothEventSamplerTest, DoubleDrawAtOneTimeStillDirties) {
+  const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
+  const base::TimeDelta overdue_period = base::TimeDelta::FromSeconds(1);
+
+  SmoothEventSampler sampler(capture_period, 1);
+  base::TimeTicks t = InitialTestTimeTicks();
+
+  ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
+  sampler.RecordSample();
+  ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
+      << "Sampled last event; should not be dirty.";
+  t += overdue_period;
+
+  // Now simulate 2 events with the same clock value.
+  ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t));
+  sampler.RecordSample();
+  ASSERT_FALSE(AddEventAndConsiderSampling(&sampler, t))
+      << "Two events at same time -- expected second not to be sampled.";
+  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t + overdue_period))
+      << "Second event should dirty the capture state.";
+  sampler.RecordSample();
+  ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t + overdue_period));
+}
+
 namespace {
 
 struct DataPoint {
   bool should_capture;
   double increment_ms;
 };
 
 void ReplayCheckingSamplerDecisions(const DataPoint* data_points,
                                     size_t num_data_points,
                                     SmoothEventSampler* sampler) {
@@ skipping 80 matching lines @@
                                           {true, 33.44},
                                           {true, 50.161},
                                           {true, 33.44},
                                           {true, 50.161},
                                           {true, 33.44},
                                           {true, 83.601},
                                           {true, 16.72},
                                           {true, 33.44},
                                           {false, 0}};
 
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3);
   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 }
 
 TEST(SmoothEventSamplerTest, DrawingAt30FpsWith60HzVsyncSampledAt30Hertz) {
   // Actual capturing of timing data: Initial instability as a 30 FPS video was
   // started from a still screen, then followed by steady-state.  Drawing
   // framerate from the video rendering was a bit volatile, but averaged 30 FPS.
   static const DataPoint data_points[] = {{true, 2407.69},
                                           {true, 16.733},
                                           {true, 217.362},
@@ skipping 88 matching lines @@
                                           {false, 16.72},
                                           {true, 66.88},
                                           {true, 16.721},
                                           {true, 50.16},
                                           {true, 33.44},
                                           {true, 16.72},
                                           {true, 33.441},
                                           {true, 33.44},
                                           {true, 33.44}};
 
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3);
   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 }
 
 TEST(SmoothEventSamplerTest, DrawingAt60FpsWith60HzVsyncSampledAt30Hertz) {
   // Actual capturing of timing data: WebGL Acquarium demo
   // (http://webglsamples.googlecode.com/hg/aquarium/aquarium.html) which ran
   // between 55-60 FPS in the steady-state.
   static const DataPoint data_points[] = {{true, 16.72},
                                           {true, 16.72},
                                           {true, 4163.29},
@@ skipping 112 matching lines @@
                                           {true, 50.161},
                                           {false, 0},
                                           {true, 16.72},
                                           {true, 33.44},
                                           {false, 0},
                                           {true, 33.441},
                                           {false, 16.72},
                                           {true, 16.72},
                                           {true, 50.16}};
 
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3);
   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 }
 
 }  // namespace media