Use message passing for BeginFrameAndCommitState and clean up forced commit logic

cc/scheduler_state_machine.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_state_machine.h"
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "cc/settings.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine()
     : 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_expectImmediateBeginFrame(false)
     , m_mainThreadNeedsLayerTextures(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 SchedulerStateMachine::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_expectImmediateBeginFrame = %d; ", m_expectImmediateBeginFrame);
     base::StringAppendF(&str, "m_mainThreadNeedsLayerTextures = %d; ", m_mainThreadNeedsLayerTextures);
     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 124 matching lines @@
         m_textureState = LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD;
         return;
 
     case ACTION_DRAW_FORCED:
     case ACTION_DRAW_IF_POSSIBLE:
         m_needsRedraw = false;
         m_needsForcedRedraw = false;
         m_drawIfPossibleFailed = false;
         if (m_insideVSync)
             m_lastFrameNumberWhereDrawWasCalled = m_currentFrameNumber;
-        if (m_commitState == COMMIT_STATE_WAITING_FOR_FIRST_DRAW)
-            m_commitState = COMMIT_STATE_IDLE;
+        if (m_commitState == COMMIT_STATE_WAITING_FOR_FIRST_DRAW) {
+            if (m_expectImmediateBeginFrame) {
+                m_commitState = COMMIT_STATE_FRAME_IN_PROGRESS;
+                m_expectImmediateBeginFrame = false;
+            } else
+                m_commitState = COMMIT_STATE_IDLE;
+        }
         if (m_textureState == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD)
             m_textureState = LAYER_TEXTURE_STATE_UNLOCKED;
         return;
 
     case ACTION_BEGIN_CONTEXT_RECREATION:
         DCHECK(m_commitState == COMMIT_STATE_IDLE);
         DCHECK(m_contextState == CONTEXT_LOST);
         m_contextState = CONTEXT_RECREATING;
         return;
 
@@ skipping 69 matching lines @@
 }
 
 void SchedulerStateMachine::setNeedsCommit()
 {
     m_needsCommit = true;
 }
 
 void SchedulerStateMachine::setNeedsForcedCommit()
 {
     m_needsForcedCommit = true;
+    m_expectImmediateBeginFrame = true;
 }
 
 void SchedulerStateMachine::beginFrameComplete()
 {
-    DCHECK(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
+    DCHECK(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS ||
+           (m_expectImmediateBeginFrame && m_commitState != COMMIT_STATE_IDLE)) << toString();
     m_commitState = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void SchedulerStateMachine::beginFrameAborted()
 {
     DCHECK(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
-    m_commitState = COMMIT_STATE_IDLE;
-    setNeedsCommit();
+    if (m_expectImmediateBeginFrame)
+        m_expectImmediateBeginFrame = false;
+    else {
+        m_commitState = COMMIT_STATE_IDLE;
+        setNeedsCommit();
+    }
 }
 
 void SchedulerStateMachine::didLoseContext()
 {
     if (m_contextState == CONTEXT_LOST || m_contextState == CONTEXT_RECREATING)
         return;
     m_contextState = CONTEXT_LOST;
 }
 
 void SchedulerStateMachine::didRecreateContext()
 {
     DCHECK(m_contextState == CONTEXT_RECREATING);
     m_contextState = CONTEXT_ACTIVE;
     setNeedsCommit();
 }
 
 void SchedulerStateMachine::setMaximumNumberOfFailedDrawsBeforeDrawIsForced(int numDraws)
 {
     m_maximumNumberOfFailedDrawsBeforeDrawIsForced = numDraws;
 }
 
 }  // namespace cc