cc: Heuristic for Renderer latency recovery

cc/test/scheduler_test_common.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/test/scheduler_test_common.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
@@ skipping 65 matching lines @@
 FakeCompositorTimingHistory::FakeCompositorTimingHistory(
     scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation)
     : CompositorTimingHistory(rendering_stats_instrumentation.get()),
       rendering_stats_instrumentation_owned_(
           rendering_stats_instrumentation.Pass()) {
 }
 
 FakeCompositorTimingHistory::~FakeCompositorTimingHistory() {
 }
 
+void FakeCompositorTimingHistory::SetAllEstimatesTo(base::TimeDelta duration) {
+  begin_main_frame_to_commit_duration_ = duration;
+  commit_to_ready_to_activate_duration_ = duration;
+  prepare_tiles_duration_ = duration;
+  activate_duration_ = duration;
+  draw_duration_ = duration;
+}
+
 void FakeCompositorTimingHistory::SetBeginMainFrameToCommitDurationEstimate(
     base::TimeDelta duration) {
   begin_main_frame_to_commit_duration_ = duration;
 }
 
 void FakeCompositorTimingHistory::SetCommitToReadyToActivateDurationEstimate(
     base::TimeDelta duration) {
   commit_to_ready_to_activate_duration_ = duration;
 }
 
@@ skipping 67 matching lines @@
     scoped_ptr<TestBackToBackBeginFrameSource> unthrottled_frame_source,
     scoped_ptr<CompositorTimingHistory> compositor_timing_history)
     : Scheduler(client,
                 scheduler_settings,
                 layer_tree_host_id,
                 task_runner,
                 external_frame_source,
                 synthetic_frame_source.Pass(),
                 unthrottled_frame_source.Pass(),
                 compositor_timing_history.Pass()),
-      now_src_(now_src) {
+      now_src_(now_src),
+      was_swap_throttled_at_last_begin_frame_(false) {
 }
 
 base::TimeTicks TestScheduler::Now() const {
   return now_src_->NowTicks();
 }
 
+void TestScheduler::BeginImplFrameWithDeadline(const BeginFrameArgs& args) {
+  was_swap_throttled_at_last_begin_frame_ = state_machine_.SwapThrottled();

[sunnyps, 2015/07/09 23:44:30]

I think a better way to do this is to hook up
FakeSchedulerClient::WillBeginImplFrame (or SchedulerTest::SendNextBeginFrame)
to just record this in the test.

[brianderson, 2015/07/10 00:34:08]

I wanted to use FakeSchedulerClient::WillBeginImplFrame initially, but when we
skip the ImplFrame, we never get the WillBeginImplFrame. This approach would
have worked with the original patch set that skipped the swap rather than the
BeginImplFrame, but it's a lot cleaner everywhere else to skip the
BeginImplFrame altogether.

Using SchedulerTest::SendNextBeginFrame will work for all cases except
RetroFrames - but we don't need this method with RetroFrames for all existing
tests - and RetroFrames will probably go away soon anyway. In this case, I can
just check IsSwapThrottled directly in the tests before calling
SendNextBeginFrame, so it's more direct.

+  Scheduler::BeginImplFrameWithDeadline(args);
+}
+
 TestScheduler::~TestScheduler() {
 }
 
 }  // namespace cc