Roll cc snapshot up to 127605

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>
 #include <wtf/text/CString.h>
@@ skipping 98 matching lines @@
         state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
         EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
         EXPECT_FALSE(state.needsCommit());
         EXPECT_FALSE(state.vsyncCallbackNeeded());
     }
 }
 
 TEST(CCSchedulerStateMachineTest, TestSetForcedRedrawDoesNotSetsNormalRedraw)
 {
     CCSchedulerStateMachine state;
+    state.setCanDraw(true);
     state.setNeedsForcedRedraw();
     EXPECT_FALSE(state.redrawPending());
     EXPECT_TRUE(state.vsyncCallbackNeeded());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFailedDrawSetsNeedsCommitAndDoesNotDrawAgain)
 {
     CCSchedulerStateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
     state.setNeedsRedraw();
     EXPECT_TRUE(state.redrawPending());
     EXPECT_TRUE(state.vsyncCallbackNeeded());
     state.didEnterVSync();
 
     // We're drawing now.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     EXPECT_FALSE(state.redrawPending());
     EXPECT_FALSE(state.commitPending());
 
     // Failing the draw makes us require a commit.
     state.didDrawIfPossibleCompleted(false);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_TRUE(state.redrawPending());
     EXPECT_TRUE(state.commitPending());
 }
 
 TEST(CCSchedulerStateMachineTest, TestSetNeedsRedrawDuringFailedDrawDoesNotRemoveNeedsRedraw)
 {
     CCSchedulerStateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
     state.setNeedsRedraw();
     EXPECT_TRUE(state.redrawPending());
     EXPECT_TRUE(state.vsyncCallbackNeeded());
     state.didEnterVSync();
 
     // We're drawing now.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     EXPECT_FALSE(state.redrawPending());
     EXPECT_FALSE(state.commitPending());
 
     // While still in the same vsync callback, set needs redraw again.
     // This should not redraw.
     state.setNeedsRedraw();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Failing the draw makes us require a commit.
     state.didDrawIfPossibleCompleted(false);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     EXPECT_TRUE(state.redrawPending());
 }
 
 TEST(CCSchedulerStateMachineTest, TestCommitAfterFailedDrawAllowsDrawInSameFrame)
 {
     CCSchedulerStateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Start a commit.
     state.setNeedsCommit();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_TRUE(state.commitPending());
 
     // Then initiate a draw.
     state.setNeedsRedraw();
     EXPECT_TRUE(state.vsyncCallbackNeeded());
@@ skipping 20 matching lines @@
 
     // And we should be allowed to draw again.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestCommitAfterFailedAndSuccessfulDrawDoesNotAllowDrawInSameFrame)
 {
     CCSchedulerStateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Start a commit.
     state.setNeedsCommit();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_TRUE(state.commitPending());
 
     // Then initiate a draw.
     state.setNeedsRedraw();
     EXPECT_TRUE(state.vsyncCallbackNeeded());
@@ skipping 31 matching lines @@
 
     // And we should not be allowed to draw again in the same frame..
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFailedDrawsWillEventuallyForceADrawAfterTheNextCommit)
 {
     CCSchedulerStateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
     state.setMaximumNumberOfFailedDrawsBeforeDrawIsForced(1);
 
     // Start a commit.
     state.setNeedsCommit();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_TRUE(state.commitPending());
 
     // Then initiate a draw.
     state.setNeedsRedraw();
@@ skipping 22 matching lines @@
 
     // The redraw should be forced in this case.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFailedDrawIsRetriedNextVSync)
 {
     CCSchedulerStateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Start a draw.
     state.setNeedsRedraw();
     EXPECT_TRUE(state.vsyncCallbackNeeded());
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     EXPECT_TRUE(state.redrawPending());
 
     // Fail the draw.
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     state.didDrawIfPossibleCompleted(false);
     EXPECT_TRUE(state.redrawPending());
 
     // We should not be trying to draw again now, but we have a commit pending.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 
     state.didLeaveVSync();
     EXPECT_TRUE(state.vsyncCallbackNeeded());
     state.didEnterVSync();
 
     // We should try draw again in the next vsync.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame)
 {
     CCSchedulerStateMachine state;
     state.setVisible(true);
+    state.setCanDraw(true);
     state.setNeedsRedraw();
     EXPECT_TRUE(state.vsyncCallbackNeeded());
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
     state.updateState(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 
     // While still in the same vsync callback, set needs redraw again.
     // This should not redraw.
     state.setNeedsRedraw();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
@@ skipping 32 matching lines @@
             // Case 2: needsCommit=true
             state.setNeedsCommit(true);
             EXPECT_NE(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
         }
     }
 
     // When on vsync, or not on vsync but needsForcedRedraw set, should always draw except if you're ready to commit, in which case commit.
     for (size_t i = 0; i < numCommitStates; ++i) {
         for (unsigned j = 0; j < 2; ++j) {
             StateMachine state;
+            state.setCanDraw(true);
             state.setCommitState(allCommitStates[i]);
             bool forcedDraw = j;
             if (!forcedDraw) {
                 state.didEnterVSync();
                 state.setNeedsRedraw(true);
                 state.setVisible(true);
             } else
                 state.setNeedsForcedRedraw(true);
 
             CCSchedulerStateMachine::Action expectedAction;
@@ skipping 92 matching lines @@
     state.setCommitState(CCSchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
     state.setCanBeginFrame(true);
     state.setNeedsCommit(true);
     state.setNeedsRedraw(true);
     state.setUpdateMoreResourcesPending(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.setVisible(true);
+    state.setCanDraw(false);
+    EXPECT_FALSE(state.vsyncCallbackNeeded());
+
+    state.setUpdateMoreResourcesPending(true);
+    EXPECT_TRUE(state.vsyncCallbackNeeded());
+
+    state.setUpdateMoreResourcesPending(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.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());
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
 
     // Begin an update.
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_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.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);
 
@@ skipping 19 matching lines @@
     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);
     EXPECT_TRUE(state.vsyncCallbackNeeded());
 
     state.setUpdateMoreResourcesPending(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.setVisible(true);
+    state.setCanDraw(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_RESOURCES, state.nextAction());
 
     // Begin an update.
     state.updateState(CCSchedulerStateMachine::ACTION_BEGIN_UPDATE_MORE_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);
@@ skipping 27 matching lines @@
     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());
 
@@ skipping 22 matching lines @@
     // Verify that another commit will begin.
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFullCycle)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Start clean and set commit.
     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());
@@ skipping 28 matching lines @@
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_IDLE, state.commitState());
     EXPECT_FALSE(state.needsRedraw());
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Start clean and set commit.
     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());
@@ skipping 39 matching lines @@
     StateMachine state;
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestGoesInvisibleBeforeBeginFrameCompletes)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Start clean and set commit.
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 
     // Begin the frame while visible.
     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());
@@ skipping 18 matching lines @@
 
     // We should be starting the commit now
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 }
 
 TEST(CCSchedulerStateMachineTest, TestContextLostWhenCompletelyIdle)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     state.didLoseContext();
 
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION, state.nextAction());
     state.updateState(state.nextAction());
 
     // Once context recreation begins, nothing should happen.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // Recreate the context
     state.didRecreateContext();
 
     // When the context is recreated, we should begin a commit
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestContextLostWhenIdleAndCommitRequestedWhileRecreating)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     state.didLoseContext();
 
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION, state.nextAction());
     state.updateState(state.nextAction());
 
     // Once context recreation begins, nothing should happen.
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
 
     // While context is recreating, commits shouldn't begin.
@@ skipping 16 matching lines @@
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_NONE, state.nextAction());
     state.setCanDraw(true);
     state.didLeaveVSync();
 }
 
 TEST(CCSchedulerStateMachineTest, TestContextLostWhileCommitInProgress)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Get a commit in flight.
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(state.nextAction());
 
     // Set damage and expect a draw.
     state.setNeedsRedraw(true);
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
@@ skipping 21 matching lines @@
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION, state.nextAction());
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestContextLostWhileCommitInProgressAndAnotherCommitRequested)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Get a commit in flight.
     state.setNeedsCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
     state.updateState(state.nextAction());
 
     // Set damage and expect a draw.
     state.setNeedsRedraw(true);
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
@@ skipping 30 matching lines @@
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION, state.nextAction());
     state.didLeaveVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION, state.nextAction());
 }
 
 
 TEST(CCSchedulerStateMachineTest, TestFinishAllRenderingWhileContextLost)
 {
     StateMachine state;
     state.setVisible(true);
+    state.setCanDraw(true);
 
     // Cause a lost context lost.
     state.didLoseContext();
 
     // Ask a forced redraw and verify it ocurrs.
     state.setNeedsForcedRedraw(true);
     state.didEnterVSync();
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
     state.didLeaveVSync();
 
@@ skipping 18 matching lines @@
     state.setVisible(false);
     state.setNeedsCommit(true);
     state.setNeedsForcedCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestBeginFrameWhenCanBeginFrameFalseAndForceCommit)
 {
     StateMachine state;
     state.setVisible(true);
+    state.setCanDraw(true);
     state.setNeedsCommit(true);
     state.setNeedsForcedCommit(true);
     EXPECT_EQ(CCSchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 }
 
 TEST(CCSchedulerStateMachineTest, TestBeginFrameWhenCommitInProgress)
 {
     StateMachine state;
     state.setCanBeginFrame(true);
     state.setVisible(false);
@@ skipping 12 matching lines @@
     EXPECT_EQ(CCSchedulerStateMachine::COMMIT_STATE_IDLE, 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());
 }
 
 }