cc: Control activation from the Scheduler

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"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       commit_state_(COMMIT_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
       last_frame_number_where_begin_frame_sent_to_main_thread_(-1),
       last_frame_number_where_draw_was_called_(-1),
-      last_frame_number_where_tree_activation_attempted_(-1),
       last_frame_number_where_update_visible_tiles_was_called_(-1),
       consecutive_failed_draws_(0),
       maximum_number_of_failed_draws_before_draw_is_forced_(3),
       needs_redraw_(false),
       swap_used_incomplete_tile_(false),
       needs_forced_redraw_(false),
       needs_forced_redraw_after_next_commit_(false),
       needs_commit_(false),
       needs_forced_commit_(false),
       expect_immediate_begin_frame_for_main_thread_(false),
       main_thread_needs_layer_textures_(false),
       inside_begin_frame_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
+      pending_tree_is_ready_for_activation_(false),
+      active_tree_has_been_drawn_(false),
       draw_if_possible_failed_(false),
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
       did_create_and_initialize_first_output_surface_(false) {}
 
 const char* SchedulerStateMachine::OutputSurfaceStateToString(
     OutputSurfaceState state) {
   switch (state) {
     case OUTPUT_SURFACE_ACTIVE:
       return "OUTPUT_SURFACE_ACTIVE";
     case OUTPUT_SURFACE_LOST:
@@ skipping 42 matching lines @@
 const char* SchedulerStateMachine::ActionToString(Action action) {
   switch (action) {
     case ACTION_NONE:
       return "ACTION_NONE";
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
       return "ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD";
     case ACTION_COMMIT:
       return "ACTION_COMMIT";
     case ACTION_UPDATE_VISIBLE_TILES:
       return "ACTION_UPDATE_VISIBLE_TILES";
-    case ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED:
-      return "ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED";
+    case ACTION_ACTIVATE_PENDING_TREE:
+      return "ACTION_ACTIVATE_PENDING_TREE";
     case ACTION_DRAW_IF_POSSIBLE:
       return "ACTION_DRAW_IF_POSSIBLE";
     case ACTION_DRAW_FORCED:
       return "ACTION_DRAW_FORCED";
     case ACTION_DRAW_AND_SWAP_ABORT:
       return "ACTION_DRAW_AND_SWAP_ABORT";
     case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
       return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION";
     case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
       return "ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD";
@@ skipping 42 matching lines @@
   state->Set("major_timestamps_in_ms", timestamps_state.release());
 
   scoped_ptr<base::DictionaryValue> minor_state(new base::DictionaryValue);
   minor_state->SetInteger("commit_count", commit_count_);
   minor_state->SetInteger("current_frame_number", current_frame_number_);
   minor_state->SetInteger(
       "last_frame_number_where_begin_frame_sent_to_main_thread",
       last_frame_number_where_begin_frame_sent_to_main_thread_);
   minor_state->SetInteger("last_frame_number_where_draw_was_called",
                           last_frame_number_where_draw_was_called_);
-  minor_state->SetInteger("last_frame_number_where_tree_activation_attempted",
-                          last_frame_number_where_tree_activation_attempted_);
   minor_state->SetInteger(
       "last_frame_number_where_update_visible_tiles_was_called",
       last_frame_number_where_update_visible_tiles_was_called_);
   minor_state->SetInteger("consecutive_failed_draws",
                           consecutive_failed_draws_);
   minor_state->SetInteger(
       "maximum_number_of_failed_draws_before_draw_is_forced",
       maximum_number_of_failed_draws_before_draw_is_forced_);
   minor_state->SetBoolean("needs_redraw", needs_redraw_);
   minor_state->SetBoolean("swap_used_incomplete_tile",
                           swap_used_incomplete_tile_);
   minor_state->SetBoolean("needs_forced_redraw", needs_forced_redraw_);
   minor_state->SetBoolean("needs_forced_redraw_after_next_commit",
                           needs_forced_redraw_after_next_commit_);
   minor_state->SetBoolean("needs_commit", needs_commit_);
   minor_state->SetBoolean("needs_forced_commit", needs_forced_commit_);
   minor_state->SetBoolean("expect_immediate_begin_frame_for_main_thread",
                           expect_immediate_begin_frame_for_main_thread_);
   minor_state->SetBoolean("main_thread_needs_layer_textures",
                           main_thread_needs_layer_textures_);
   minor_state->SetBoolean("inside_begin_frame", inside_begin_frame_);
   minor_state->SetBoolean("visible", visible_);
   minor_state->SetBoolean("can_start", can_start_);
   minor_state->SetBoolean("can_draw", can_draw_);
   minor_state->SetBoolean("has_pending_tree", has_pending_tree_);
+  minor_state->SetBoolean("pending_tree_is_ready_for_activation_",
+                          pending_tree_is_ready_for_activation_);
+  minor_state->SetBoolean("active_tree_has_been_drawn_",
+                          active_tree_has_been_drawn_);
   minor_state->SetBoolean("draw_if_possible_failed", draw_if_possible_failed_);
   minor_state->SetBoolean("did_create_and_initialize_first_output_surface",
                           did_create_and_initialize_first_output_surface_);
   state->Set("minor_state", minor_state.release());
 
   return state.PassAs<base::Value>();
 }
 
 bool SchedulerStateMachine::HasDrawnThisFrame() const {
   return current_frame_number_ == last_frame_number_where_draw_was_called_;
 }
 
-bool SchedulerStateMachine::HasAttemptedTreeActivationThisFrame() const {
-  return current_frame_number_ ==
-         last_frame_number_where_tree_activation_attempted_;
-}
-
 bool SchedulerStateMachine::HasUpdatedVisibleTilesThisFrame() const {
   return current_frame_number_ ==
          last_frame_number_where_update_visible_tiles_was_called_;
 }
 
 bool SchedulerStateMachine::HasSentBeginFrameToMainThreadThisFrame() const {
   return current_frame_number_ ==
          last_frame_number_where_begin_frame_sent_to_main_thread_;
 }
 
@@ skipping 18 matching lines @@
             OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION);
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) {
     if (commit_results_in_pending_tree) {
       output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION;
     } else {
       output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
       needs_redraw_ = true;
     }
   }
 
-  // if we don't have to wait for activation, update needs_redraw now.
-  if (!commit_results_in_pending_tree) {
-    if (!commit_was_aborted)
+  // Update state if we have a new active tree to draw.
+  if (!commit_results_in_pending_tree &&
+      (!commit_was_aborted || expect_immediate_begin_frame_for_main_thread_)) {
       needs_redraw_ = true;
-    if (expect_immediate_begin_frame_for_main_thread_)
-      needs_redraw_ = true;
+      active_tree_has_been_drawn_ = false;
   }
 
   // This post-commit work is common to both completed and aborted commits.
   if (draw_if_possible_failed_)
     last_frame_number_where_draw_was_called_ = -1;
 
   if (needs_forced_redraw_after_next_commit_) {
     needs_forced_redraw_after_next_commit_ = false;
     needs_forced_redraw_ = true;
   }
 
   // If we are planing to draw with the new commit, lock the layer textures for
   // use on the impl thread. Otherwise, leave them unlocked.
   if (commit_results_in_pending_tree || needs_redraw_ || needs_forced_redraw_)
     texture_state_ = LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD;
   else
     texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED;
 }
 
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // These are all the cases where, if we do not abort draws to make
   // forward progress, we might deadlock with the main thread.
+  // This should be a superset of PendingActivationsShouldBeForced().
+  if (PendingActivationsShouldBeForced())
+    return true;
+
+  // Additional states where we should abort draws.
+  // Note: We don't force activation in these cases because doing so would
+  // result in checkerboarding on resize, becoming visible, etc.
   if (!can_draw_)
     return true;
   if (!visible_)
     return true;
-  if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
-    return true;
-  if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD)
+  if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
     return true;
   return false;
 }
 
+bool SchedulerStateMachine::PendingActivationsShouldBeForced() const {
+  // These are all the cases where, if we do not force activations to make
+  // forward progress, we might deadlock with the main thread.
+  // This should be a subset PendingDrawsShouldBeAborted().
+  if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD)
+    return true;
+  if (output_surface_state_ == OUTPUT_SURFACE_LOST ||
+      output_surface_state_ == OUTPUT_SURFACE_CREATING ||
+      output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT)
+    return true;
+  return false;
+}
+
 bool SchedulerStateMachine::ShouldDraw() const {
   // Always handle forced draws ASAP.
   if (needs_forced_redraw_)
     return true;
 
   // If we are going to abort draws, we should do so ASAP.
-  if (PendingDrawsShouldBeAborted()) {
-    // TODO(brianderson): Remove the !has_pending_tree_ condition once
-    // the Scheduler controls activation. It's dangerous for us to rely on
-    // an eventual activation if we've lost the output surface.
-    return commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW &&
-           !has_pending_tree_;
-  }
+  if (PendingDrawsShouldBeAborted())
+    return commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
 
   // After this line, we only want to draw once per frame.
   if (HasDrawnThisFrame())
     return false;
 
   // We currently only draw within the BeginFrame.
   if (!inside_begin_frame_)
     return false;
 
   return needs_redraw_;
 }
 
-bool SchedulerStateMachine::ShouldAttemptTreeActivation() const {
-  return has_pending_tree_ && inside_begin_frame_ &&
-         !HasAttemptedTreeActivationThisFrame();
+bool SchedulerStateMachine::ShouldActivatePendingTree() const {
+  // There is nothing to activate.
+  if (!has_pending_tree_)
+    return false;
+
+  // We don't want to activate a second tree before drawing the first one.
+  // Note: It is possible that there is no active tree to draw when
+  // output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION,
+  // so we don't block activation on draw in that case.
+  if (!active_tree_has_been_drawn_ &&
+      output_surface_state_ != OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
+    return false;
+
+  // If we want to force activation, do so ASAP.
+  if (PendingActivationsShouldBeForced())
+    return true;
+
+  // At this point, only activate if we are ready to activate.
+  return pending_tree_is_ready_for_activation_;
 }
 
 bool SchedulerStateMachine::ShouldUpdateVisibleTiles() const {
   if (!settings_.impl_side_painting)
     return false;
   if (HasUpdatedVisibleTilesThisFrame())
     return false;
 
-  return ShouldAttemptTreeActivation() || ShouldDraw() ||
+  return ShouldActivatePendingTree() || ShouldDraw() ||
          swap_used_incomplete_tile_;
 }
 
 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;
@@ skipping 48 matching lines @@
           needs_forced_commit_)
         // TODO(enne): Should probably drop the active tree on force commit.
         return has_pending_tree_ ? ACTION_NONE
                                  : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       if (output_surface_state_ == OUTPUT_SURFACE_LOST && can_start_)
         return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
       if (output_surface_state_ == OUTPUT_SURFACE_CREATING)
         return ACTION_NONE;
       if (ShouldUpdateVisibleTiles())
         return ACTION_UPDATE_VISIBLE_TILES;
-      if (ShouldAttemptTreeActivation())
-        return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
+      if (ShouldActivatePendingTree())
+        return ACTION_ACTIVATE_PENDING_TREE;
       if (ShouldDraw()) {
         return needs_forced_redraw_ ? ACTION_DRAW_FORCED
                                     : ACTION_DRAW_IF_POSSIBLE;
       }
       if (ShouldSendBeginFrameToMainThread())
         return ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       return ACTION_NONE;
     }
     case COMMIT_STATE_FRAME_IN_PROGRESS:
       if (ShouldUpdateVisibleTiles())
         return ACTION_UPDATE_VISIBLE_TILES;
-      if (ShouldAttemptTreeActivation())
-        return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
+      if (ShouldActivatePendingTree())
+        return ACTION_ACTIVATE_PENDING_TREE;
       if (ShouldDraw()) {
         return needs_forced_redraw_ ? 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: {
       if (ShouldUpdateVisibleTiles())
         return ACTION_UPDATE_VISIBLE_TILES;
-      if (ShouldAttemptTreeActivation())
-        return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
+      if (ShouldActivatePendingTree())
+        return ACTION_ACTIVATE_PENDING_TREE;
       if (ShouldDraw()) {
         if (needs_forced_redraw_)
           return ACTION_DRAW_FORCED;
         else if (PendingDrawsShouldBeAborted())
           return ACTION_DRAW_AND_SWAP_ABORT;
         else
           return ACTION_DRAW_IF_POSSIBLE;
       }
       return ACTION_NONE;
     }
 
     case COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW:
       if (ShouldUpdateVisibleTiles())
         return ACTION_UPDATE_VISIBLE_TILES;
-      if (ShouldAttemptTreeActivation())
-        return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
+      if (ShouldActivatePendingTree())
+        return ACTION_ACTIVATE_PENDING_TREE;
       if (needs_forced_redraw_)
         return ACTION_DRAW_FORCED;
       return ACTION_NONE;
   }
   NOTREACHED();
   return ACTION_NONE;
 }
 
 void SchedulerStateMachine::UpdateState(Action action) {
   switch (action) {
     case ACTION_NONE:
       return;
 
     case ACTION_UPDATE_VISIBLE_TILES:
       last_frame_number_where_update_visible_tiles_was_called_ =
           current_frame_number_;
       return;
 
-    case ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED:
-      last_frame_number_where_tree_activation_attempted_ =
-          current_frame_number_;
+    case ACTION_ACTIVATE_PENDING_TREE:
       return;
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
       DCHECK(!has_pending_tree_);
       if (!needs_forced_commit_ &&
           output_surface_state_ != OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) {
         DCHECK(visible_);
         DCHECK_GT(current_frame_number_,
                   last_frame_number_where_begin_frame_sent_to_main_thread_);
       }
@@ skipping 45 matching lines @@
     expect_immediate_begin_frame_for_main_thread_ = false;
   } else if (commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW) {
     commit_state_ = COMMIT_STATE_IDLE;
   }
   if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD)
     texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED;
 
   needs_redraw_ = false;
   needs_forced_redraw_ = false;
   draw_if_possible_failed_ = false;
+  active_tree_has_been_drawn_ = true;
 
   if (did_swap)
     swap_used_incomplete_tile_ = false;
 }
 
 void SchedulerStateMachine::SetMainThreadNeedsLayerTextures() {
   DCHECK(!main_thread_needs_layer_textures_);
   DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
   main_thread_needs_layer_textures_ = true;
 }
 
 bool SchedulerStateMachine::BeginFrameNeededToDrawByImplThread() const {
-  // TODO(brianderson): Remove this hack once the Scheduler controls activation.
-  if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
-    return true;
-
   // If we can't draw, don't tick until we are notified that we can draw again.
   if (!can_draw_)
     return false;
 
   if (needs_forced_redraw_)
     return true;
 
   if (visible_ && swap_used_incomplete_tile_)
     return true;
 
   return needs_redraw_ && visible_ && HasInitializedOutputSurface();
 }
 
 bool SchedulerStateMachine::ProactiveBeginFrameWantedByImplThread() const {
   // Do not be proactive when invisible.
-  if (!visible_ || output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
+  if (!visible_ || !HasInitializedOutputSurface())
     return false;
 
   // We should proactively request a BeginFrame if a commit or a tree activation
   // is pending.
   return (needs_commit_ || needs_forced_commit_ ||
           commit_state_ != COMMIT_STATE_IDLE || has_pending_tree_);
 }
 
 void SchedulerStateMachine::DidEnterBeginFrame(const BeginFrameArgs& args) {
   current_frame_number_++;
@@ skipping 65 matching lines @@
 }
 
 void SchedulerStateMachine::DidLoseOutputSurface() {
   if (output_surface_state_ == OUTPUT_SURFACE_LOST ||
       output_surface_state_ == OUTPUT_SURFACE_CREATING)
     return;
   output_surface_state_ = OUTPUT_SURFACE_LOST;
   needs_redraw_ = false;
 }
 
+void SchedulerStateMachine::NotifyReadyToActivate() {
+  if (has_pending_tree_)
+    pending_tree_is_ready_for_activation_ = true;
+}
+
 void SchedulerStateMachine::SetHasPendingTree(bool has_pending_tree) {
   if (has_pending_tree_ && !has_pending_tree) {
     // There is a new active tree.
     if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
       output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
 
+    pending_tree_is_ready_for_activation_ = false;
+    active_tree_has_been_drawn_ = false;
     needs_redraw_ = true;
+  } 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;
 }
 
 void SchedulerStateMachine::SetCanDraw(bool can) { can_draw_ = can; }
 
 void SchedulerStateMachine::DidCreateAndInitializeOutputSurface() {
   DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_CREATING);
   output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT;
 
@@ skipping 19 matching lines @@
   NOTREACHED();
   return false;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc