cc: Allow sending BeginMainFrame before draw or 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"
 #include "base/values.h"
@@ skipping 65 matching lines @@
 }
 
 const char* SchedulerStateMachine::CommitStateToString(CommitState state) {
   switch (state) {
     case COMMIT_STATE_IDLE:
       return "COMMIT_STATE_IDLE";
     case COMMIT_STATE_FRAME_IN_PROGRESS:
       return "COMMIT_STATE_FRAME_IN_PROGRESS";
     case COMMIT_STATE_READY_TO_COMMIT:
       return "COMMIT_STATE_READY_TO_COMMIT";
-    case COMMIT_STATE_WAITING_FOR_FIRST_DRAW:
-      return "COMMIT_STATE_WAITING_FOR_FIRST_DRAW";
   }
   NOTREACHED();
   return "???";
 }
 
 const char* SchedulerStateMachine::TextureStateToString(TextureState state) {
   switch (state) {
     case LAYER_TEXTURE_STATE_UNLOCKED:
       return "LAYER_TEXTURE_STATE_UNLOCKED";
     case LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD:
@@ skipping 246 matching lines @@
   if (HasDrawnThisDrawAttempt())
     return false;
 
   // After a readback, make sure not to draw again until we've replaced the
   // readback commit with a real one.
   if (readback_state_ == READBACK_STATE_WAITING_FOR_REPLACEMENT_COMMIT ||
       readback_state_ == READBACK_STATE_WAITING_FOR_REPLACEMENT_ACTIVATION)
     return false;
 
   // Draw immediately for readbacks to unblock the main thread quickly.
-  if (readback_state_ == READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK) {
-    DCHECK_EQ(commit_state_, COMMIT_STATE_WAITING_FOR_FIRST_DRAW);

[danakj, 2013/09/17 17:05:07]

Should we DCHECK(active_tree_waiting_for_first_draw_)? The unit tests are
setting this true when they set this state.

[brianderson, 2013/10/03 14:44:38]

Yes, that would be a good DCHECK to add.

+  if (readback_state_ == READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK)
     return true;
-  }
 
   // If we need to abort draws, we should do so ASAP since the draw could
   // be blocking other important actions (like output surface initialization),
   // from occuring. If we are waiting for the first draw, then perfom the
   // aborted draw to keep things moving. If we are not waiting for the first
   // draw however, we don't want to abort for no reason.
   if (PendingDrawsShouldBeAborted())
     return active_tree_needs_first_draw_;
 
   // After this line, we only want to swap once per frame.
   if (HasSwappedThisFrame())
     return false;
 
   // 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) {
-    DCHECK_EQ(commit_state_, COMMIT_STATE_WAITING_FOR_FIRST_DRAW);

[danakj, 2013/09/17 17:05:07]

Should we DCHECK(active_tree_waiting_for_first_draw_)? The unit tests are
setting this true when they set this state.

+  if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     return true;
-  }
 
   return needs_redraw_;
 }
 
 bool SchedulerStateMachine::ShouldAcquireLayerTexturesForMainThread() const {
   if (!main_thread_needs_layer_textures_)
     return false;
   if (texture_state_ == LAYER_TEXTURE_STATE_UNLOCKED)
     return true;
   DCHECK_EQ(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD);
@@ skipping 46 matching lines @@
 }
 
 bool SchedulerStateMachine::ShouldSendBeginFrameToMainThread() const {
   if (!needs_commit_)
     return false;
 
   // Only send BeginFrame to the main thread when idle.
   if (commit_state_ != COMMIT_STATE_IDLE)
     return false;
 
-  // We can't accept a commit if we have a pending tree.
-  if (has_pending_tree_)
+  // Starting the commit while we still have a pending tree will block the
+  // main thread until the pending tree activates.
+  if (has_pending_tree_ &&
+      !settings_.start_commit_before_activate_enabled)
+    return false;
+
+  // If we are not impl-side-painting, starting the commit before the active
+  // tree has drawn will block the main thread until the first draw occurs.
+  // If we are impl-side-painting however, we will not block the main thread
+  // by starting the commit before the active tree has drawn since the pending
+  // tree is free to accept the commit.
+  if (active_tree_needs_first_draw_ &&

[Sami, 2013/10/03 13:31:11]

It's a little hard to see how this condition relates to
settings_.impl_side_painting as suggested by the comment. Maybe split this into
two if statements that explicitly check for settings_.impl_side_painting?

[brianderson, 2013/10/03 14:44:38]

The decision to be made here is the same regardless of whether
impl-side-painting is on or off, it's just what might happen afterwards that is
different. I will clarify the comment.

+      !settings_.start_commit_before_draw_enabled)
     return false;
 
   // We want to handle readback commits immediately to unblock the main thread.
   // Note: This BeginFrame will correspond to the replacement commit that comes
   // after the readback commit itself, so we only send the BeginFrame if a
   // commit isn't already pending behind the readback.
   if (readback_state_ == READBACK_STATE_NEEDS_BEGIN_FRAME)
     return !CommitPending();
 
   // We do not need commits if we are not visible, unless there's a
@@ skipping 25 matching lines @@
     return true;
 
   // After this point, we only start a commit once per frame.
   if (HasSentBeginFrameToMainThreadThisFrame())
     return false;
 
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
-  return commit_state_ == COMMIT_STATE_READY_TO_COMMIT;
+  if (commit_state_ != COMMIT_STATE_READY_TO_COMMIT)
+    return false;
+
+  // We must not finish the commit until the pending tree is free.
+  if (has_pending_tree_) {
+    DCHECK(settings_.start_commit_before_activate_enabled);
+    return false;
+  }
+
+  // If not impl-side-painting, we must not finish the commit until the
+  // previous commit has been drawn.
+  if (active_tree_needs_first_draw_ && !settings_.impl_side_painting) {
+    DCHECK(settings_.start_commit_before_draw_enabled);
+    return false;
+  }
+
+  return true;
 }
 
 SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
   if (ShouldAcquireLayerTexturesForMainThread())
     return ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD;
   if (ShouldUpdateVisibleTiles())
     return ACTION_UPDATE_VISIBLE_TILES;
   if (ShouldActivatePendingTree())
     return ACTION_ACTIVATE_PENDING_TREE;
   if (ShouldCommit())
@@ skipping 30 matching lines @@
     case ACTION_UPDATE_VISIBLE_TILES:
       last_draw_attempt_count_update_visible_tiles_was_called_ =
           draw_attempt_count_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE:
       UpdateStateOnActivation();
       return;
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
-      DCHECK(!has_pending_tree_);
+      DCHECK(!has_pending_tree_ ||
+             settings_.start_commit_before_activate_enabled);
+      DCHECK(!active_tree_needs_first_draw_ ||
+             settings_.start_commit_before_draw_enabled);
       DCHECK(visible_ || readback_state_ == READBACK_STATE_NEEDS_BEGIN_FRAME);
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       if (readback_state_ == READBACK_STATE_NEEDS_BEGIN_FRAME)
         readback_state_ = READBACK_STATE_WAITING_FOR_COMMIT;
       last_begin_frame_count_begin_frame_sent_to_main_thread_ =
           begin_frame_count_;
       return;
 
     case ACTION_COMMIT: {
@@ skipping 32 matching lines @@
       texture_state_ = LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD;
       main_thread_needs_layer_textures_ = false;
       return;
   }
 }
 
 void SchedulerStateMachine::UpdateStateOnCommit(bool commit_was_aborted) {
   commit_count_++;
   draw_attempt_count_++;
 
+  // Transition directly to idle.
+  commit_state_ = COMMIT_STATE_IDLE;
+
   // If we are impl-side-painting but the commit was aborted, then we behave
   // mostly as if we are not impl-side-painting since there is no pending tree.
   has_pending_tree_ = settings_.impl_side_painting && !commit_was_aborted;
 
   // Update state related to readbacks.
   if (readback_state_ == READBACK_STATE_WAITING_FOR_COMMIT) {
     // Update the state if this is the readback commit.
     readback_state_ = has_pending_tree_
                           ? READBACK_STATE_WAITING_FOR_ACTIVATION
                           : READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK;
@@ skipping 25 matching lines @@
     if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) {
       if (has_pending_tree_) {
         output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION;
       } else {
         output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
         needs_redraw_ = true;
       }
     }
   }
 
-  // Update the commit state. We expect and wait for a draw if the commit
-  // was not aborted or if we are in a readback or forced draw.
-  if (!commit_was_aborted)
-    commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
-  else if (readback_state_ != READBACK_STATE_IDLE ||
-           forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE)
-    commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
-  else
-    commit_state_ = COMMIT_STATE_IDLE;
-
   // Update state if we have a new active tree to draw, or if the active tree
   // was unchanged but we need to do a readback or forced draw.
   if (!has_pending_tree_ &&
       (!commit_was_aborted ||
        readback_state_ == READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK ||
        forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)) {
     needs_redraw_ = true;
     active_tree_needs_first_draw_ = true;
   }
 
@@ skipping 36 matching lines @@
   needs_redraw_ = true;
   last_draw_attempt_count_tree_activation_attempted_ = draw_attempt_count_;
 }
 
 void SchedulerStateMachine::UpdateStateOnDraw(bool did_swap) {
   DCHECK(readback_state_ != READBACK_STATE_WAITING_FOR_REPLACEMENT_COMMIT &&
          readback_state_ != READBACK_STATE_WAITING_FOR_REPLACEMENT_ACTIVATION)
       << *AsValue();
 
   if (readback_state_ == READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK) {
-    // The draw correspons to a readback commit.
-    DCHECK_EQ(commit_state_, COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
+    // The draw corresponds to a readback commit.
     // We are blocking commits from the main thread until after this draw, so
     // we should not have a pending tree.
     DCHECK(!has_pending_tree_);
     // We transition to COMMIT_STATE_FRAME_IN_PROGRESS because there is a
     // pending BeginFrame on the main thread behind the readback request.
     commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
     readback_state_ = READBACK_STATE_WAITING_FOR_REPLACEMENT_COMMIT;
   } else if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) {
-    DCHECK_EQ(commit_state_, COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
-    commit_state_ = COMMIT_STATE_IDLE;
     forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
-  } else if (commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW &&
-             !has_pending_tree_) {
-    commit_state_ = COMMIT_STATE_IDLE;
   }
 
   if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD)
     texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED;
 
   needs_redraw_ = false;
   draw_if_possible_failed_ = false;
   active_tree_needs_first_draw_ = false;
   last_draw_attempt_count_draw_was_called_ = draw_attempt_count_;
 
@@ skipping 164 matching lines @@
   // behind the readback request. In that case, we can skip
   // READBACK_STATE_NEEDS_BEGIN_FRAME and go directly to
   // READBACK_STATE_WAITING_FOR_COMMIT
   if (commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS)
     readback_state_ = READBACK_STATE_WAITING_FOR_COMMIT;
   else
     readback_state_ = READBACK_STATE_NEEDS_BEGIN_FRAME;
 }
 
 void SchedulerStateMachine::FinishCommit() {
-  DCHECK(commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS) << *AsValue();
+  DCHECK(commit_state_ != COMMIT_STATE_IDLE) << *AsValue();
   commit_state_ = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void SchedulerStateMachine::BeginFrameAbortedByMainThread(bool did_handle) {
   DCHECK_EQ(commit_state_, COMMIT_STATE_FRAME_IN_PROGRESS);
   if (did_handle) {
     bool commit_was_aborted = true;
     UpdateStateOnCommit(commit_was_aborted);
   } else {
     DCHECK_NE(readback_state_, READBACK_STATE_WAITING_FOR_COMMIT);
@@ skipping 36 matching lines @@
     case OUTPUT_SURFACE_ACTIVE:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc