Tab capture: do 200 rendundant captures of static content.

content/browser/renderer_host/media/web_contents_video_capture_device_unittest.cc

 // Copyright (c) 2012 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/browser/renderer_host/media/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/debug/debugger.h"
 #include "base/run_loop.h"
 #include "base/time.h"
@@ skipping 705 matching lines @@
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorGREEN));
   source()->SetSolidColor(SK_ColorRED);
   ASSERT_NO_FATAL_FAILURE(consumer()->WaitForNextColor(SK_ColorRED));
 
   device()->Stop();
   device()->DeAllocate();
 }
 
 // 60Hz sampled at 30Hz should produce 30Hz.
 TEST(SmoothEventSamplerTest, Sample60HertzAt30Hertz) {
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 200);
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60;
 
   base::Time t;
   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "First timer event should sample.";
-  sampler.RecordSample();
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "Should always be overdue until first paint.";
+  for (int i = 0; i < 200; i++) {
+    ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
+        << "Should sample until redundant capture goal is hit";
+    sampler.RecordSample();
+  }
+  ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
+      << "Should not be overdue once redundant capture goal achieved.";
 
   // Steady state, we should capture every other vsync, indefinitely.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
     sampler.RecordSample();
     t += vsync;
 
     ASSERT_FALSE(sampler.AddEventAndConsiderSampling(t));
     t += vsync;
@@ skipping 19 matching lines @@
     ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t));
 
     ASSERT_FALSE(sampler.AddEventAndConsiderSampling(t));
     t += vsync;
     ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t));
   }
 }
 
 // 50Hz sampled at 30Hz should produce 25Hz.
 TEST(SmoothEventSamplerTest, Sample50HertzAt30Hertz) {
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 2);
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 50;
 
   base::Time t;
   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "First timer event should sample.";
-  sampler.RecordSample();
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "Should always be overdue until first paint.";
+  for (int i = 0; i < 2; i++) {
+    ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
+        << "Should sample until redundant capture goal is hit";
+    sampler.RecordSample();
+  }
+  ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
+      << "Should not be overdue once redundant capture goal achieved.";
+
+
 
   // Steady state, we should capture every other vsync, indefinitely.
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
     sampler.RecordSample();
     t += vsync;
 
     ASSERT_FALSE(sampler.AddEventAndConsiderSampling(t));
     t += vsync;
@@ skipping 19 matching lines @@
     ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t));
 
     ASSERT_FALSE(sampler.AddEventAndConsiderSampling(t));
     t += vsync;
     ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t));
   }
 }
 
 // 30Hz sampled at 30Hz should produce 30Hz.
 TEST(SmoothEventSamplerTest, Sample30HertzAt30Hertz) {
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 3);
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 30;
 
   base::Time t;
   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "First timer event should sample.";
-  sampler.RecordSample();
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "Should always be overdue until first paint.";
+  for (int i = 0; i < 3; i++) {
+    ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
+        << "Should sample until redundant capture goal is hit";
+    sampler.RecordSample();
+  }
+  ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
+      << "Should not be overdue once redundant capture goal achieved.";
 
   // Steady state, we should capture every vsync, indefinitely.
   for (int i = 0; i < 200; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
     sampler.RecordSample();
     t += vsync;
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
@@ skipping 11 matching lines @@
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
     sampler.RecordSample();
     t += vsync;
     ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t));
   }
 }
 
 // 24Hz sampled at 30Hz should produce 24Hz.
 TEST(SmoothEventSamplerTest, Sample24HertzAt30Hertz) {
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 333);
   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 24;
 
   base::Time t;
   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "First timer event should sample.";
-  sampler.RecordSample();
-  ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
-      << "Should always be overdue until first paint.";
+  for (int i = 0; i < 333; i++) {
+    ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t))
+        << "Should sample until redundant capture goal is hit";
+    sampler.RecordSample();
+  }
+  ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
+      << "Should not be overdue once redundant capture goal achieved.";
 
   // Steady state, we should capture every vsync, indefinitely.
   for (int i = 0; i < 200; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
     sampler.RecordSample();
     t += vsync;
   }
 
   // Now pretend we're limited by backpressure in the pipeline. In this scenario
@@ skipping 10 matching lines @@
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
     sampler.RecordSample();
     t += vsync;
     ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t));
   }
 }
 
 TEST(SmoothEventSamplerTest, DoubleDrawAtOneTimeStillDirties) {
-  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 1);
   const base::TimeDelta overdue_period = base::TimeDelta::FromSeconds(1);
 
   base::Time t;
   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
   ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
   sampler.RecordSample();
   t += overdue_period;
   ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
       << "Sampled last event; should not be dirty.";
 
   // Now simulate 2 events with the same clock value.
   ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
   sampler.RecordSample();
   ASSERT_FALSE(sampler.AddEventAndConsiderSampling(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));
 }
 
 TEST(SmoothEventSamplerTest, FallbackToPollingIfUpdatesUnreliable) {
   const base::TimeDelta timer_interval = base::TimeDelta::FromSeconds(1) / 30;
-  SmoothEventSampler should_not_poll(timer_interval, true);
-  SmoothEventSampler should_poll(timer_interval, false);
+  SmoothEventSampler should_not_poll(timer_interval, true, 1);
+  SmoothEventSampler should_poll(timer_interval, false, 1);
 
   base::Time t;
   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
   ASSERT_TRUE(should_not_poll.AddEventAndConsiderSampling(t));
   ASSERT_TRUE(should_poll.AddEventAndConsiderSampling(t));
   should_not_poll.RecordSample();
   should_poll.RecordSample();
   t += timer_interval;
   ASSERT_FALSE(should_not_poll.IsOverdueForSamplingAt(t))
       << "Sampled last event; should not be dirty.";
@@ skipping 14 matching lines @@
   t += timer_interval / 3;
   ASSERT_FALSE(should_not_poll.IsOverdueForSamplingAt(t))
       << "Sampled last event; should not be dirty.";
   ASSERT_TRUE(should_poll.IsOverdueForSamplingAt(t))
       << "If updates are unreliable, must fall back to polling when idle.";
   should_poll.RecordSample();
 }
 
 }  // namespace content