Trigger deadline immediately after an aborted main thread commit

cc/scheduler/scheduler_state_machine_unittest.cc

 // Copyright 2011 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/scheduler/scheduler_state_machine.h"
 
 #include "cc/scheduler/scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define EXPECT_ACTION_UPDATE_STATE(action)                                 \
@@ skipping 53 matching lines @@
 
   BeginFrameState begin_frame_state() const { return begin_frame_state_; }
 
   OutputSurfaceState output_surface_state() const {
     return output_surface_state_;
   }
 
   bool NeedsCommit() const { return needs_commit_; }
 
   void SetNeedsRedraw(bool b) { needs_redraw_ = b; }
-  bool NeedsRedraw() const { return needs_redraw_; }
 
   void SetNeedsForcedRedrawForTimeout(bool b) {
     forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
     commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
   }
   bool NeedsForcedRedrawForTimeout() const {
     return forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE;
   }
 
   void SetNeedsForcedRedrawForReadback() {
@@ skipping 572 matching lines @@
 
   // Tell the scheduler the frame finished.
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
 
   // Commit.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
-  EXPECT_TRUE(state.NeedsRedraw());
+  EXPECT_TRUE(state.needs_redraw());
 
   // Expect to do nothing until BeginFrame deadline
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // At BeginFrame deadline, draw.
   state.OnBeginFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
   state.DidDrawIfPossibleCompleted(true);
 
   // Should be synchronized, no draw needed, no action needed.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
-  EXPECT_FALSE(state.NeedsRedraw());
+  EXPECT_FALSE(state.needs_redraw());
 }
 
 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
   state.UpdateState(state.NextAction());
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetVisible(true);
   state.SetCanDraw(true);
@@ skipping 16 matching lines @@
 
   // Tell the scheduler the frame finished.
   state.FinishCommit();
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
             state.CommitState());
 
   // First commit.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
             state.CommitState());
-  EXPECT_TRUE(state.NeedsRedraw());
+  EXPECT_TRUE(state.needs_redraw());
 
   // Expect to do nothing until BeginFrame deadline.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // At BeginFrame deadline, draw.
   state.OnBeginFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
   state.DidDrawIfPossibleCompleted(true);
 
   // Should be synchronized, no draw needed, no action needed.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
-  EXPECT_FALSE(state.NeedsRedraw());
+  EXPECT_FALSE(state.needs_redraw());
 
   // Next BeginFrame should initiate second commit.
   state.OnBeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD);
 }
 
 TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
@@ skipping 864 matching lines @@
   EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   state.BeginFrameAbortedByMainThread(true);
 
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   EXPECT_FALSE(state.PendingDrawsShouldBeAborted());
 }
 
+TEST(SchedulerStateMachineTest,
+    TestTriggerDeadlineEarlyAfterAbortedCommit) {
+  SchedulerSettings settings;
+  settings.deadline_scheduling_enabled = true;
+  settings.impl_side_painting = true;
+  StateMachine state(settings);
+  state.SetCanStart();
+  state.UpdateState(state.NextAction());
+  state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+  state.SetVisible(true);
+  state.SetCanDraw(true);
+
+  // This test mirrors what happens during the first frame of a scroll gesture.
+  // First we get the input event and a BeginFrame.
+  state.OnBeginFrame(BeginFrameArgs::CreateForTesting());
+
+  // As a response the compositor requests a redraw and a commit to tell the
+  // main thread about the new scroll offset.
+  state.SetNeedsRedraw(true);
+  state.SetNeedsCommit();
+
+  // We should start the commit normally.
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+  // Since only the scroll offset changed, the main thread will abort the
+  // commit.
+  state.BeginFrameAbortedByMainThread(true);
+
+  // Since the commit was aborted, we should draw right away instead of waiting
+  // for the deadline.
+  EXPECT_TRUE(state.ShouldTriggerBeginFrameDeadlineEarly());
+}
+
 }  // namespace
 }  // namespace cc