cc: Make the scheduler compositeAndReadback flow not race with WAITING_FOR_FIRST_DRAW

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"
 
 namespace cc {
@@ skipping 124 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_READY_TO_COMMIT:
         return ACTION_COMMIT;
 
-    case COMMIT_STATE_WAITING_FOR_FIRST_DRAW:
+    case COMMIT_STATE_WAITING_FOR_FIRST_DRAW: {
         if (shouldDraw() || m_outputSurfaceState == OUTPUT_SURFACE_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).
         bool canCommit = m_visible || m_needsForcedCommit;
         if (m_needsCommit && canCommit && drawSuspendedUntilCommit())
             return ACTION_BEGIN_FRAME;
         return ACTION_NONE;
     }
+
+    case COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW:
+        if (m_needsForcedRedraw)
+            return ACTION_DRAW_FORCED;
+        return ACTION_NONE;
+    }
     NOTREACHED();
     return ACTION_NONE;
 }
 
 void SchedulerStateMachine::updateState(Action action)
 {
     switch (action) {
     case ACTION_NONE:
         return;
 
     case ACTION_BEGIN_FRAME:
         DCHECK(m_visible || m_needsForcedCommit);
         m_commitState = COMMIT_STATE_FRAME_IN_PROGRESS;
         m_needsCommit = false;
         m_needsForcedCommit = false;
         return;
 
     case ACTION_COMMIT:
-        m_commitState = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
+        if (m_expectImmediateBeginFrame)
+            m_commitState = COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW;
+        else
+            m_commitState = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
         m_needsRedraw = true;
         if (m_drawIfPossibleFailed)
             m_lastFrameNumberWhereDrawWasCalled = -1;
 
         if (m_needsForcedRedrawAfterNextCommit) {
             m_needsForcedRedrawAfterNextCommit = false;
             m_needsForcedRedraw = true;
         }
 
         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) {
-            if (m_expectImmediateBeginFrame) {
-                m_commitState = COMMIT_STATE_FRAME_IN_PROGRESS;
-                m_expectImmediateBeginFrame = false;
-            } else
-                m_commitState = COMMIT_STATE_IDLE;
-        }
+        if (m_commitState == COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW) {
+            DCHECK(m_expectImmediateBeginFrame);
+            m_commitState = COMMIT_STATE_FRAME_IN_PROGRESS;
+            m_expectImmediateBeginFrame = false;
+        } else if (m_commitState == COMMIT_STATE_WAITING_FOR_FIRST_DRAW)
+            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_OUTPUT_SURFACE_RECREATION:
         DCHECK(m_commitState == COMMIT_STATE_IDLE);
         DCHECK(m_outputSurfaceState == OUTPUT_SURFACE_LOST);
         m_outputSurfaceState = OUTPUT_SURFACE_RECREATING;
         return;
 
@@ skipping 110 matching lines @@
     m_outputSurfaceState = OUTPUT_SURFACE_ACTIVE;
     setNeedsCommit();
 }
 
 void SchedulerStateMachine::setMaximumNumberOfFailedDrawsBeforeDrawIsForced(int numDraws)
 {
     m_maximumNumberOfFailedDrawsBeforeDrawIsForced = numDraws;
 }
 
 }  // namespace cc