Use message passing for BeginFrameAndCommitState and clean up forced commit logic

cc/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 "config.h"
 
 #include "cc/scheduler_state_machine.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 10 matching lines @@
 
 // Exposes the protected state fields of the SchedulerStateMachine for testing
 class StateMachine : public SchedulerStateMachine {
 public:
     void setCommitState(CommitState cs) { m_commitState = cs; }
     CommitState commitState() const { return  m_commitState; }
 
     void setNeedsCommit(bool b) { m_needsCommit = b; }
     bool needsCommit() const { return m_needsCommit; }
 
-    void setNeedsForcedCommit(bool b) { m_needsForcedCommit = b; }
-    bool needsForcedCommit() const { return m_needsForcedCommit; }
-
     void setNeedsRedraw(bool b) { m_needsRedraw = b; }
     bool needsRedraw() const { return m_needsRedraw; }
 
     void setNeedsForcedRedraw(bool b) { m_needsForcedRedraw = b; }
     bool needsForcedRedraw() const { return m_needsForcedRedraw; }
 
     bool canDraw() const { return m_canDraw; }
     bool insideVSync() const { return m_insideVSync; }
     bool visible() const { return m_visible; }
 };
@@ skipping 775 matching lines @@
     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
     state.didLeaveVSync();
 }
 
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenInvisibleAndForceCommit)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(false);
     state.setNeedsCommit(true);
-    state.setNeedsForcedCommit(true);
+    state.setNeedsForcedCommit();
     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenCanBeginFrameFalseAndForceCommit)
 {
     StateMachine state;
     state.setVisible(true);
     state.setCanDraw(true);
     state.setNeedsCommit(true);
-    state.setNeedsForcedCommit(true);
+    state.setNeedsForcedCommit();
     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenCommitInProgress)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(false);
     state.setCommitState(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS);
     state.setNeedsCommit(true);
-    state.setNeedsForcedCommit(true);
+    state.setNeedsForcedCommit();
 
     state.beginFrameComplete();
     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(state.nextAction());
 
     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 
     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(SchedulerStateMachineTest, TestBeginFrameWhenContextLost)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
     state.setCanDraw(true);
     state.setNeedsCommit(true);
-    state.setNeedsForcedCommit(true);
+    state.setNeedsForcedCommit();
     state.didLoseContext();
     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
+TEST(SchedulerStateMachineTest, TestImmediateBeginFrame)
+{
+    StateMachine state;
+    state.setCanBeginFrame(true);
+    state.setVisible(true);
+    state.setCanDraw(true);
+
+    // Schedule a forced frame, commit it, draw it.
+    state.setNeedsCommit(true);
+    state.setNeedsForcedCommit();
+    state.updateState(state.nextAction());
+    state.beginFrameComplete();
+    EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
+    EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
+    state.updateState(state.nextAction());
+
+    state.didEnterVSync();
+    EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
+    state.updateState(state.nextAction());
+    state.didDrawIfPossibleCompleted(true);
+    state.didLeaveVSync();
+
+    // Should be waiting for the normal begin frame
+    EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 }
+
+TEST(SchedulerStateMachineTest, TestImmediateBeginFrameDuringCommit)
+{
+    StateMachine state;
+    state.setCanBeginFrame(true);
+    state.setVisible(true);
+    state.setCanDraw(true);
+
+    // Start a normal commit.
+    state.setNeedsCommit(true);
+    state.updateState(state.nextAction());
+
+    // Schedule a forced frame, commit it, draw it.
+    state.setNeedsCommit(true);
+    state.setNeedsForcedCommit();
+    state.updateState(state.nextAction());
+    state.beginFrameComplete();
+    EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
+    EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
+    state.updateState(state.nextAction());
+
+    state.didEnterVSync();
+    EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
+    state.updateState(state.nextAction());
+    state.didDrawIfPossibleCompleted(true);
+    state.didLeaveVSync();
+
+    // Should be waiting for the normal begin frame
+    EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState()) << state.toString();
+}
+
+
+}