Clean-up: Remove accelerated subscriber switch for tab/desktop capture.

content/browser/media/capture/video_capture_oracle_unittest.cc

 // Copyright (c) 2013 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/media/capture/video_capture_oracle.h"
 
 #include <cstdlib>
 #include <utility>
 #include <vector>
 
@@ skipping 70 matching lines @@
 
 }  // 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, true, redundant_capture_goal);
+  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);
@@ skipping 18 matching lines @@
     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, true, redundant_capture_goal);
+  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);
@@ skipping 24 matching lines @@
     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, true, redundant_capture_goal);
+  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++) {
@@ skipping 28 matching lines @@
     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, true, redundant_capture_goal);
+  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);
   }
@@ skipping 14 matching lines @@
     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, true, redundant_capture_goal);
+  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);
   }
@@ skipping 12 matching lines @@
   for (int i = 0; i < 100; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
     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, true, 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));
 }
 
-TEST(SmoothEventSamplerTest, FallbackToPollingIfUpdatesUnreliable) {
-  const base::TimeDelta timer_interval = base::TimeDelta::FromSeconds(1) / 30;
-
-  SmoothEventSampler should_not_poll(timer_interval, true, 1);
-  SmoothEventSampler should_poll(timer_interval, false, 1);
-  base::TimeTicks t = InitialTestTimeTicks();
-
-  // Do one round of the "happy case" where an event was received and
-  // RecordSample() was called by the client.
-  ASSERT_TRUE(AddEventAndConsiderSampling(&should_not_poll, t));
-  ASSERT_TRUE(AddEventAndConsiderSampling(&should_poll, t));
-  should_not_poll.RecordSample();
-  should_poll.RecordSample();
-
-  // For the following time period, before 250 ms has elapsed, neither sampler
-  // says we're overdue.
-  const int non_overdue_intervals = static_cast<int>(
-      base::TimeDelta::FromMilliseconds(250) / timer_interval);
-  for (int i = 0; i < non_overdue_intervals; i++) {
-    t += timer_interval;
-    ASSERT_FALSE(should_not_poll.IsOverdueForSamplingAt(t))
-        << "Sampled last event; should not be dirty.";
-    ASSERT_FALSE(should_poll.IsOverdueForSamplingAt(t))
-        << "Dirty interval has not elapsed yet.";
-  }
-
-  // Next time period ahead, both samplers say we're overdue.  The non-polling
-  // sampler is returning true here because it has been configured to allow one
-  // redundant capture.
-  t += timer_interval;  // Step past the 250 ms threshold.
-  ASSERT_TRUE(should_not_poll.IsOverdueForSamplingAt(t))
-      << "Sampled last event; is dirty one time only to meet redundancy goal.";
-  ASSERT_TRUE(should_poll.IsOverdueForSamplingAt(t))
-      << "If updates are unreliable, must fall back to polling when idle.";
-  should_not_poll.RecordSample();
-  should_poll.RecordSample();
-
-  // Forever more, the non-polling sampler returns false while the polling one
-  // returns true.
-  for (int i = 0; i < 100; ++i) {
-    t += timer_interval;
-    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();
-  }
-  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 {
 
 struct DataPoint {
   bool should_capture;
   double increment_ms;
 };
 
 void ReplayCheckingSamplerDecisions(const DataPoint* data_points,
                                     size_t num_data_points,
                                     SmoothEventSampler* sampler) {
@@ skipping 28 matching lines @@
     { true, 33.441 }, { true, 50.337 }, { true, 50.183 }, { true, 16.722 },
     { true, 50.161 }, { true, 33.441 }, { true, 50.16 }, { true, 33.441 },
     { true, 50.16 }, { true, 33.441 }, { true, 50.16 }, { true, 33.44 },
     { true, 50.161 }, { true, 50.16 }, { true, 33.44 }, { true, 33.441 },
     { true, 50.16 }, { true, 50.161 }, { true, 33.44 }, { true, 33.441 },
     { true, 50.16 }, { true, 33.44 }, { true, 50.161 }, { 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, true, 3);
+  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 }, { true, 33.441 },
     { true, 33.44 }, { true, 33.44 }, { true, 33.441 }, { true, 33.44 },
@@ skipping 15 matching lines @@
     { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { false, 0 },
     { true, 16.72 }, { true, 50.161 }, { false, 0 }, { true, 50.16 },
     { false, 0.001 }, { true, 16.721 }, { true, 66.88 }, { true, 33.44 },
     { true, 33.441 }, { true, 33.44 }, { true, 50.161 }, { true, 16.72 },
     { false, 0 }, { true, 33.44 }, { false, 16.72 }, { true, 66.881 },
     { true, 33.44 }, { true, 16.72 }, { true, 33.441 }, { 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, true, 3);
+  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 }, { true, 50.193 },
     { true, 117.041 }, { true, 50.161 }, { true, 50.16 }, { true, 33.441 },
@@ skipping 21 matching lines @@
     { true, 16.721 }, { true, 50.161 }, { false, 0 }, { true, 16.72 },
     { true, 33.44 }, { true, 33.441 }, { false, 0 }, { true, 33.44 },
     { true, 33.44 }, { false, 0 }, { true, 33.441 }, { false, 16.72 },
     { true, 16.72 }, { true, 50.16 }, { false, 0 }, { true, 16.72 },
     { true, 33.441 }, { false, 0 }, { true, 33.44 }, { false, 16.72 },
     { true, 33.44 }, { false, 0 }, { true, 16.721 }, { 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, true, 3);
+  SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3);
   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 }
 
 class AnimatedContentSamplerTest : public ::testing::Test {
  public:
   AnimatedContentSamplerTest() {}
   ~AnimatedContentSamplerTest() override {}
 
   void SetUp() override {
     const base::TimeDelta since_epoch =
@@ skipping 605 matching lines @@
          Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(33))));
 
 // Tests that VideoCaptureOracle filters out events whose timestamps are
 // decreasing.
 TEST(VideoCaptureOracleTest, EnforcesEventTimeMonotonicity) {
   const base::TimeDelta min_capture_period =
       base::TimeDelta::FromSeconds(1) / 30;
   const gfx::Rect damage_rect(0, 0, 1280, 720);
   const base::TimeDelta event_increment = min_capture_period * 2;
 
-  VideoCaptureOracle oracle(min_capture_period, true);
+  VideoCaptureOracle oracle(min_capture_period);
 
   base::TimeTicks t = InitialTestTimeTicks();
   for (int i = 0; i < 10; ++i) {
     t += event_increment;
     ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
         VideoCaptureOracle::kCompositorUpdate,
         damage_rect, t));
   }
 
   base::TimeTicks furthest_event_time = t;
@@ skipping 15 matching lines @@
 
 // Tests that VideoCaptureOracle is enforcing the requirement that captured
 // frames are delivered in order.  Otherwise, downstream consumers could be
 // tripped-up by out-of-order frames or frame timestamps.
 TEST(VideoCaptureOracleTest, EnforcesFramesDeliveredInOrder) {
   const base::TimeDelta min_capture_period =
       base::TimeDelta::FromSeconds(1) / 30;
   const gfx::Rect damage_rect(0, 0, 1280, 720);
   const base::TimeDelta event_increment = min_capture_period * 2;
 
-  VideoCaptureOracle oracle(min_capture_period, true);
+  VideoCaptureOracle oracle(min_capture_period);
 
   // Most basic scenario: Frames delivered one at a time, with no additional
   // captures in-between deliveries.
   base::TimeTicks t = InitialTestTimeTicks();
   int last_frame_number;
   base::TimeTicks ignored;
   for (int i = 0; i < 10; ++i) {
     t += event_increment;
     ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
         VideoCaptureOracle::kCompositorUpdate,
@@ skipping 35 matching lines @@
 }
 
 // Tests that VideoCaptureOracle transitions between using its two samplers in a
 // way that does not introduce severe jank, pauses, etc.
 TEST(VideoCaptureOracleTest, TransitionsSmoothlyBetweenSamplers) {
   const base::TimeDelta min_capture_period =
       base::TimeDelta::FromSeconds(1) / 30;
   const gfx::Rect animation_damage_rect(0, 0, 1280, 720);
   const base::TimeDelta event_increment = min_capture_period * 2;
 
-  VideoCaptureOracle oracle(min_capture_period, true);
+  VideoCaptureOracle oracle(min_capture_period);
 
   // Run sequences of animation events and non-animation events through the
   // oracle.  As the oracle transitions between each sampler, make sure the
   // frame timestamps won't trip-up downstream consumers.
   base::TimeTicks t = InitialTestTimeTicks();
   base::TimeTicks last_frame_timestamp;
   for (int i = 0; i < 1000; ++i) {
     t += event_increment;
 
     // For every 100 events, provide 50 that will cause the
@@ skipping 30 matching lines @@
       // |event_increment|.
       const base::TimeDelta max_acceptable_delta = (i % 100) == 78 ?
           event_increment * 5 : event_increment * 2;
       EXPECT_GE(max_acceptable_delta.InMicroseconds(), delta.InMicroseconds());
     }
     last_frame_timestamp = frame_timestamp;
   }
 }
 
 }  // namespace content