diff options
Diffstat (limited to 'chromium/media/capture/smooth_event_sampler_unittest.cc')
-rw-r--r-- | chromium/media/capture/smooth_event_sampler_unittest.cc | 488 |
1 files changed, 0 insertions, 488 deletions
diff --git a/chromium/media/capture/smooth_event_sampler_unittest.cc b/chromium/media/capture/smooth_event_sampler_unittest.cc deleted file mode 100644 index 14a6823f556..00000000000 --- a/chromium/media/capture/smooth_event_sampler_unittest.cc +++ /dev/null @@ -1,488 +0,0 @@ -// 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/smooth_event_sampler.h" - -#include "base/strings/stringprintf.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace media { - -namespace { - -bool AddEventAndConsiderSampling(SmoothEventSampler* sampler, - base::TimeTicks event_time) { - sampler->ConsiderPresentationEvent(event_time); - 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, 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, 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, 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, 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, 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, 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++) { - SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); - SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); - SteadyStateSampleAndAdvance(vsync, &sampler, &t); - } - - // Now change the capture rate back to 60 Hz, and we should capture every - // vsync again. - sampler.SetMinCapturePeriod(one_to_one_period); - for (int i = 0; i < 100; i++) { - SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); - SteadyStateSampleAndAdvance(vsync, &sampler, &t); - } - - // Now change the capture rate to 24 Hz, and we should capture with a 2-3-2-3 - // cadence. - sampler.SetMinCapturePeriod(two_and_three_to_one_period); - 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) { - base::TimeTicks t = InitialTestTimeTicks(); - for (size_t i = 0; i < num_data_points; ++i) { - t += base::TimeDelta::FromMicroseconds( - static_cast<int64>(data_points[i].increment_ms * 1000)); - ASSERT_EQ(data_points[i].should_capture, - AddEventAndConsiderSampling(sampler, t)) - << "at data_points[" << i << ']'; - if (data_points[i].should_capture) - sampler->RecordSample(); - } -} - -} // namespace - -TEST(SmoothEventSamplerTest, DrawingAt24FpsWith60HzVsyncSampledAt30Hertz) { - // Actual capturing of timing data: Initial instability as a 24 FPS video was - // started from a still screen, then clearly followed by steady-state. - static const DataPoint data_points[] = { - { true, 1437.93 }, { true, 150.484 }, { true, 217.362 }, { true, 50.161 }, - { true, 33.44 }, { false, 0 }, { true, 16.721 }, { true, 66.88 }, - { true, 50.161 }, { false, 0 }, { false, 0 }, { true, 50.16 }, - { true, 33.441 }, { true, 16.72 }, { false, 16.72 }, { true, 117.041 }, - { true, 16.72 }, { false, 16.72 }, { true, 50.161 }, { true, 50.16 }, - { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { true, 16.72 }, - { false, 0 }, { true, 50.161 }, { false, 0 }, { true, 33.44 }, - { true, 16.72 }, { false, 16.721 }, { true, 66.881 }, { false, 0 }, - { true, 33.441 }, { true, 16.72 }, { true, 50.16 }, { true, 16.72 }, - { false, 16.721 }, { true, 50.161 }, { true, 50.16 }, { false, 0 }, - { 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, 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 }, - { true, 33.44 }, { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, - { true, 16.721 }, { true, 33.44 }, { false, 0 }, { true, 50.161 }, - { true, 50.16 }, { false, 0 }, { true, 50.161 }, { true, 33.44 }, - { true, 16.72 }, { false, 0 }, { false, 16.72 }, { true, 66.881 }, - { false, 0 }, { true, 33.44 }, { true, 16.72 }, { true, 50.161 }, - { false, 0 }, { true, 33.538 }, { true, 33.526 }, { true, 33.447 }, - { true, 33.445 }, { true, 33.441 }, { true, 16.721 }, { true, 33.44 }, - { true, 33.44 }, { true, 50.161 }, { true, 16.72 }, { true, 33.44 }, - { true, 33.441 }, { true, 33.44 }, { false, 0 }, { false, 16.72 }, - { true, 66.881 }, { true, 16.72 }, { false, 16.72 }, { true, 50.16 }, - { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { true, 33.44 }, - { true, 33.441 }, { true, 33.44 }, { true, 50.161 }, { false, 0 }, - { true, 33.44 }, { true, 33.44 }, { true, 50.161 }, { true, 16.72 }, - { true, 33.44 }, { true, 33.441 }, { false, 0 }, { true, 66.88 }, - { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { false, 0 }, - { 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, 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 }, - { true, 50.16 }, { true, 33.44 }, { false, 0 }, { false, 0 }, - { true, 50.161 }, { true, 83.601 }, { true, 50.16 }, { true, 16.72 }, - { true, 33.441 }, { false, 16.72 }, { true, 50.16 }, { true, 16.72 }, - { false, 0.001 }, { 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, 16.72 }, - { true, 50.161 }, { false, 0 }, { true, 16.72 }, { true, 33.44 }, - { false, 0 }, { true, 33.44 }, { false, 16.721 }, { true, 16.721 }, - { true, 50.161 }, { 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, 33.44 }, { false, 0 }, { true, 16.72 }, { true, 33.441 }, - { false, 0 }, { true, 33.44 }, { false, 16.72 }, { true, 16.72 }, - { true, 50.16 }, { false, 0 }, { true, 16.721 }, { true, 33.44 }, - { false, 0 }, { true, 33.44 }, { false, 16.721 }, { 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 }, { false, 0 }, { true, 16.72 }, { true, 33.441 }, - { true, 33.44 }, { false, 0 }, { true, 33.44 }, { true, 33.441 }, - { false, 0 }, { true, 33.44 }, { true, 33.441 }, { false, 0 }, - { true, 33.44 }, { false, 0 }, { true, 33.44 }, { false, 16.72 }, - { 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, 3); - ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler); -} - -} // namespace media |