cc: Start commit early and block on tree activation

cc/scheduler/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/scheduler_state_machine.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 
@@ skipping 205 matching lines @@
     return true;
   }
 
   // If we've lost the output surface or draw is suspended, we want to be able
   // to abort a draw and make forward progress to unblock the main thread.
   if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE ||
       DrawSuspendedUntilCommit()) {
     return !active_tree_has_been_drawn_ &&
            (commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW ||
             commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION ||
+            commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS ||
             (output_surface_state_ != OUTPUT_SURFACE_ACTIVE &&
              !active_tree_is_null_));
   }
 
   // Except for the cases above, do not draw outside of the BeginFrame deadline.
   if (begin_frame_state_ != BEGIN_FRAME_STATE_INSIDE_DEADLINE)
     return false;
 
   // Only handle forced redraws due to timeouts on the regular deadline.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) {
@@ skipping 63 matching lines @@
   if (!BeginFrameNeededToDrawByImplThread())
     return true;
   return false;
 }
 
 bool SchedulerStateMachine::ShouldSendBeginFrameToMainThread() const {
   if (HasSentBeginFrameToMainThreadThisFrame())
     return false;
 
   // Only send BeginFrame to the main thread when idle.
-  if (commit_state_ != COMMIT_STATE_IDLE)
+  if (commit_state_ != COMMIT_STATE_IDLE &&
+      commit_state_ != COMMIT_STATE_WAITING_FOR_ACTIVATION)
     return false;
 
   // We can't accept a commit if we have a pending tree.
-  if (has_pending_tree_)
-    return false;
+  //if (has_pending_tree_)
+  //  return false;
 
   // We want to handle readback commits ASAP.
   if (readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED)
     return !CommitPending();
 
   // We want to start the first commit after we get a new output surface
   // immediately.
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT
       && needs_commit_)
     return true;
@@ skipping 49 matching lines @@
       if (ShouldDraw()) {
         if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE ||
             DrawSuspendedUntilCommit())
           return ACTION_DRAW_AND_SWAP_ABORT;
         else
           return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
       }
       return ACTION_NONE;
 
     case COMMIT_STATE_FRAME_IN_PROGRESS:
+    case COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS:
       if (ShouldUpdateVisibleTiles())
         return ACTION_UPDATE_VISIBLE_TILES;
       if (ShouldActivatePendingTree())
         return ACTION_ACTIVATE_PENDING_TREE;
       if (ShouldDraw()) {
         if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE ||
             DrawSuspendedUntilCommit())
           return ACTION_DRAW_AND_SWAP_ABORT;
         else
           return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
       }
       return ACTION_NONE;
 
     case COMMIT_STATE_READY_TO_COMMIT:
       return ACTION_COMMIT;
 
     case COMMIT_STATE_WAITING_FOR_ACTIVATION: {
+      if (ShouldSendBeginFrameToMainThread())
+        return ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       if (ShouldUpdateVisibleTiles())
         return ACTION_UPDATE_VISIBLE_TILES;
       if (ShouldActivatePendingTree())
         return ACTION_ACTIVATE_PENDING_TREE;
       if (ShouldDraw()) {
         if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE ||
             DrawSuspendedUntilCommit())
           return ACTION_DRAW_AND_SWAP_ABORT;
         else
           return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
@@ skipping 34 matching lines @@
       last_draw_attempt_count_update_visible_tiles_was_called_ =
           draw_attempt_count_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE:
       last_draw_attempt_count_tree_activation_attempted_ =
           draw_attempt_count_;
       return;
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
-      DCHECK(!has_pending_tree_);
+      //DCHECK(!has_pending_tree_);
       DCHECK(visible_ ||
              readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED ||
              forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT ||
              output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT);
-      commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
+      if (commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION)
+        commit_state_ = COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS;
+      else
+        commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       if (readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED)
         readback_state_ = READBACK_STATE_FORCED_COMMIT_PENDING;
       last_begin_frame_count_begin_frame_sent_to_main_thread_ =
           begin_frame_count_;
       return;
 
     case ACTION_COMMIT:
       HandleCommitInternal(false);
       return;
@@ skipping 154 matching lines @@
   } else {
     consecutive_failed_draws_ = 0;
   }
 }
 
 void SchedulerStateMachine::SetNeedsCommit() { needs_commit_ = true; }
 
 void SchedulerStateMachine::SetNeedsForcedCommitForReadback() {
   DCHECK(readback_state_ == READBACK_STATE_IDLE ||
          readback_state_ == READBACK_STATE_REPLACEMENT_COMMIT_PENDING);
-  if (commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS)
+  if (commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
+      commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS)
     readback_state_ = READBACK_STATE_FORCED_COMMIT_PENDING;
   else
     readback_state_ = READBACK_STATE_FORCED_COMMIT_REQUESTED;
 }
 
 void SchedulerStateMachine::FinishCommit() {
   DCHECK(commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
+         commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS ||
          readback_state_ == READBACK_STATE_FORCED_COMMIT_PENDING)
       << ToString();
   commit_state_ = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void SchedulerStateMachine::BeginFrameAbortedByMainThread(bool did_handle) {
-  DCHECK_EQ(commit_state_, COMMIT_STATE_FRAME_IN_PROGRESS);
+  DCHECK(commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
+         commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS);
   if (readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED) {
     readback_state_ = READBACK_STATE_IDLE;
   } else if (did_handle) {
     HandleCommitInternal(true);
   } else {
     commit_state_ = COMMIT_STATE_IDLE;
     SetNeedsCommit();
   }
 }
 
@@ skipping 21 matching lines @@
     needs_redraw_ = true;
 
     if (draw_if_possible_failed_) {
       last_begin_frame_count_swap_performed_ = -1;
       last_draw_attempt_count_draw_was_called_ = -1;
     }
 
     if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
       output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
 
-    DCHECK_EQ(COMMIT_STATE_WAITING_FOR_ACTIVATION, commit_state_);
+    DCHECK(commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION ||
+           commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS);
     if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION) {
       commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
       forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_DRAW;
     } else if (readback_state_ == READBACK_STATE_WAITING_FOR_ACTIVATION) {
       commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
       readback_state_ = READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK;
     } else {
-      commit_state_ = COMMIT_STATE_IDLE;
+      if (commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION_AND_FRAME_IN_PROGRESS)
+        commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
+      else
+        commit_state_ = COMMIT_STATE_IDLE;
       if (readback_state_ == READBACK_STATE_REPLACEMENT_COMMIT_ACTIVATING)
         readback_state_ = READBACK_STATE_IDLE;
     }
   } else if (!has_pending_tree_ && has_pending_tree) {
     // There is a new pending tree.
     pending_tree_is_ready_for_activation_ = false;
   }
 
   has_pending_tree_ = has_pending_tree;
 }
@@ skipping 14 matching lines @@
   return output_surface_state_ != OUTPUT_SURFACE_LOST &&
          output_surface_state_ != OUTPUT_SURFACE_CREATING;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc