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_pending_tree_activated_(-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),
+      active_tree_has_been_drawn_(false),
+      active_tree_is_null_(true),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
+      pending_tree_is_ready_for_activation_(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_pending_tree_activated_",
+                          last_frame_number_pending_tree_activated_);
   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("active_tree_has_been_drawn_",
+                          active_tree_has_been_drawn_);
+  minor_state->SetBoolean("active_tree_is_null_", active_tree_is_null_);
   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("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 {
+bool SchedulerStateMachine::HasActivatedPendingTreeThisFrame() const {
   return current_frame_number_ ==
-         last_frame_number_where_tree_activation_attempted_;
+         last_frame_number_pending_tree_activated_;
 }
 
 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 20 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;
   }
@@ skipping 38 matching lines @@
   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 {
+  // Some quick early outs.
+  if (!inside_begin_frame_)
+     return false;
+  if (!has_pending_tree_)
+    return false;
+  if (HasActivatedPendingTreeThisFrame())
+    return false;
+
+  if (!pending_tree_is_ready_for_activation_)
+    return false;
+
+  // We do not want to activate a second tree before drawing the first one.

[enne (OOO), 2013/08/23 17:54:09]

Is this handled by the HasActivatedPendingTreeThisFrame above?

[brianderson, 2013/08/23 20:51:59]

There's some overlap, but there are cases where
HasActivatedPendingTreeThisFrame() will be false and active_tree_has_been_drawn_
will also be false, in which case we still don't want to activate.

Now that I think about it, I should get rid of
HasActivatedPendingTreeThisFrame(). If activations are blocked by the active
tree having been drawn, activating twice in the same frame will be ok.

Also, we don't have to worry about infinite loops because
active_tree_has_been_drawn_ will go false to block the next activation.

+  return active_tree_has_been_drawn_ || active_tree_is_null_;
 }
 
 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:
+      last_frame_number_pending_tree_activated_ = current_frame_number_;
       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;
 }
@@ skipping 97 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::SetHasPendingTree(bool has_pending_tree) {
+void SchedulerStateMachine::NotifyReadyToActivate() {
+  if (has_pending_tree_)
+    pending_tree_is_ready_for_activation_ = true;
+}
+
+void SchedulerStateMachine::SetHasTrees(bool has_pending_tree,
+                                        bool active_tree_is_null) {
+  active_tree_is_null_ = active_tree_is_null;
   if (has_pending_tree_ && !has_pending_tree) {
     // There is a new active tree.
+    pending_tree_is_ready_for_activation_ = false;
+    active_tree_has_been_drawn_ = false;
+    needs_redraw_ = true;
+
     if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
       output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
-
-    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