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/debug/trace_event.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 69 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 251 matching lines @@
 }
 
 bool SchedulerStateMachine::ShouldDraw() const {
   // 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);
+  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 BeginImplFrame
   // deadline.
   if (begin_impl_frame_state_ != BEGIN_IMPL_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);
+  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 44 matching lines @@
 }
 
 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const {
   if (!needs_commit_)
     return false;
 
   // Only send BeginMainFrame when there isn't another commit pending already.
   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.
+  // Disabled when smoothness takes priority to reduce CPU contention.
+  if (has_pending_tree_ && (!settings_.start_commit_before_activate_enabled ||
+                            smoothness_takes_priority_))
+    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.
+  // Disabled when smoothness takes priority to reduce CPU contention.
+  if (active_tree_needs_first_draw_ &&
+      (!settings_.start_commit_before_draw_enabled ||
+       smoothness_takes_priority_))
     return false;
 
   // We want to handle readback commits immediately to unblock the main thread.
   // Note: This BeginMainFrame will correspond to the replacement commit that
   // comes after the readback commit itself, so we only send the BeginMainFrame
   // if a commit isn't already pending behind the readback.
   if (readback_state_ == READBACK_STATE_NEEDS_BEGIN_MAIN_FRAME)
     return !CommitPending();
 
   // We do not need commits if we are not visible, unless there's a
@@ skipping 34 matching lines @@
   if (!HasInitializedOutputSurface())
     return false;
 
   if (skip_begin_main_frame_to_reduce_latency_)
     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;
 }
 
 bool SchedulerStateMachine::IsCommitStateWaiting() const {
   return commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS;
 }
 
 bool SchedulerStateMachine::ShouldManageTiles() const {
   // ManageTiles only really needs to be called immediately after commit
   // and then periodically after that. Use a funnel to make sure we average
   // one ManageTiles per BeginImplFrame in the long run.
@@ skipping 52 matching lines @@
     case ACTION_UPDATE_VISIBLE_TILES:
       last_frame_number_update_visible_tiles_was_called_ =
           current_frame_number_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE:
       UpdateStateOnActivation();
       return;
 
     case ACTION_SEND_BEGIN_MAIN_FRAME:
-      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_MAIN_FRAME);
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       if (readback_state_ == READBACK_STATE_NEEDS_BEGIN_MAIN_FRAME)
         readback_state_ = READBACK_STATE_WAITING_FOR_COMMIT;
       last_frame_number_begin_main_frame_sent_ =
           current_frame_number_;
       return;
 
@@ skipping 36 matching lines @@
 
     case ACTION_MANAGE_TILES:
       UpdateStateOnManageTiles();
       return;
   }
 }
 
 void SchedulerStateMachine::UpdateStateOnCommit(bool commit_was_aborted) {
   commit_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) {
-    DCHECK(commit_state_ == COMMIT_STATE_READY_TO_COMMIT);
-    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 31 matching lines @@
   active_tree_needs_first_draw_ = true;
   needs_redraw_ = true;
 }
 
 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 BeginMainFrame 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;
 
   if (did_swap)
@@ skipping 171 matching lines @@
     return true;
 
   // Prioritize impl-thread draws in smoothness mode.
   if (smoothness_takes_priority_)
     return true;
 
   return false;
 }
 
 bool SchedulerStateMachine::MainThreadIsInHighLatencyMode() const {
+  // If a commit is pending before the previous commit has been drawn, we
+  // are definitely in a high latency mode.
+  if (CommitPending() && (active_tree_needs_first_draw_ || has_pending_tree_))
+    return true;
+
   // If we just sent a BeginMainFrame and haven't hit the deadline yet, the main
   // thread is in a low latency mode.
   if (last_frame_number_begin_main_frame_sent_ == current_frame_number_ &&
       (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING ||
        begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME))
     return false;
 
   // If there's a commit in progress it must either be from the previous frame
   // or it started after the impl thread's deadline. In either case the main
   // thread is in high latency mode.
-  if (commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
-      commit_state_ == COMMIT_STATE_READY_TO_COMMIT)
+  if (CommitPending())
     return true;
 
   // Similarly, if there's a pending tree the main thread is in high latency
   // mode, because either
   //   it's from the previous frame
   // or
   //   we're currently drawing the active tree and the pending tree will thus
   //   only be drawn in the next frame.
   if (has_pending_tree_)
     return true;
@@ skipping 88 matching lines @@
   // BeginMainFrame behind the readback request. In that case, we can skip
   // READBACK_STATE_NEEDS_BEGIN_MAIN_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_MAIN_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::BeginMainFrameAborted(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 43 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