Tab Capture: AnimatedContentSampler subsampling and phase fixes in tests

content/browser/media/capture/animated_content_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 "content/browser/media/capture/animated_content_sampler.h"
 
-#include <cstdlib>
+#include <cmath>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace content {
 
 namespace {
 
 base::TimeTicks InitialTestTimeTicks() {
   return base::TimeTicks() + base::TimeDelta::FromSeconds(1);
 }
 
+base::TimeDelta FpsAsPeriod(int frame_rate) {
+  return base::TimeDelta::FromSeconds(1) / frame_rate;
+}
+
 }  // namespace
 
 class AnimatedContentSamplerTest : public ::testing::Test {
  public:
   AnimatedContentSamplerTest() {}
   ~AnimatedContentSamplerTest() override {}
 
   void SetUp() override {
     const base::TimeDelta since_epoch =
         InitialTestTimeTicks() - base::TimeTicks::UnixEpoch();
@@ skipping 30 matching lines @@
   // ElectMajorityDamageRect().
   void ObserveDamageRect(const gfx::Rect& damage_rect) {
     sampler_->observations_.push_back(
         AnimatedContentSampler::Observation(damage_rect, base::TimeTicks()));
   }
 
   gfx::Rect ElectMajorityDamageRect() const {
     return sampler_->ElectMajorityDamageRect();
   }
 
+  static base::TimeDelta ComputeSamplingPeriod(
+      base::TimeDelta detected_period,
+      base::TimeDelta target_sampling_period,
+      base::TimeDelta min_capture_period) {
+    return AnimatedContentSampler::ComputeSamplingPeriod(
+        detected_period, target_sampling_period, min_capture_period);
+  }
+
  private:
   // Note: Not using base::RandInt() because it is horribly slow on debug
   // builds.  The following is a very simple, deterministic LCG:
   int NextRandomInt() {
     rand_seed_ = (1103515245 * rand_seed_ + 12345) % (1 << 31);
     return rand_seed_;
   }
 
   int rand_seed_;
   scoped_ptr<AnimatedContentSampler> sampler_;
@@ skipping 70 matching lines @@
     ObserveDamageRect(spinner_rect);
     ObserveDamageRect(video_rect);
     ObserveDamageRect(spinner_rect);
     ObserveDamageRect(spinner_rect);
     ObserveDamageRect(video_rect);
     ObserveDamageRect(spinner_rect);
   }
   EXPECT_EQ(video_rect, ElectMajorityDamageRect());
 }
 
+TEST_F(AnimatedContentSamplerTest, TargetsSamplingPeriod) {
+  struct Helper {
+    static void RunTargetSamplingPeriodTest(int target_fps) {
+      const base::TimeDelta min_capture_period = FpsAsPeriod(60);
+      const base::TimeDelta target_sampling_period = FpsAsPeriod(target_fps);
+
+      for (int content_fps = 1; content_fps <= 60; ++content_fps) {
+        const base::TimeDelta content_period = FpsAsPeriod(content_fps);
+        const base::TimeDelta sampling_period =
+            ComputeSamplingPeriod(content_period,
+                                  target_sampling_period,
+                                  min_capture_period);
+        if (content_period >= target_sampling_period) {
+          ASSERT_EQ(content_period, sampling_period);
+        } else {
+          ASSERT_LE(min_capture_period, sampling_period);
+
+          // Check that the sampling rate is as close (or closer) to the target
+          // sampling rate than any integer-subsampling of the content frame
+          // rate.
+          const double absolute_diff =
+              std::abs(1.0 / sampling_period.InSecondsF() - target_fps);
+          const double fudge_for_acceptable_rounding_error = 0.005;
+          for (double divisor = 1; divisor < 4; ++divisor) {
+            SCOPED_TRACE(::testing::Message() << "target_fps=" << target_fps
+                                              << ", content_fps=" << content_fps
+                                              << ", divisor=" << divisor);
+            ASSERT_GE(std::abs(content_fps / divisor - target_fps),
+                      absolute_diff - fudge_for_acceptable_rounding_error);
+          }
+        }
+      }
+    }
+  };
+
+  for (int target_fps = 1; target_fps <= 60; ++target_fps)
+    Helper::RunTargetSamplingPeriodTest(target_fps);
+}
+
 namespace {
 
 // A test scenario for AnimatedContentSamplerParameterizedTest.
 struct Scenario {
   base::TimeDelta vsync_interval;  // Reflects compositor's update rate.
   base::TimeDelta min_capture_period;  // Reflects maximum capture rate.
   base::TimeDelta content_period;  // Reflects content animation rate.
+  base::TimeDelta target_sampling_period;
 
-  Scenario(base::TimeDelta v, base::TimeDelta m, base::TimeDelta c)
-      : vsync_interval(v), min_capture_period(m), content_period(c) {
+  Scenario(int compositor_frequency,
+           int max_frame_rate,
+           int content_frame_rate)
+      : vsync_interval(FpsAsPeriod(compositor_frequency)),
+        min_capture_period(FpsAsPeriod(max_frame_rate)),
+        content_period(FpsAsPeriod(content_frame_rate)) {
     CHECK(content_period >= vsync_interval)
         << "Bad test params: Impossible to animate faster than the compositor.";
   }
+
+  Scenario(int compositor_frequency,
+           int max_frame_rate,
+           int content_frame_rate,
+           int target_sampling_rate)
+      : vsync_interval(FpsAsPeriod(compositor_frequency)),
+        min_capture_period(FpsAsPeriod(max_frame_rate)),
+        content_period(FpsAsPeriod(content_frame_rate)),
+        target_sampling_period(FpsAsPeriod(target_sampling_rate)) {
+    CHECK(content_period >= vsync_interval)
+        << "Bad test params: Impossible to animate faster than the compositor.";
+  }
 };
 
 // Value printer for Scenario.
 ::std::ostream& operator<<(::std::ostream& os, const Scenario& s) {
   return os << "{ vsync_interval=" << s.vsync_interval.InMicroseconds()
             << ", min_capture_period=" << s.min_capture_period.InMicroseconds()
             << ", content_period=" << s.content_period.InMicroseconds()
             << " }";
 }
 
-base::TimeDelta FpsAsPeriod(int frame_rate) {
-  return base::TimeDelta::FromSeconds(1) / frame_rate;
-}
-
 }  // namespace
 
 class AnimatedContentSamplerParameterizedTest
     : public AnimatedContentSamplerTest,
       public ::testing::WithParamInterface<Scenario> {
  public:
   AnimatedContentSamplerParameterizedTest()
       : count_dropped_frames_(0), count_sampled_frames_(0) {}
   virtual ~AnimatedContentSamplerParameterizedTest() {}
 
+  void SetUp() override {
+    AnimatedContentSamplerTest::SetUp();
+    sampler()->SetTargetSamplingPeriod(GetParam().target_sampling_period);
+  }
+
  protected:
   typedef std::pair<gfx::Rect, base::TimeTicks> Event;
 
   base::TimeDelta GetMinCapturePeriod() const override {
     return GetParam().min_capture_period;
   }
 
+  base::TimeDelta ComputeExpectedSamplingPeriod() const {
+    return AnimatedContentSamplerTest::ComputeSamplingPeriod(
+        GetParam().content_period,
+        GetParam().target_sampling_period,
+        GetParam().min_capture_period);
+  }
+
   // Generate a sequence of events from the compositor pipeline.  The event
   // times will all be at compositor vsync boundaries.
   std::vector<Event> GenerateEventSequence(base::TimeTicks begin,
                                            base::TimeTicks end,
                                            bool include_content_frame_events,
-                                           bool include_random_events) {
+                                           bool include_random_events,
+                                           base::TimeTicks* next_begin_time) {
     DCHECK(GetParam().content_period >= GetParam().vsync_interval);
-    base::TimeTicks next_content_time = begin - GetParam().content_period;
+    base::TimeTicks next_content_time = begin;
     std::vector<Event> events;
-    for (base::TimeTicks compositor_time = begin; compositor_time < end;
+    base::TimeTicks compositor_time;
+    for (compositor_time = begin; compositor_time < end;
          compositor_time += GetParam().vsync_interval) {
-      if (include_content_frame_events && next_content_time < compositor_time) {
-        events.push_back(Event(GetContentDamageRect(), compositor_time));
+      if (next_content_time <= compositor_time) {
         next_content_time += GetParam().content_period;
-      } else if (include_random_events && GetRandomInRange(0, 1) == 0) {
+        if (include_content_frame_events) {
+          events.push_back(Event(GetContentDamageRect(), compositor_time));
+          continue;
+        }
+      }
+      if (include_random_events && GetRandomInRange(0, 1) == 0) {
         events.push_back(Event(GetRandomDamageRect(), compositor_time));
       }
     }
 
+    if (next_begin_time) {
+      while (compositor_time < next_content_time)
+        compositor_time += GetParam().vsync_interval;
+      *next_begin_time = compositor_time;
+    }
+
     DCHECK(!events.empty());
     return events;
   }
 
   // Feed |events| through the sampler, and detect whether the expected
   // lock-in/out transition occurs.  Also, track and measure the frame drop
   // ratio and check it against the expected drop rate.
   void RunEventSequence(const std::vector<Event> events,
                         bool was_detecting_before,
                         bool is_detecting_after,
-                        bool simulate_pipeline_back_pressure) {
+                        bool simulate_pipeline_back_pressure,
+                        const char* description) {
+    SCOPED_TRACE(::testing::Message() << "Description: " << description);
+
     gfx::Rect first_detected_region;
 
     EXPECT_EQ(was_detecting_before, sampler()->HasProposal());
     bool has_detection_switched = false;
+    bool has_detection_flip_flopped_once = false;
     ResetFrameCounters();
     for (std::vector<Event>::const_iterator i = events.begin();
          i != events.end(); ++i) {
       sampler()->ConsiderPresentationEvent(i->first, i->second);
 
       // Detect when the sampler locks in/out, and that it stays that way for
-      // all further iterations of this loop.
+      // all further iterations of this loop.  It is permissible for the lock-in
+      // to flip-flop once, but no more than that.
       if (!has_detection_switched &&
           was_detecting_before != sampler()->HasProposal()) {
         has_detection_switched = true;
+      } else if (has_detection_switched &&
+                 is_detecting_after != sampler()->HasProposal()) {
+        ASSERT_FALSE(has_detection_flip_flopped_once);
+        has_detection_flip_flopped_once = true;
+        has_detection_switched = false;
       }
       ASSERT_EQ(
           has_detection_switched ? is_detecting_after : was_detecting_before,
           sampler()->HasProposal());
 
       if (sampler()->HasProposal()) {
         // Make sure the sampler doesn't flip-flop and keep proposing sampling
         // based on locking into different regions.
         if (first_detected_region.IsEmpty()) {
           first_detected_region = sampler()->detected_region();
@@ skipping 44 matching lines @@
     }
   }
 
   // Confirm the AnimatedContentSampler is not dropping more frames than
   // expected, given current test parameters.
   void ExpectFrameDropRatioIsCorrect() {
     if (count_sampled_frames_ == 0) {
       EXPECT_EQ(0, count_dropped_frames_);
       return;
     }
-    const double content_framerate =
-        1000000.0 / GetParam().content_period.InMicroseconds();
-    const double capture_framerate =
-        1000000.0 / GetParam().min_capture_period.InMicroseconds();
-    const double expected_drop_rate = std::max(
-        0.0, (content_framerate - capture_framerate) / capture_framerate);
-    const double actual_drop_rate =
-        static_cast<double>(count_dropped_frames_) / count_sampled_frames_;
-    EXPECT_NEAR(expected_drop_rate, actual_drop_rate, 0.015);
+    const double expected_sampling_ratio =
+        GetParam().content_period.InSecondsF() /
+            ComputeExpectedSamplingPeriod().InSecondsF();
+    const int total_frames = count_dropped_frames_ + count_sampled_frames_;
+    EXPECT_NEAR(total_frames * expected_sampling_ratio,
+                count_sampled_frames_,
+                1.5);
+    EXPECT_NEAR(total_frames * (1.0 - expected_sampling_ratio),
+                count_dropped_frames_,
+                1.5);
   }
 
  private:
   // These counters only include the frames with the desired content.
   int count_dropped_frames_;
   int count_sampled_frames_;
 };
 
 // Tests that the implementation locks in/out of frames containing stable
 // animated content, whether or not random events are also simultaneously
 // present.
 TEST_P(AnimatedContentSamplerParameterizedTest, DetectsAnimatedContent) {
   // |begin| refers to the start of an event sequence in terms of the
   // Compositor's clock.
   base::TimeTicks begin = InitialTestTimeTicks();
 
   // Provide random events and expect no lock-in.
-  base::TimeTicks end = begin + base::TimeDelta::FromSeconds(5);
-  RunEventSequence(GenerateEventSequence(begin, end, false, true),
-                   false,
-                   false,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(5),
+                            false,
+                            true,
+                            &begin),
+      false,
+      false,
+      false,
+      "Provide random events and expect no lock-in.");
+  if (HasFailure())
+    return;
 
   // Provide content frame events with some random events mixed-in, and expect
   // the sampler to lock-in.
-  end = begin + base::TimeDelta::FromSeconds(5);
-  RunEventSequence(GenerateEventSequence(begin, end, true, true),
-                   false,
-                   true,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(5),
+                            true,
+                            true,
+                            &begin),
+      false,
+      true,
+      false,
+      "Provide content frame events with some random events mixed-in, and "
+      "expect the sampler to lock-in.");
+  if (HasFailure())
+    return;
 
   // Continue providing content frame events without the random events mixed-in
   // and expect the lock-in to hold.
-  end = begin + base::TimeDelta::FromSeconds(5);
-  RunEventSequence(GenerateEventSequence(begin, end, true, false),
-                   true,
-                   true,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(5),
+                            true,
+                            false,
+                            &begin),
+      true,
+      true,
+      false,
+      "Continue providing content frame events without the random events "
+      "mixed-in and expect the lock-in to hold.");
+  if (HasFailure())
+    return;
 
   // Continue providing just content frame events and expect the lock-in to
   // hold.  Also simulate the capture pipeline experiencing back pressure.
-  end = begin + base::TimeDelta::FromSeconds(20);
-  RunEventSequence(GenerateEventSequence(begin, end, true, false),
-                   true,
-                   true,
-                   true);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(20),
+                            true,
+                            false,
+                            &begin),
+      true,
+      true,
+      true,
+      "Continue providing just content frame events and expect the lock-in to "
+      "hold.  Also simulate the capture pipeline experiencing back pressure.");
+  if (HasFailure())
+    return;
+
 
   // Provide a half-second of random events only, and expect the lock-in to be
   // broken.
-  end = begin + base::TimeDelta::FromMilliseconds(500);
-  RunEventSequence(GenerateEventSequence(begin, end, false, true),
-                   true,
-                   false,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromMilliseconds(500),
+                            false,
+                            true,
+                            &begin),
+      true,
+      false,
+      false,
+      "Provide a half-second of random events only, and expect the lock-in to "
+      "be broken.");
+  if (HasFailure())
+    return;
 
   // Now, go back to providing content frame events, and expect the sampler to
   // lock-in once again.
-  end = begin + base::TimeDelta::FromSeconds(5);
-  RunEventSequence(GenerateEventSequence(begin, end, true, false),
-                   false,
-                   true,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(5),
+                            true,
+                            false,
+                            &begin),
+      false,
+      true,
+      false,
+      "Now, go back to providing content frame events, and expect the sampler "
+      "to lock-in once again.");
 }
 
 // Tests that AnimatedContentSampler won't lock in to, nor flip-flop between,
 // two animations of the same pixel change rate.  VideoCaptureOracle should
 // revert to using the SmoothEventSampler for these kinds of situations, as
 // there is no "right answer" as to which animation to lock into.
 TEST_P(AnimatedContentSamplerParameterizedTest,
        DoesNotLockInToTwoCompetingAnimations) {
   // Don't test when the event stream cannot indicate two separate content
   // animations under the current test parameters.
   if (GetParam().content_period < 2 * GetParam().vsync_interval)
     return;
 
   // Start the first animation and run for a bit, and expect the sampler to
   // lock-in.
   base::TimeTicks begin = InitialTestTimeTicks();
-  base::TimeTicks end = begin + base::TimeDelta::FromSeconds(5);
-  RunEventSequence(GenerateEventSequence(begin, end, true, false),
-                   false,
-                   true,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(5),
+                            true,
+                            false,
+                            &begin),
+      false,
+      true,
+      false,
+      "Start the first animation and run for a bit, and expect the sampler to "
+      "lock-in.");
+  if (HasFailure())
+    return;
 
-  // Now, keep the first animation and blend in an second animation of the same
+  // Now, keep the first animation and blend in a second animation of the same
   // size and frame rate, but at a different position.  This will should cause
   // the sampler to enter an "undetected" state since it's unclear which
   // animation should be locked into.
-  end = begin + base::TimeDelta::FromSeconds(20);
   std::vector<Event> first_animation_events =
-      GenerateEventSequence(begin, end, true, false);
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(20),
+                            true,
+                            false,
+                            &begin);
   gfx::Rect second_animation_rect(
       gfx::Point(0, GetContentDamageRect().height()),
       GetContentDamageRect().size());
   std::vector<Event> both_animations_events;
   base::TimeDelta second_animation_offset = GetParam().vsync_interval;
   for (std::vector<Event>::const_iterator i = first_animation_events.begin();
        i != first_animation_events.end(); ++i) {
     both_animations_events.push_back(*i);
     both_animations_events.push_back(
         Event(second_animation_rect, i->second + second_animation_offset));
   }
-  RunEventSequence(both_animations_events, true, false, false);
-  begin = end;
+  RunEventSequence(
+      both_animations_events, true, false, false,
+      "Now, blend-in a second animation of the same size and frame rate, but "
+      "at a different position.");
+  if (HasFailure())
+    return;
 
   // Now, run just the first animation, and expect the sampler to lock-in once
   // again.
-  end = begin + base::TimeDelta::FromSeconds(5);
-  RunEventSequence(GenerateEventSequence(begin, end, true, false),
-                   false,
-                   true,
-                   false);
-  begin = end;
+  RunEventSequence(
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(5),
+                            true,
+                            false,
+                            &begin),
+      false,
+      true,
+      false,
+      "Now, run just the first animation, and expect the sampler to lock-in "
+      "once again.");
+  if (HasFailure())
+    return;
 
   // Now, blend in the second animation again, but it has half the frame rate of
   // the first animation and damage Rects with twice the area.  This will should
   // cause the sampler to enter an "undetected" state again.  This tests that
   // pixel-weighting is being accounted for in the sampler's logic.
-  end = begin + base::TimeDelta::FromSeconds(20);
-  first_animation_events = GenerateEventSequence(begin, end, true, false);
+  first_animation_events =
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromSeconds(20),
+                            true,
+                            false,
+                            &begin);
   second_animation_rect.set_width(second_animation_rect.width() * 2);
   both_animations_events.clear();
   bool include_second_animation_frame = true;
   for (std::vector<Event>::const_iterator i = first_animation_events.begin();
        i != first_animation_events.end(); ++i) {
     both_animations_events.push_back(*i);
     if (include_second_animation_frame) {
       both_animations_events.push_back(
           Event(second_animation_rect, i->second + second_animation_offset));
     }
     include_second_animation_frame = !include_second_animation_frame;
   }
-  RunEventSequence(both_animations_events, true, false, false);
-  begin = end;
+  RunEventSequence(
+      both_animations_events, true, false, false,
+      "Now, blend in the second animation again, but it has half the frame "
+      "rate of the first animation and damage Rects with twice the area.");
 }
 
 // Tests that the frame timestamps are smooth; meaning, that when run through a
 // simulated compositor, each frame is held displayed for the right number of
 // v-sync intervals.
 TEST_P(AnimatedContentSamplerParameterizedTest, FrameTimestampsAreSmooth) {
   // Generate 30 seconds of animated content events, run the events through
   // AnimatedContentSampler, and record all frame timestamps being proposed
   // once lock-in is continuous.
-  base::TimeTicks begin = InitialTestTimeTicks();
+  const base::TimeTicks begin = InitialTestTimeTicks();
   std::vector<Event> events = GenerateEventSequence(
       begin,
       begin + base::TimeDelta::FromSeconds(20),
       true,
-      false);
+      false,
+      nullptr);
   typedef std::vector<base::TimeTicks> Timestamps;
   Timestamps frame_timestamps;
   for (std::vector<Event>::const_iterator i = events.begin(); i != events.end();
        ++i) {
     sampler()->ConsiderPresentationEvent(i->first, i->second);
     if (sampler()->HasProposal()) {
       if (sampler()->ShouldSample()) {
         frame_timestamps.push_back(sampler()->frame_timestamp());
         sampler()->RecordSample(sampler()->frame_timestamp());
       }
     } else {
       frame_timestamps.clear();  // Reset until continuous lock-in.
     }
   }
   ASSERT_LE(2u, frame_timestamps.size());
 
   // Iterate through the |frame_timestamps|, building a histogram counting the
   // number of times each frame was displayed k times.  For example, 10 frames
   // of 30 Hz content on a 60 Hz v-sync interval should result in
   // display_counts[2] == 10.  Quit early if any one frame was obviously
   // repeated too many times.
   const int64 max_expected_repeats_per_frame = 1 +
-      std::max(GetParam().min_capture_period, GetParam().content_period) /
-          GetParam().vsync_interval;
+      ComputeExpectedSamplingPeriod() / GetParam().vsync_interval;
   std::vector<size_t> display_counts(max_expected_repeats_per_frame + 1, 0);
   base::TimeTicks last_present_time = frame_timestamps.front();
   for (Timestamps::const_iterator i = frame_timestamps.begin() + 1;
        i != frame_timestamps.end(); ++i) {
     const size_t num_vsync_intervals = static_cast<size_t>(
         (*i - last_present_time) / GetParam().vsync_interval);
     ASSERT_LT(0u, num_vsync_intervals);
     ASSERT_GT(display_counts.size(), num_vsync_intervals);  // Quit early.
     ++display_counts[num_vsync_intervals];
     last_present_time += num_vsync_intervals * GetParam().vsync_interval;
@@ skipping 18 matching lines @@
     }
   }
   size_t stray_count_remaining =
       (frame_timestamps.size() - 1) - (highest_count + second_highest_count);
   // Expect no more than 0.75% of frames fall outside the two main buckets.
   EXPECT_GT(frame_timestamps.size() * 75 / 10000, stray_count_remaining);
   for (size_t repeats = 1; repeats < display_counts.size() - 1; ++repeats) {
     if (display_counts[repeats] == highest_count) {
       EXPECT_EQ(second_highest_count, display_counts[repeats + 1]);
       ++repeats;
-    } else if (display_counts[repeats] == second_highest_count) {
+    } else if (second_highest_count > 0 &&
+               display_counts[repeats] == second_highest_count) {
       EXPECT_EQ(highest_count, display_counts[repeats + 1]);
       ++repeats;
     } else {
       EXPECT_GE(stray_count_remaining, display_counts[repeats]);
       stray_count_remaining -= display_counts[repeats];
     }
   }
 }
 
 // Tests that frame timestamps are "lightly pushed" back towards the original
 // presentation event times, which tells us the AnimatedContentSampler can
 // account for sources of timestamp drift and correct the drift.
 TEST_P(AnimatedContentSamplerParameterizedTest,
        FrameTimestampsConvergeTowardsEventTimes) {
   const int max_drift_increment_millis = 3;
 
   // Generate a full minute of events.
   const base::TimeTicks begin = InitialTestTimeTicks();
-  const base::TimeTicks end = begin + base::TimeDelta::FromMinutes(1);
-  std::vector<Event> events = GenerateEventSequence(begin, end, true, false);
+  std::vector<Event> events =
+      GenerateEventSequence(begin,
+                            begin + base::TimeDelta::FromMinutes(1),
+                            true,
+                            false,
+                            nullptr);
 
   // Modify the event sequence so that 1-3 ms of additional drift is suddenly
   // present every 100 events.  This is meant to simulate that, external to
   // AnimatedContentSampler, the video hardware vsync timebase is being
   // refreshed and is showing severe drift from the system clock.
   base::TimeDelta accumulated_drift;
   for (size_t i = 1; i < events.size(); ++i) {
     if (i % 100 == 0) {
       accumulated_drift += base::TimeDelta::FromMilliseconds(
           GetRandomInRange(1, max_drift_increment_millis + 1));
@@ skipping 21 matching lines @@
               total_error.InMicroseconds(),
               max_acceptable_error.InMicroseconds());
 }
 
 INSTANTIATE_TEST_CASE_P(
     ,
     AnimatedContentSamplerParameterizedTest,
     ::testing::Values(
          // Typical frame rate content: Compositor runs at 60 Hz, capture at 30
          // Hz, and content video animates at 30, 25, or 24 Hz.
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(30)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(25)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(24)),
+         Scenario(60, 30, 30),
+         Scenario(60, 30, 25),
+         Scenario(60, 30, 24),
 
          // High frame rate content that leverages the Compositor's
          // capabilities, but capture is still at 30 Hz.
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(60)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(50)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(48)),
+         Scenario(60, 30, 60),
+         Scenario(60, 30, 50),
+         Scenario(60, 30, 48),
 
          // High frame rate content that leverages the Compositor's
          // capabilities, and capture is also a buttery 60 Hz.
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(60), FpsAsPeriod(60)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(60), FpsAsPeriod(50)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(60), FpsAsPeriod(48)),
+         Scenario(60, 60, 60),
+         Scenario(60, 60, 50),
+         Scenario(60, 60, 48),
+
+         // High frame rate content that leverages the Compositor's
+         // capabilities, but the client has disabled HFR sampling.
+         Scenario(60, 60, 60, 30),
+         Scenario(60, 60, 50, 30),
+         Scenario(60, 60, 48, 30),
 
          // On some platforms, the Compositor runs at 50 Hz.
-         Scenario(FpsAsPeriod(50), FpsAsPeriod(30), FpsAsPeriod(30)),
-         Scenario(FpsAsPeriod(50), FpsAsPeriod(30), FpsAsPeriod(25)),
-         Scenario(FpsAsPeriod(50), FpsAsPeriod(30), FpsAsPeriod(24)),
-         Scenario(FpsAsPeriod(50), FpsAsPeriod(30), FpsAsPeriod(50)),
-         Scenario(FpsAsPeriod(50), FpsAsPeriod(30), FpsAsPeriod(48)),
+         Scenario(50, 30, 30),
+         Scenario(50, 30, 25),
+         Scenario(50, 30, 24),
+         Scenario(50, 30, 50),
+         Scenario(50, 30, 48),
 
          // Stable, but non-standard content frame rates.
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(16)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(20)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(23)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(26)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(27)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(28)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(29)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(31)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(32)),
-         Scenario(FpsAsPeriod(60), FpsAsPeriod(30), FpsAsPeriod(33))));
+         Scenario(60, 30, 16),
+         Scenario(60, 30, 20),
+         Scenario(60, 30, 23),
+         Scenario(60, 30, 26),
+         Scenario(60, 30, 27),
+         Scenario(60, 30, 28),
+         Scenario(60, 30, 29),
+         Scenario(60, 30, 31),
+         Scenario(60, 30, 32),
+         Scenario(60, 30, 33)));
 
 }  // namespace content