cc: Remove awareness of incremental updates from state machine.

cc/CCSchedulerStateMachine.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 "base/stringprintf.h"
 
 
 namespace WebCore {
 
 CCSchedulerStateMachine::CCSchedulerStateMachine()
     : m_commitState(COMMIT_STATE_IDLE)
     , m_currentFrameNumber(0)
     , m_lastFrameNumberWhereDrawWasCalled(-1)
     , m_consecutiveFailedDraws(0)
     , m_maximumNumberOfFailedDrawsBeforeDrawIsForced(3)
     , m_needsRedraw(false)
     , m_needsForcedRedraw(false)
     , m_needsForcedRedrawAfterNextCommit(false)
     , m_needsCommit(false)
     , m_needsForcedCommit(false)
     , m_mainThreadNeedsLayerTextures(false)
-    , m_updateMoreResourcesPending(false)
+    , m_updateResourcesCompletePending(false)
     , m_insideVSync(false)
     , m_visible(false)
     , m_canBeginFrame(false)
     , m_canDraw(false)
     , m_drawIfPossibleFailed(false)
     , m_textureState(LAYER_TEXTURE_STATE_UNLOCKED)
     , m_contextState(CONTEXT_ACTIVE)
 {
 }
 
 std::string CCSchedulerStateMachine::toString()
 {
     std::string str;
     base::StringAppendF(&str, "m_commitState = %d; ", m_commitState);
     base::StringAppendF(&str, "m_currentFrameNumber = %d; ", m_currentFrameNumber);
     base::StringAppendF(&str, "m_lastFrameNumberWhereDrawWasCalled = %d; ", m_lastFrameNumberWhereDrawWasCalled);
     base::StringAppendF(&str, "m_consecutiveFailedDraws = %d; ", m_consecutiveFailedDraws);
     base::StringAppendF(&str, "m_maximumNumberOfFailedDrawsBeforeDrawIsForced = %d; ", m_maximumNumberOfFailedDrawsBeforeDrawIsForced);
     base::StringAppendF(&str, "m_needsRedraw = %d; ", m_needsRedraw);
     base::StringAppendF(&str, "m_needsForcedRedraw = %d; ", m_needsForcedRedraw);
     base::StringAppendF(&str, "m_needsForcedRedrawAfterNextCommit = %d; ", m_needsForcedRedrawAfterNextCommit);
     base::StringAppendF(&str, "m_needsCommit = %d; ", m_needsCommit);
     base::StringAppendF(&str, "m_needsForcedCommit = %d; ", m_needsForcedCommit);
     base::StringAppendF(&str, "m_mainThreadNeedsLayerTextures = %d; ", m_mainThreadNeedsLayerTextures);
-    base::StringAppendF(&str, "m_updateMoreResourcesPending = %d; ", m_updateMoreResourcesPending);
+    base::StringAppendF(&str, "m_updateResourcesCompletePending = %d; ", m_updateResourcesCompletePending);
     base::StringAppendF(&str, "m_insideVSync = %d; ", m_insideVSync);
     base::StringAppendF(&str, "m_visible = %d; ", m_visible);
     base::StringAppendF(&str, "m_canBeginFrame = %d; ", m_canBeginFrame);
     base::StringAppendF(&str, "m_canDraw = %d; ", m_canDraw);
     base::StringAppendF(&str, "m_drawIfPossibleFailed = %d; ", m_drawIfPossibleFailed);
     base::StringAppendF(&str, "m_textureState = %d; ", m_textureState);
     base::StringAppendF(&str, "m_contextState = %d; ", m_contextState);
     return str;
 }
 
@@ skipping 75 matching lines @@
         return ACTION_NONE;
 
     case COMMIT_STATE_FRAME_IN_PROGRESS:
         if (shouldDraw())
             return m_needsForcedRedraw ? ACTION_DRAW_FORCED : ACTION_DRAW_IF_POSSIBLE;
         return ACTION_NONE;
 
     case COMMIT_STATE_UPDATING_RESOURCES:
         if (shouldDraw())
             return m_needsForcedRedraw ? ACTION_DRAW_FORCED : ACTION_DRAW_IF_POSSIBLE;
-        if (!m_updateMoreResourcesPending)
-            return ACTION_BEGIN_UPDATE_MORE_RESOURCES;
+        if (!m_updateResourcesCompletePending)
+            return ACTION_BEGIN_UPDATE_RESOURCES;
         return ACTION_NONE;
 
     case COMMIT_STATE_READY_TO_COMMIT:
         return ACTION_COMMIT;
 
     case COMMIT_STATE_WAITING_FOR_FIRST_DRAW:
         if (shouldDraw() || m_contextState == CONTEXT_LOST)
             return m_needsForcedRedraw ? ACTION_DRAW_FORCED : ACTION_DRAW_IF_POSSIBLE;
         // COMMIT_STATE_WAITING_FOR_FIRST_DRAW wants to enforce a draw. If m_canDraw is false
         // or textures are not available, proceed to the next step (similar as in COMMIT_STATE_IDLE).
@@ skipping 12 matching lines @@
     case ACTION_NONE:
         return;
 
     case ACTION_BEGIN_FRAME:
         ASSERT(m_visible || m_needsForcedCommit);
         m_commitState = COMMIT_STATE_FRAME_IN_PROGRESS;
         m_needsCommit = false;
         m_needsForcedCommit = false;
         return;
 
-    case ACTION_BEGIN_UPDATE_MORE_RESOURCES:
+    case ACTION_BEGIN_UPDATE_RESOURCES:
         ASSERT(m_commitState == COMMIT_STATE_UPDATING_RESOURCES);
-        m_updateMoreResourcesPending = true;
+        m_updateResourcesCompletePending = true;
         return;
 
     case ACTION_COMMIT:
         m_commitState = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
         m_needsRedraw = true;
         if (m_drawIfPossibleFailed)
             m_lastFrameNumberWhereDrawWasCalled = -1;
 
         if (m_needsForcedRedrawAfterNextCommit) {
             m_needsForcedRedrawAfterNextCommit = false;
@@ skipping 34 matching lines @@
 void CCSchedulerStateMachine::setMainThreadNeedsLayerTextures()
 {
     ASSERT(!m_mainThreadNeedsLayerTextures);
     ASSERT(m_textureState != LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
     m_mainThreadNeedsLayerTextures = true;
 }
 
 bool CCSchedulerStateMachine::vsyncCallbackNeeded() const
 {
     // To prevent live-lock, we must always tick when updating resources.
-    if (m_updateMoreResourcesPending || m_commitState == COMMIT_STATE_UPDATING_RESOURCES)
+    if (m_updateResourcesCompletePending || m_commitState == COMMIT_STATE_UPDATING_RESOURCES)
         return true;
 
     // If we can't draw, don't tick until we are notified that we can draw again.
     if (!m_canDraw)
         return false;
 
     if (m_needsForcedRedraw)
         return true;
 
     return m_needsRedraw && m_visible && m_contextState == CONTEXT_ACTIVE;
@@ skipping 45 matching lines @@
 void CCSchedulerStateMachine::setNeedsCommit()
 {
     m_needsCommit = true;
 }
 
 void CCSchedulerStateMachine::setNeedsForcedCommit()
 {
     m_needsForcedCommit = true;
 }
 
-void CCSchedulerStateMachine::beginFrameComplete()
+void CCSchedulerStateMachine::beginFrameComplete(bool hasResourceUpdates)
 {
     ASSERT(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
-    m_commitState = COMMIT_STATE_UPDATING_RESOURCES;
+    if (hasResourceUpdates)
+        m_commitState = COMMIT_STATE_UPDATING_RESOURCES;
+    else
+        m_commitState = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void CCSchedulerStateMachine::beginFrameAborted()
 {
     ASSERT(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
     m_commitState = COMMIT_STATE_IDLE;
     setNeedsCommit();
 }
 
-void CCSchedulerStateMachine::beginUpdateMoreResourcesComplete(bool morePending)
+void CCSchedulerStateMachine::updateResourcesComplete()
 {
     ASSERT(m_commitState == COMMIT_STATE_UPDATING_RESOURCES);
-    ASSERT(m_updateMoreResourcesPending);
-    m_updateMoreResourcesPending = false;
-    if (!morePending)
-        m_commitState = COMMIT_STATE_READY_TO_COMMIT;
+    ASSERT(m_updateResourcesCompletePending);
+    m_updateResourcesCompletePending = false;
+    m_commitState = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void CCSchedulerStateMachine::didLoseContext()
 {
     if (m_contextState == CONTEXT_LOST || m_contextState == CONTEXT_RECREATING)
         return;
     m_contextState = CONTEXT_LOST;
 }
 
 void CCSchedulerStateMachine::didRecreateContext()
 {
     ASSERT(m_contextState == CONTEXT_RECREATING);
     m_contextState = CONTEXT_ACTIVE;
     setNeedsCommit();
 }
 
 void CCSchedulerStateMachine::setMaximumNumberOfFailedDrawsBeforeDrawIsForced(int numDraws)
 {
     m_maximumNumberOfFailedDrawsBeforeDrawIsForced = numDraws;
 }
 
 }