content/browser/renderer_host/media/video_capture_oracle_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/media/video_capture_oracle.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "base/time/time.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace content {
  12 namespace {
  13
  14 void SteadyStateSampleAndAdvance(base::TimeDelta vsync,
  15                                  SmoothEventSampler* sampler, base::Time* t) {
  16   ASSERT_TRUE(sampler->AddEventAndConsiderSampling(*t));
  17   ASSERT_TRUE(sampler->HasUnrecordedEvent());
  18   sampler->RecordSample();
  19   ASSERT_FALSE(sampler->HasUnrecordedEvent());
  20   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
  21   *t += vsync;
  22   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
  23 }
  24
  25 void SteadyStateNoSampleAndAdvance(base::TimeDelta vsync,
  26                                    SmoothEventSampler* sampler, base::Time* t) {
  27   ASSERT_FALSE(sampler->AddEventAndConsiderSampling(*t));
  28   ASSERT_TRUE(sampler->HasUnrecordedEvent());
  29   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
  30   *t += vsync;
  31   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t));
  32 }
  33
  34 void TestRedundantCaptureStrategy(base::TimeDelta capture_period,
  35                                   int redundant_capture_goal,
  36                                   SmoothEventSampler* sampler, base::Time* t) {
  37   // Before any events have been considered, we're overdue for sampling.
  38   ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t));
  39
  40   // Consider the first event.  We want to sample that.
  41   ASSERT_FALSE(sampler->HasUnrecordedEvent());
  42   ASSERT_TRUE(sampler->AddEventAndConsiderSampling(*t));
  43   ASSERT_TRUE(sampler->HasUnrecordedEvent());
  44   sampler->RecordSample();
  45   ASSERT_FALSE(sampler->HasUnrecordedEvent());
  46
  47   // After more than one capture period has passed without considering an event,
  48   // we should repeatedly be overdue for sampling.  However, once the redundant
  49   // capture goal is achieved, we should no longer be overdue for sampling.
  50   *t += capture_period * 4;
  51   for (int i = 0; i < redundant_capture_goal; i++) {
  52     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
  53     ASSERT_FALSE(sampler->HasUnrecordedEvent());
  54     ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t))
  55         << "Should sample until redundant capture goal is hit";
  56     sampler->RecordSample();
  57     *t += capture_period;  // Timer fires once every capture period.
  58   }
  59   ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t))
  60       << "Should not be overdue once redundant capture goal achieved.";
  61 }
  62
  63 // 60Hz sampled at 30Hz should produce 30Hz.  In addition, this test contains
  64 // much more comprehensive before/after/edge-case scenarios than the others.
  65 TEST(SmoothEventSamplerTest, Sample60HertzAt30Hertz) {
  66   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
  67   const int redundant_capture_goal = 200;
  68   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60;
  69
  70   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
  71   base::Time t;
  72   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
  73
  74   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
  75                                &sampler, &t);
  76
  77   // Steady state, we should capture every other vsync, indefinitely.
  78   for (int i = 0; i < 100; i++) {
  79     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
  80     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
  81     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
  82   }
  83
  84   // Now pretend we're limited by backpressure in the pipeline. In this scenario
  85   // case we are adding events but not sampling them.
  86   for (int i = 0; i < 20; i++) {
  87     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
  88     ASSERT_EQ(i >= 7, sampler.IsOverdueForSamplingAt(t));
  89     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
  90     ASSERT_TRUE(sampler.HasUnrecordedEvent());
  91     t += vsync;
  92   }
  93
  94   // Now suppose we can sample again. We should be back in the steady state,
  95   // but at a different phase.
  96   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
  97   for (int i = 0; i < 100; i++) {
  98     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
  99     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 100     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 101   }
 102 }
 103
 104 // 50Hz sampled at 30Hz should produce a sequence where some frames are skipped.
 105 TEST(SmoothEventSamplerTest, Sample50HertzAt30Hertz) {
 106   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
 107   const int redundant_capture_goal = 2;
 108   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 50;
 109
 110   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
 111   base::Time t;
 112   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 113
 114   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
 115                                &sampler, &t);
 116
 117   // Steady state, we should capture 1st, 2nd and 4th frames out of every five
 118   // frames, indefinitely.
 119   for (int i = 0; i < 100; i++) {
 120     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 121     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 122     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 123     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 124     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 125     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 126   }
 127
 128   // Now pretend we're limited by backpressure in the pipeline. In this scenario
 129   // case we are adding events but not sampling them.
 130   for (int i = 0; i < 12; i++) {
 131     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 132     ASSERT_EQ(i >= 5, sampler.IsOverdueForSamplingAt(t));
 133     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
 134     t += vsync;
 135   }
 136
 137   // Now suppose we can sample again. We should be back in the steady state
 138   // again.
 139   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
 140   for (int i = 0; i < 100; i++) {
 141     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 142     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 143     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 144     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 145     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 146     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 147   }
 148 }
 149
 150 // 75Hz sampled at 30Hz should produce a sequence where some frames are skipped.
 151 TEST(SmoothEventSamplerTest, Sample75HertzAt30Hertz) {
 152   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
 153   const int redundant_capture_goal = 32;
 154   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 75;
 155
 156   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
 157   base::Time t;
 158   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 159
 160   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
 161                                &sampler, &t);
 162
 163   // Steady state, we should capture 1st and 3rd frames out of every five
 164   // frames, indefinitely.
 165   SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 166   SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 167   for (int i = 0; i < 100; i++) {
 168     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 169     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 170     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 171     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 172     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 173     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 174   }
 175
 176   // Now pretend we're limited by backpressure in the pipeline. In this scenario
 177   // case we are adding events but not sampling them.
 178   for (int i = 0; i < 20; i++) {
 179     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 180     ASSERT_EQ(i >= 8, sampler.IsOverdueForSamplingAt(t));
 181     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
 182     t += vsync;
 183   }
 184
 185   // Now suppose we can sample again. We capture the next frame, and not the one
 186   // after that, and then we're back in the steady state again.
 187   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
 188   SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 189   SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 190   for (int i = 0; i < 100; i++) {
 191     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 192     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 193     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 194     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 195     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 196     SteadyStateNoSampleAndAdvance(vsync, &sampler, &t);
 197   }
 198 }
 199
 200 // 30Hz sampled at 30Hz should produce 30Hz.
 201 TEST(SmoothEventSamplerTest, Sample30HertzAt30Hertz) {
 202   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
 203   const int redundant_capture_goal = 1;
 204   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 30;
 205
 206   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
 207   base::Time t;
 208   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 209
 210   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
 211                                &sampler, &t);
 212
 213   // Steady state, we should capture every vsync, indefinitely.
 214   for (int i = 0; i < 200; i++) {
 215     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 216     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 217   }
 218
 219   // Now pretend we're limited by backpressure in the pipeline. In this scenario
 220   // case we are adding events but not sampling them.
 221   for (int i = 0; i < 7; i++) {
 222     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 223     ASSERT_EQ(i >= 3, sampler.IsOverdueForSamplingAt(t));
 224     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
 225     t += vsync;
 226   }
 227
 228   // Now suppose we can sample again. We should be back in the steady state.
 229   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
 230   for (int i = 0; i < 100; i++) {
 231     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 232     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 233   }
 234 }
 235
 236 // 24Hz sampled at 30Hz should produce 24Hz.
 237 TEST(SmoothEventSamplerTest, Sample24HertzAt30Hertz) {
 238   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
 239   const int redundant_capture_goal = 333;
 240   const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 24;
 241
 242   SmoothEventSampler sampler(capture_period, true, redundant_capture_goal);
 243   base::Time t;
 244   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 245
 246   TestRedundantCaptureStrategy(capture_period, redundant_capture_goal,
 247                                &sampler, &t);
 248
 249   // Steady state, we should capture every vsync, indefinitely.
 250   for (int i = 0; i < 200; i++) {
 251     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 252     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 253   }
 254
 255   // Now pretend we're limited by backpressure in the pipeline. In this scenario
 256   // case we are adding events but not sampling them.
 257   for (int i = 0; i < 7; i++) {
 258     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 259     ASSERT_EQ(i >= 3, sampler.IsOverdueForSamplingAt(t));
 260     ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
 261     t += vsync;
 262   }
 263
 264   // Now suppose we can sample again. We should be back in the steady state.
 265   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t));
 266   for (int i = 0; i < 100; i++) {
 267     SCOPED_TRACE(base::StringPrintf("Iteration %d", i));
 268     SteadyStateSampleAndAdvance(vsync, &sampler, &t);
 269   }
 270 }
 271
 272 TEST(SmoothEventSamplerTest, DoubleDrawAtOneTimeStillDirties) {
 273   const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30;
 274   const base::TimeDelta overdue_period = base::TimeDelta::FromSeconds(1);
 275
 276   SmoothEventSampler sampler(capture_period, true, 1);
 277   base::Time t;
 278   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 279
 280   ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
 281   sampler.RecordSample();
 282   ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t))
 283       << "Sampled last event; should not be dirty.";
 284   t += overdue_period;
 285
 286   // Now simulate 2 events with the same clock value.
 287   ASSERT_TRUE(sampler.AddEventAndConsiderSampling(t));
 288   sampler.RecordSample();
 289   ASSERT_FALSE(sampler.AddEventAndConsiderSampling(t))
 290       << "Two events at same time -- expected second not to be sampled.";
 291   ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t + overdue_period))
 292       << "Second event should dirty the capture state.";
 293   sampler.RecordSample();
 294   ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t + overdue_period));
 295 }
 296
 297 TEST(SmoothEventSamplerTest, FallbackToPollingIfUpdatesUnreliable) {
 298   const base::TimeDelta timer_interval = base::TimeDelta::FromSeconds(1) / 30;
 299
 300   SmoothEventSampler should_not_poll(timer_interval, true, 1);
 301   SmoothEventSampler should_poll(timer_interval, false, 1);
 302   base::Time t;
 303   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 304
 305   // Do one round of the "happy case" where an event was received and
 306   // RecordSample() was called by the client.
 307   ASSERT_TRUE(should_not_poll.AddEventAndConsiderSampling(t));
 308   ASSERT_TRUE(should_poll.AddEventAndConsiderSampling(t));
 309   should_not_poll.RecordSample();
 310   should_poll.RecordSample();
 311
 312   // One time period ahead, neither sampler says we're overdue.
 313   for (int i = 0; i < 3; i++) {
 314     t += timer_interval;
 315     ASSERT_FALSE(should_not_poll.IsOverdueForSamplingAt(t))
 316         << "Sampled last event; should not be dirty.";
 317     ASSERT_FALSE(should_poll.IsOverdueForSamplingAt(t))
 318         << "Dirty interval has not elapsed yet.";
 319   }
 320
 321   // Next time period ahead, both samplers say we're overdue.  The non-polling
 322   // sampler is returning true here because it has been configured to allow one
 323   // redundant capture.
 324   t += timer_interval;
 325   ASSERT_TRUE(should_not_poll.IsOverdueForSamplingAt(t))
 326       << "Sampled last event; is dirty one time only to meet redundancy goal.";
 327   ASSERT_TRUE(should_poll.IsOverdueForSamplingAt(t))
 328       << "If updates are unreliable, must fall back to polling when idle.";
 329   should_not_poll.RecordSample();
 330   should_poll.RecordSample();
 331
 332   // Forever more, the non-polling sampler returns false while the polling one
 333   // returns true.
 334   for (int i = 0; i < 100; ++i) {
 335     t += timer_interval;
 336     ASSERT_FALSE(should_not_poll.IsOverdueForSamplingAt(t))
 337         << "Sampled last event; should not be dirty.";
 338     ASSERT_TRUE(should_poll.IsOverdueForSamplingAt(t))
 339         << "If updates are unreliable, must fall back to polling when idle.";
 340     should_poll.RecordSample();
 341   }
 342   t += timer_interval / 3;
 343   ASSERT_FALSE(should_not_poll.IsOverdueForSamplingAt(t))
 344       << "Sampled last event; should not be dirty.";
 345   ASSERT_TRUE(should_poll.IsOverdueForSamplingAt(t))
 346       << "If updates are unreliable, must fall back to polling when idle.";
 347   should_poll.RecordSample();
 348 }
 349
 350 struct DataPoint {
 351   bool should_capture;
 352   double increment_ms;
 353 };
 354
 355 void ReplayCheckingSamplerDecisions(const DataPoint* data_points,
 356                                     size_t num_data_points,
 357                                     SmoothEventSampler* sampler) {
 358   base::Time t;
 359   ASSERT_TRUE(base::Time::FromString("Sat, 23 Mar 2013 1:21:08 GMT", &t));
 360   for (size_t i = 0; i < num_data_points; ++i) {
 361     t += base::TimeDelta::FromMicroseconds(
 362         static_cast<int64>(data_points[i].increment_ms * 1000));
 363     ASSERT_EQ(data_points[i].should_capture,
 364               sampler->AddEventAndConsiderSampling(t))
 365         << "at data_points[" << i << ']';
 366     if (data_points[i].should_capture)
 367       sampler->RecordSample();
 368   }
 369 }
 370
 371 TEST(SmoothEventSamplerTest, DrawingAt24FpsWith60HzVsyncSampledAt30Hertz) {
 372   // Actual capturing of timing data: Initial instability as a 24 FPS video was
 373   // started from a still screen, then clearly followed by steady-state.
 374   static const DataPoint data_points[] = {
 375     { true, 1437.93 }, { true, 150.484 }, { true, 217.362 }, { true, 50.161 },
 376     { true, 33.44 }, { false, 0 }, { true, 16.721 }, { true, 66.88 },
 377     { true, 50.161 }, { false, 0 }, { false, 0 }, { true, 50.16 },
 378     { true, 33.441 }, { true, 16.72 }, { false, 16.72 }, { true, 117.041 },
 379     { true, 16.72 }, { false, 16.72 }, { true, 50.161 }, { true, 50.16 },
 380     { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { true, 16.72 },
 381     { false, 0 }, { true, 50.161 }, { false, 0 }, { true, 33.44 },
 382     { true, 16.72 }, { false, 16.721 }, { true, 66.881 }, { false, 0 },
 383     { true, 33.441 }, { true, 16.72 }, { true, 50.16 }, { true, 16.72 },
 384     { false, 16.721 }, { true, 50.161 }, { true, 50.16 }, { false, 0 },
 385     { true, 33.441 }, { true, 50.337 }, { true, 50.183 }, { true, 16.722 },
 386     { true, 50.161 }, { true, 33.441 }, { true, 50.16 }, { true, 33.441 },
 387     { true, 50.16 }, { true, 33.441 }, { true, 50.16 }, { true, 33.44 },
 388     { true, 50.161 }, { true, 50.16 }, { true, 33.44 }, { true, 33.441 },
 389     { true, 50.16 }, { true, 50.161 }, { true, 33.44 }, { true, 33.441 },
 390     { true, 50.16 }, { true, 33.44 }, { true, 50.161 }, { true, 33.44 },
 391     { true, 50.161 }, { true, 33.44 }, { true, 50.161 }, { true, 33.44 },
 392     { true, 83.601 }, { true, 16.72 }, { true, 33.44 }, { false, 0 }
 393   };
 394
 395   SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 3);
 396   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 397 }
 398
 399 TEST(SmoothEventSamplerTest, DrawingAt30FpsWith60HzVsyncSampledAt30Hertz) {
 400   // Actual capturing of timing data: Initial instability as a 30 FPS video was
 401   // started from a still screen, then followed by steady-state.  Drawing
 402   // framerate from the video rendering was a bit volatile, but averaged 30 FPS.
 403   static const DataPoint data_points[] = {
 404     { true, 2407.69 }, { true, 16.733 }, { true, 217.362 }, { true, 33.441 },
 405     { true, 33.44 }, { true, 33.44 }, { true, 33.441 }, { true, 33.44 },
 406     { true, 33.44 }, { true, 33.441 }, { true, 33.44 }, { true, 33.44 },
 407     { true, 16.721 }, { true, 33.44 }, { false, 0 }, { true, 50.161 },
 408     { true, 50.16 }, { false, 0 }, { true, 50.161 }, { true, 33.44 },
 409     { true, 16.72 }, { false, 0 }, { false, 16.72 }, { true, 66.881 },
 410     { false, 0 }, { true, 33.44 }, { true, 16.72 }, { true, 50.161 },
 411     { false, 0 }, { true, 33.538 }, { true, 33.526 }, { true, 33.447 },
 412     { true, 33.445 }, { true, 33.441 }, { true, 16.721 }, { true, 33.44 },
 413     { true, 33.44 }, { true, 50.161 }, { true, 16.72 }, { true, 33.44 },
 414     { true, 33.441 }, { true, 33.44 }, { false, 0 }, { false, 16.72 },
 415     { true, 66.881 }, { true, 16.72 }, { false, 16.72 }, { true, 50.16 },
 416     { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { true, 33.44 },
 417     { true, 33.441 }, { true, 33.44 }, { true, 50.161 }, { false, 0 },
 418     { true, 33.44 }, { true, 33.44 }, { true, 50.161 }, { true, 16.72 },
 419     { true, 33.44 }, { true, 33.441 }, { false, 0 }, { true, 66.88 },
 420     { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { false, 0 },
 421     { true, 33.441 }, { true, 33.44 }, { true, 33.44 }, { false, 0 },
 422     { true, 16.72 }, { true, 50.161 }, { false, 0 }, { true, 50.16 },
 423     { false, 0.001 }, { true, 16.721 }, { true, 66.88 }, { true, 33.44 },
 424     { true, 33.441 }, { true, 33.44 }, { true, 50.161 }, { true, 16.72 },
 425     { false, 0 }, { true, 33.44 }, { false, 16.72 }, { true, 66.881 },
 426     { true, 33.44 }, { true, 16.72 }, { true, 33.441 }, { false, 16.72 },
 427     { true, 66.88 }, { true, 16.721 }, { true, 50.16 }, { true, 33.44 },
 428     { true, 16.72 }, { true, 33.441 }, { true, 33.44 }, { true, 33.44 }
 429   };
 430
 431   SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 3);
 432   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 433 }
 434
 435 TEST(SmoothEventSamplerTest, DrawingAt60FpsWith60HzVsyncSampledAt30Hertz) {
 436   // Actual capturing of timing data: WebGL Acquarium demo
 437   // (http://webglsamples.googlecode.com/hg/aquarium/aquarium.html) which ran
 438   // between 55-60 FPS in the steady-state.
 439   static const DataPoint data_points[] = {
 440     { true, 16.72 }, { true, 16.72 }, { true, 4163.29 }, { true, 50.193 },
 441     { true, 117.041 }, { true, 50.161 }, { true, 50.16 }, { true, 33.441 },
 442     { true, 50.16 }, { true, 33.44 }, { false, 0 }, { false, 0 },
 443     { true, 50.161 }, { true, 83.601 }, { true, 50.16 }, { true, 16.72 },
 444     { true, 33.441 }, { false, 16.72 }, { true, 50.16 }, { true, 16.72 },
 445     { false, 0.001 }, { true, 33.441 }, { false, 16.72 }, { true, 16.72 },
 446     { true, 50.16 }, { false, 0 }, { true, 16.72 }, { true, 33.441 },
 447     { false, 0 }, { true, 33.44 }, { false, 16.72 }, { true, 16.72 },
 448     { true, 50.161 }, { false, 0 }, { true, 16.72 }, { true, 33.44 },
 449     { false, 0 }, { true, 33.44 }, { false, 16.721 }, { true, 16.721 },
 450     { true, 50.161 }, { false, 0 }, { true, 16.72 }, { true, 33.441 },
 451     { false, 0 }, { true, 33.44 }, { false, 16.72 }, { true, 33.44 },
 452     { false, 0 }, { true, 16.721 }, { true, 50.161 }, { false, 0 },
 453     { true, 33.44 }, { false, 0 }, { true, 16.72 }, { true, 33.441 },
 454     { false, 0 }, { true, 33.44 }, { false, 16.72 }, { true, 16.72 },
 455     { true, 50.16 }, { false, 0 }, { true, 16.721 }, { true, 33.44 },
 456     { false, 0 }, { true, 33.44 }, { false, 16.721 }, { true, 16.721 },
 457     { true, 50.161 }, { false, 0 }, { true, 16.72 }, { true, 33.44 },
 458     { false, 0 }, { true, 33.441 }, { false, 16.72 }, { true, 16.72 },
 459     { true, 50.16 }, { false, 0 }, { true, 16.72 }, { true, 33.441 },
 460     { true, 33.44 }, { false, 0 }, { true, 33.44 }, { true, 33.441 },
 461     { false, 0 }, { true, 33.44 }, { true, 33.441 }, { false, 0 },
 462     { true, 33.44 }, { false, 0 }, { true, 33.44 }, { false, 16.72 },
 463     { true, 16.721 }, { true, 50.161 }, { false, 0 }, { true, 16.72 },
 464     { true, 33.44 }, { true, 33.441 }, { false, 0 }, { true, 33.44 },
 465     { true, 33.44 }, { false, 0 }, { true, 33.441 }, { false, 16.72 },
 466     { true, 16.72 }, { true, 50.16 }, { false, 0 }, { true, 16.72 },
 467     { true, 33.441 }, { false, 0 }, { true, 33.44 }, { false, 16.72 },
 468     { true, 33.44 }, { false, 0 }, { true, 16.721 }, { true, 50.161 },
 469     { false, 0 }, { true, 16.72 }, { true, 33.44 }, { false, 0 },
 470     { true, 33.441 }, { false, 16.72 }, { true, 16.72 }, { true, 50.16 }
 471   };
 472
 473   SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, true, 3);
 474   ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler);
 475 }
 476
 477 }  // namespace
 478 }  // namespace content