cc: Remove awareness of incremental updates from state machine.

cc/CCSchedulerStateMachineTest.cpp

 // 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 "CCSchedulerStateMachine.h"
 
 #include <gtest/gtest.h>
 
@@ skipping 25 matching lines @@
     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; }
 
-    void setUpdateMoreResourcesPending(bool b) { m_updateMoreResourcesPending = b; }
-    bool updateMoreResourcesPending() const { return m_updateMoreResourcesPending; }
+    void setUpdateResourcesCompletePending(bool b) { m_updateResourcesCompletePending = b; }
+    bool updateResourcesCompletePending() const { return m_updateResourcesCompletePending; }
 };
 
 TEST(CCSchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded)
 {
     // If no commit needed, do nothing
     {
         StateMachine state;
         state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_IDLE);
         state.setCanBeginFrame(true);
         state.setNeedsRedraw(false);
         state.setNeedsCommit(false);
-        state.setUpdateMoreResourcesPending(false);
+        state.setUpdateResourcesCompletePending(false);
         state.setVisible(true);
 
         EXPECT_FALSE(state.vsyncCallbackNeeded());
 
         state.didLeaveVSync();
         EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
         EXPECT_FALSE(state.vsyncCallbackNeeded());
         state.didEnterVSync();
         EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     }
 
     // If commit requested but canBeginFrame is still false, do nothing.
     {
         StateMachine state;
         state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_IDLE);
         state.setNeedsRedraw(false);
         state.setNeedsCommit(false);
-        state.setUpdateMoreResourcesPending(false);
+        state.setUpdateResourcesCompletePending(false);
         state.setVisible(true);
 
         EXPECT_FALSE(state.vsyncCallbackNeeded());
 
         state.didLeaveVSync();
         EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
         EXPECT_FALSE(state.vsyncCallbackNeeded());
         state.didEnterVSync();
         EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     }
 
 
     // If commit requested, begin a frame
     {
         StateMachine state;
         state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_IDLE);
         state.setCanBeginFrame(true);
         state.setNeedsRedraw(false);
         state.setNeedsCommit(true);
-        state.setUpdateMoreResourcesPending(false);
+        state.setUpdateResourcesCompletePending(false);
         state.setVisible(true);
         EXPECT_FALSE(state.vsyncCallbackNeeded());
     }
 
     // Begin the frame, make sure needsCommit and commitState update correctly.
     {
         StateMachine state;
         state.setCanBeginFrame(true);
         state.setVisible(true);
         state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
@@ skipping 89 matching lines @@
 
     // Fail the draw.
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     state.didDrawIfPossibleCompleted(false);
     EXPECT_TRUE(state.redrawPending());
     // But the commit is ongoing.
     EXPECT_TRUE(state.commitPending());
 
     // Finish the commit.
-    state.beginFrameComplete();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.beginUpdateMoreResourcesComplete(false);
+    state.beginFrameComplete(true);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_COMMIT);
     EXPECT_TRUE(state.redrawPending());
 
     // And we should be allowed to draw again.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestCommitAfterFailedAndSuccessfulDrawDoesNotAllowDrawInSameFrame)
 {
@@ skipping 28 matching lines @@
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 
     // Do the forced draw.
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_FORCED);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     EXPECT_FALSE(state.redrawPending());
     // And the commit is still ongoing.
     EXPECT_TRUE(state.commitPending());
 
     // Finish the commit.
-    state.beginFrameComplete();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.beginUpdateMoreResourcesComplete(false);
+    state.beginFrameComplete(true);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_COMMIT);
     EXPECT_TRUE(state.redrawPending());
 
     // And we should not be allowed to draw again in the same frame..
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFailedDrawsWillEventuallyForceADrawAfterTheNextCommit)
 {
@@ skipping 19 matching lines @@
     // Fail the draw.
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     state.didDrawIfPossibleCompleted(false);
     EXPECT_TRUE(state.redrawPending());
     // But the commit is ongoing.
     EXPECT_TRUE(state.commitPending());
 
     // Finish the commit. Note, we should not yet be forcing a draw, but should
     // continue the commit as usual.
-    state.beginFrameComplete();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.beginUpdateMoreResourcesComplete(false);
+    state.beginFrameComplete(true);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_COMMIT);
     EXPECT_TRUE(state.redrawPending());
 
     // The redraw should be forced in this case.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFailedDrawIsRetriedNextVSync)
 {
@@ skipping 94 matching lines @@
                 state.setNeedsForcedRedraw(true);
 
             CCSchedulerStateMachine::Action expectedAction;
             if (allCommitStates[i] != CCSchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT)
                 expectedAction = forcedDraw ? CCSchedulerStateMachine::ACTION_DRAW_FORCED : CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE;
             else
                 expectedAction = CCSchedulerStateMachine::ACTION_COMMIT;
 
             // Case 1: needsCommit=false updateMoreResourcesPending=false.
             state.setNeedsCommit(false);
-            state.setUpdateMoreResourcesPending(false);
+            state.setUpdateResourcesCompletePending(false);
             EXPECT_TRUE(state.vsyncCallbackNeeded());
             EXPECT_EQ(expectedAction, state.nextAction());
 
             // Case 2: needsCommit=false updateMoreResourcesPending=true.
             state.setNeedsCommit(false);
-            state.setUpdateMoreResourcesPending(true);
+            state.setUpdateResourcesCompletePending(true);
             EXPECT_TRUE(state.vsyncCallbackNeeded());
             EXPECT_EQ(expectedAction, state.nextAction());
 
             // Case 3: needsCommit=true updateMoreResourcesPending=false.
             state.setNeedsCommit(true);
-            state.setUpdateMoreResourcesPending(false);
+            state.setUpdateResourcesCompletePending(false);
             EXPECT_TRUE(state.vsyncCallbackNeeded());
             EXPECT_EQ(expectedAction, state.nextAction());
 
             // Case 4: needsCommit=true updateMoreResourcesPending=true.
             state.setNeedsCommit(true);
-            state.setUpdateMoreResourcesPending(true);
+            state.setUpdateResourcesCompletePending(true);
             EXPECT_TRUE(state.vsyncCallbackNeeded());
             EXPECT_EQ(expectedAction, state.nextAction());
         }
     }
 }
 
 TEST(CCSchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible)
 {
     size_t numCommitStates = sizeof(allCommitStates) / sizeof(CCSchedulerStateMachine::CommitState);
     for (size_t i = 0; i < numCommitStates; ++i) {
         // There shouldn't be any drawing regardless of vsync.
         for (unsigned j = 0; j < 2; ++j) {
             StateMachine state;
             state.setCommitState(allCommitStates[i]);
             state.setVisible(false);
             state.setNeedsRedraw(true);
             state.setNeedsForcedRedraw(false);
             if (j == 1)
                 state.didEnterVSync();
 
             // Case 1: needsCommit=false updateMoreResourcesPending=false.
             state.setNeedsCommit(false);
-            state.setUpdateMoreResourcesPending(false);
+            state.setUpdateResourcesCompletePending(false);
             EXPECT_NE(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 
             // Case 2: needsCommit=false updateMoreResourcesPending=true.
             state.setNeedsCommit(false);
-            state.setUpdateMoreResourcesPending(true);
+            state.setUpdateResourcesCompletePending(true);
             EXPECT_NE(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 
             // Case 3: needsCommit=true updateMoreResourcesPending=false.
             state.setNeedsCommit(true);
-            state.setUpdateMoreResourcesPending(false);
+            state.setUpdateResourcesCompletePending(false);
             EXPECT_NE(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 
             // Case 4: needsCommit=true updateMoreResourcesPending=true.
             state.setNeedsCommit(true);
-            state.setUpdateMoreResourcesPending(true);
+            state.setUpdateResourcesCompletePending(true);
             EXPECT_NE(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
         }
     }
 }
 
 TEST(CCSchedulerStateMachineTest, TestCanRedraw_StopsDraw)
 {
     size_t numCommitStates = sizeof(allCommitStates) / sizeof(CCSchedulerStateMachine::CommitState);
     for (size_t i = 0; i < numCommitStates; ++i) {
         // There shouldn't be any drawing regardless of vsync.
@@ skipping 12 matching lines @@
     }
 }
 
 TEST(CCSchedulerStateMachineTest, TestCanRedrawWithWaitingForFirstDrawMakesProgress)
 {
     StateMachine state;
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
     state.setCanBeginFrame(true);
     state.setNeedsCommit(true);
     state.setNeedsRedraw(true);
-    state.setUpdateMoreResourcesPending(false);
+    state.setUpdateResourcesCompletePending(false);
     state.setVisible(true);
     state.setCanDraw(false);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestVsyncCallbackNeededOnCanDrawAndResourceUpdates)
 {
     StateMachine state;
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
     state.setCanBeginFrame(true);
     state.setNeedsCommit(true);
     state.setNeedsRedraw(true);
-    state.setUpdateMoreResourcesPending(false);
+    state.setUpdateResourcesCompletePending(false);
     state.setVisible(true);
     state.setCanDraw(false);
     EXPECT_FALSE(state.vsyncCallbackNeeded());
 
-    state.setUpdateMoreResourcesPending(true);
+    state.setUpdateResourcesCompletePending(true);
     EXPECT_TRUE(state.vsyncCallbackNeeded());
 
-    state.setUpdateMoreResourcesPending(false);
+    state.setUpdateResourcesCompletePending(false);
     EXPECT_FALSE(state.vsyncCallbackNeeded());
 
     state.setCanDraw(true);
     EXPECT_TRUE(state.vsyncCallbackNeeded());
 }
 
 TEST(CCSchedulerStateMachineTest, TestUpdates_NoRedraw_OneRoundOfUpdates)
 {
     StateMachine state;
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES);
     state.setNeedsRedraw(false);
-    state.setUpdateMoreResourcesPending(false);
+    state.setUpdateResourcesCompletePending(false);
     state.setVisible(true);
     state.setCanDraw(true);
 
     // Verify we begin update, both for vsync and not vsync.
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
     state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
 
     // Begin an update.
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
 
     // Verify we don't do anything, both for vsync and not vsync.
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // End update with no more updates pending.
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateResourcesComplete();
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 }
 
-TEST(CCSchedulerStateMachineTest, TestUpdates_NoRedraw_TwoRoundsOfUpdates)
-{
-    StateMachine state;
-    state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES);
-    state.setNeedsRedraw(false);
-    state.setUpdateMoreResourcesPending(false);
-    state.setVisible(true);
-    state.setCanDraw(true);
-
-    // Verify the update begins, both for vsync and not vsync.
-    state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.didLeaveVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-
-    // Begin an update.
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-
-    // Verify we do nothing, both for vsync and not vsync.
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
-    state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
-
-    // Ack the update with more pending.
-    state.beginUpdateMoreResourcesComplete(true);
-
-    // Verify we update more, both for vsync and not vsync.
-    state.didLeaveVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-
-    // Begin another update, while inside vsync. And, it updating.
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.beginUpdateMoreResourcesComplete(false);
-
-    // Make sure we commit, independent of vsync.
-    state.didLeaveVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
-    state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
-}
-
-
 TEST(CCSchedulerStateMachineTest, TestVSyncNeededWhenUpdatesPendingButInvisible)
 {
     StateMachine state;
     state.setCanDraw(true);
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES);
     state.setNeedsRedraw(false);
     state.setVisible(false);
-    state.setUpdateMoreResourcesPending(true);
+    state.setUpdateResourcesCompletePending(true);
     EXPECT_TRUE(state.vsyncCallbackNeeded());
 
-    state.setUpdateMoreResourcesPending(false);
+    state.setUpdateResourcesCompletePending(false);
     EXPECT_TRUE(state.vsyncCallbackNeeded());
 }
 
 TEST(CCSchedulerStateMachineTest, TestUpdates_WithRedraw_OneRoundOfUpdates)
 {
     StateMachine state;
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES);
     state.setNeedsRedraw(true);
-    state.setUpdateMoreResourcesPending(false);
+    state.setUpdateResourcesCompletePending(false);
     state.setVisible(true);
     state.setCanDraw(true);
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
 
     // Begin an update.
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
 
     // Ensure we draw on the next vsync even though an update is in-progress.
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
     state.didDrawIfPossibleCompleted(true);
 
     // Ensure that we once we have drawn, we dont do anything else.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Leave the vsync before we finish the update.
     state.didLeaveVSync();
-
-    // Finish update but leave more resources pending.
-    state.beginUpdateMoreResourcesComplete(true);
-
-    // Verify that regardless of vsync, we update some more.
-    state.didLeaveVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.didEnterVSync();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-
-    // Begin another update. Finish it immediately. Inside the vsync.
-    state.didEnterVSync();
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.didLeaveVSync();
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateResourcesComplete();
 
     // Verify we commit regardless of vsync state
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestSetNeedsCommitIsNotLost)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setNeedsCommit(true);
     state.setVisible(true);
     state.setCanDraw(true);
 
     // Begin the frame.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(state.nextAction());
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 
     // Now, while the frame is in progress, set another commit.
     state.setNeedsCommit(true);
     EXPECT_TRUE(state.needsCommit());
 
     // Let the frame finish.
-    state.beginFrameComplete();
+    state.beginFrameComplete(true);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES, state.commitState());
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 
     // Expect to commit regardless of vsync state.
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 
     // Commit and make sure we draw on next vsync
     state.updateState(CCSchedulerStateMachine::ACTION_COMMIT);
@@ skipping 18 matching lines @@
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 
     // Begin the frame.
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
     EXPECT_FALSE(state.needsCommit());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Tell the scheduler the frame finished.
-    state.beginFrameComplete();
+    state.beginFrameComplete(true);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES, state.commitState());
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
 
     // Tell the scheduler the update began and finished
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 
     // Commit.
     state.updateState(CCSchedulerStateMachine::ACTION_COMMIT);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
     EXPECT_TRUE(state.needsRedraw());
 
     // Expect to do nothing until vsync.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
@@ skipping 26 matching lines @@
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
     EXPECT_FALSE(state.needsCommit());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Request another commit while the commit is in flight.
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Tell the scheduler the frame finished.
-    state.beginFrameComplete();
+    state.beginFrameComplete(true);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_UPDATING_RESOURCES, state.commitState());
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
 
     // Tell the scheduler the update began and finished
-    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES);
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 
     // Commit.
     state.updateState(CCSchedulerStateMachine::ACTION_COMMIT);
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
     EXPECT_TRUE(state.needsRedraw());
 
     // Expect to do nothing until vsync.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
@@ skipping 137 matching lines @@
     state.didLeaveVSync();
 
     // Cause a lost context while the begin frame is in flight.
     state.didLoseContext();
 
     // Ask for another draw. Expect nothing happens.
     state.setNeedsRedraw(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Finish the frame, update resources, and commit.
-    state.beginFrameComplete();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    state.beginFrameComplete(true);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
     state.updateState(state.nextAction());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(state.nextAction());
 
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     state.updateState(state.nextAction());
 
     // Expect to be told to begin context recreation, independent of vsync state
     state.didEnterVSync();
@@ skipping 23 matching lines @@
 
     // Cause a lost context while the begin frame is in flight.
     state.didLoseContext();
 
     // Ask for another draw and also set needs commit. Expect nothing happens.
     state.setNeedsRedraw(true);
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Finish the frame, update resources, and commit.
-    state.beginFrameComplete();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    state.beginFrameComplete(true);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
     state.updateState(state.nextAction());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(state.nextAction());
 
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     state.updateState(state.nextAction());
 
     // Expect to be told to begin context recreation, independent of vsync state
     state.didEnterVSync();
@@ skipping 54 matching lines @@
 
 TEST(CCSchedulerStateMachineTest, TestBeginFrameWhenCommitInProgress)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(false);
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS);
     state.setNeedsCommit(true);
     state.setNeedsForcedCommit(true);
 
-    state.beginFrameComplete();
-    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
+    state.beginFrameComplete(true);
+    EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_RESOURCES, state.nextAction());
     state.updateState(state.nextAction());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
-    state.beginUpdateMoreResourcesComplete(false);
+    state.updateResourcesComplete();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_COMMIT, state.nextAction());
     state.updateState(state.nextAction());
 
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestBeginFrameWhenContextLost)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
     state.setCanDraw(true);
     state.setNeedsCommit(true);
     state.setNeedsForcedCommit(true);
     state.didLoseContext();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 }