cc: Use BeginFrameArgs

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"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       commit_state_(COMMIT_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
-      last_frame_number_where_draw_was_called_(-1),
-      last_frame_number_where_tree_activation_attempted_(-1),
-      last_frame_number_where_check_for_completed_tile_uploads_called_(-1),
+      current_frame_attempt_(0),
+      last_frame_attempt_draw_was_called_(-1),
+      last_frame_attempt_tree_activation_attempted_(-1),
+      last_frame_attempt_check_for_completed_tile_uploads_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),
+      begin_frame_state_(BEGIN_FRAME_IDLE),
+      active_tree_has_been_drawn_(true),

[Sami, 2013/06/14 15:59:20]

Should this be false?

[brianderson, 2013/06/14 18:42:36]

If the active tree has been drawn, then this patch will wait for another tree
activation after a BeginFrame before drawing again.
If the active tree has not been drawn (because it was activated while we were in
BEGIN_FRAME_IDLE), then we will draw immediately on a BeginFrame.

I initialized it to true so we wait for tree activation for the first frame.

I will change the variable name to begin_frame_should_draw_immediately so the
name reflects the effect rather than the cause.

       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       draw_if_possible_failed_(false),
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       did_create_and_initialize_first_output_surface_(false) {}
 
 std::string SchedulerStateMachine::ToString() {
   std::string str;
   base::StringAppendF(&str,
                       "settings_.impl_side_painting = %d; ",
                       settings_.impl_side_painting);
   base::StringAppendF(&str, "commit_state_ = %d; ", commit_state_);
   base::StringAppendF(&str, "commit_count_ = %d; ", commit_count_);
-  base::StringAppendF(
-      &str, "current_frame_number_ = %d; ", current_frame_number_);
+  base::StringAppendF(&str, "current_frame_number_ = %d; ",
+                      current_frame_number_);
+  base::StringAppendF(&str, "current_frame_attempt_ = %d; ",
+                      current_frame_attempt_);
   base::StringAppendF(&str,
-                      "last_frame_number_where_draw_was_called_ = %d; ",
-                      last_frame_number_where_draw_was_called_);
+                      "last_frame_attempt_draw_was_called_ = %d; ",
+                      last_frame_attempt_draw_was_called_);
   base::StringAppendF(
       &str,
-      "last_frame_number_where_tree_activation_attempted_ = %d; ",
-      last_frame_number_where_tree_activation_attempted_);
+      "last_frame_attempt_tree_activation_attempted_ = %d; ",
+      last_frame_attempt_tree_activation_attempted_);
   base::StringAppendF(
       &str,
-      "last_frame_number_where_check_for_completed_tile_uploads_called_ = %d; ",
-      last_frame_number_where_check_for_completed_tile_uploads_called_);
+      "last_frame_attempt_check_for_completed_tile_uploads_called_ = %d; ",
+      last_frame_attempt_check_for_completed_tile_uploads_called_);
   base::StringAppendF(
       &str, "consecutive_failed_draws_ = %d; ", consecutive_failed_draws_);
   base::StringAppendF(
       &str,
       "maximum_number_of_failed_draws_before_draw_is_forced_ = %d; ",
       maximum_number_of_failed_draws_before_draw_is_forced_);
   base::StringAppendF(&str, "needs_redraw_ = %d; ", needs_redraw_);
   base::StringAppendF(
       &str, "swap_used_incomplete_tile_ = %d; ", swap_used_incomplete_tile_);
   base::StringAppendF(
       &str, "needs_forced_redraw_ = %d; ", needs_forced_redraw_);
   base::StringAppendF(&str,
                       "needs_forced_redraw_after_next_commit_ = %d; ",
                       needs_forced_redraw_after_next_commit_);
   base::StringAppendF(&str, "needs_commit_ = %d; ", needs_commit_);
   base::StringAppendF(
       &str, "needs_forced_commit_ = %d; ", needs_forced_commit_);
   base::StringAppendF(&str,
                       "expect_immediate_begin_frame_for_main_thread_ = %d; ",
                       expect_immediate_begin_frame_for_main_thread_);
   base::StringAppendF(&str,
                       "main_thread_needs_layer_textures_ = %d; ",
                       main_thread_needs_layer_textures_);
-  base::StringAppendF(&str, "inside_begin_frame_ = %d; ",
-      inside_begin_frame_);
+  base::StringAppendF(&str, "begin_frame_state_ = %d; ", begin_frame_state_);
   base::StringAppendF(&str, "last_frame_time_ = %"PRId64"; ",
       (last_begin_frame_args_.frame_time() - base::TimeTicks())
           .InMilliseconds());
   base::StringAppendF(&str, "last_deadline_ = %"PRId64"; ",
       (last_begin_frame_args_.deadline() - base::TimeTicks()).InMilliseconds());
   base::StringAppendF(&str, "last_interval_ = %"PRId64"; ",
       last_begin_frame_args_.interval().InMilliseconds());
   base::StringAppendF(&str, "visible_ = %d; ", visible_);
   base::StringAppendF(&str, "can_start_ = %d; ", can_start_);
   base::StringAppendF(&str, "can_draw_ = %d; ", can_draw_);
   base::StringAppendF(
       &str, "draw_if_possible_failed_ = %d; ", draw_if_possible_failed_);
   base::StringAppendF(&str, "has_pending_tree_ = %d; ", has_pending_tree_);
+  base::StringAppendF(&str, "active_tree_has_been_drawn_ = %d; ",
+      active_tree_has_been_drawn_);
   base::StringAppendF(&str, "texture_state_ = %d; ", texture_state_);
   base::StringAppendF(
       &str, "output_surface_state_ = %d; ", output_surface_state_);
   return str;
 }
 
 bool SchedulerStateMachine::HasDrawnThisFrame() const {
-  return current_frame_number_ == last_frame_number_where_draw_was_called_;
+  return current_frame_attempt_ == last_frame_attempt_draw_was_called_;

[brianderson, 2013/06/14 18:42:36]

I should change back to use current_frame_number since we should only draw once
per frame.

 }
 
 bool SchedulerStateMachine::HasAttemptedTreeActivationThisFrame() const {

[ajuma, 2013/06/14 15:22:32]

Calling this HasAttemptedTreeActivationThisFrameAttempt would make it clear that
we're trying multiple times per frame.

[brianderson, 2013/06/14 18:42:36]

Will do.

-  return current_frame_number_ ==
-         last_frame_number_where_tree_activation_attempted_;
+  return current_frame_attempt_ ==
+         last_frame_attempt_tree_activation_attempted_;
 }
 
 bool SchedulerStateMachine::HasCheckedForCompletedTileUploadsThisFrame() const {
-  return current_frame_number_ ==
-         last_frame_number_where_check_for_completed_tile_uploads_called_;
+  return current_frame_attempt_ ==
+         last_frame_attempt_check_for_completed_tile_uploads_called_;
 }
 
 bool SchedulerStateMachine::DrawSuspendedUntilCommit() const {
   if (!can_draw_)
     return true;
   if (!visible_)
     return true;
   if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD)
     return true;
   return false;
 }
 
 bool SchedulerStateMachine::ScheduledToDraw() const {
   if (!needs_redraw_)
     return false;
   if (DrawSuspendedUntilCommit())
     return false;
   return true;
 }
 
 bool SchedulerStateMachine::ShouldDraw() const {
   if (needs_forced_redraw_)
     return true;
 
   if (!ScheduledToDraw())
     return false;
-  if (!inside_begin_frame_)
+  if (begin_frame_state_ != BEGIN_FRAME_DRAWING)
     return false;
   if (HasDrawnThisFrame())
     return false;
   if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
     return false;
   return true;
 }
 
 bool SchedulerStateMachine::ShouldAttemptTreeActivation() const {
-  return has_pending_tree_ && inside_begin_frame_ &&
+  return active_tree_has_been_drawn_ &&
+         has_pending_tree_ &&
+         (begin_frame_state_ == BEGIN_FRAME_STARTING ||
+          begin_frame_state_ == BEGIN_FRAME_WAITING ||
+          begin_frame_state_ == BEGIN_FRAME_DRAWING) &&
          !HasAttemptedTreeActivationThisFrame();
 }
 
 bool SchedulerStateMachine::ShouldCheckForCompletedTileUploads() const {
   if (!settings_.impl_side_painting)
     return false;
   if (HasCheckedForCompletedTileUploadsThisFrame())
     return false;
 
   return ShouldAttemptTreeActivation() || ShouldDraw() ||
@@ skipping 36 matching lines @@
       if (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
       if (ShouldAttemptTreeActivation())
         return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
       if (ShouldDraw()) {
         return needs_forced_redraw_ ? ACTION_DRAW_FORCED
                                     : ACTION_DRAW_IF_POSSIBLE;
       }
       if (needs_commit_ &&
           ((visible_ && output_surface_state_ == OUTPUT_SURFACE_ACTIVE)
-           || needs_forced_commit_))
+           || needs_forced_commit_) &&
+          !has_pending_tree_ &&
+          begin_frame_state_ == BEGIN_FRAME_STARTING)
         // TODO(enne): Should probably drop the active tree on force commit.
-        return has_pending_tree_ ? ACTION_NONE
-                                 : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
+        return ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       return ACTION_NONE;
 
     case COMMIT_STATE_FRAME_IN_PROGRESS:
       if (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
       if (ShouldAttemptTreeActivation())
         return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
       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 (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
       if (ShouldAttemptTreeActivation())
         return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
       if (ShouldDraw() || output_surface_state_ == OUTPUT_SURFACE_LOST) {
         return needs_forced_redraw_ ? ACTION_DRAW_FORCED
                                     : ACTION_DRAW_IF_POSSIBLE;
       }
       // COMMIT_STATE_WAITING_FOR_FIRST_DRAW wants to enforce a draw. If
       // can_draw_ is false or textures are not available, proceed to the next
       // step (similar as in COMMIT_STATE_IDLE).
       bool can_commit = visible_ || needs_forced_commit_;
-      if (needs_commit_ && can_commit && DrawSuspendedUntilCommit())
-        return has_pending_tree_ ? ACTION_NONE
-                                 : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
+      if (needs_commit_ && can_commit && DrawSuspendedUntilCommit() &&
+          !has_pending_tree_ && begin_frame_state_ == BEGIN_FRAME_STARTING)
+        return ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
       return ACTION_NONE;
     }
 
     case COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW:
       if (ShouldCheckForCompletedTileUploads())
         return ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS;
       if (ShouldAttemptTreeActivation())
         return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED;
       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:
+      if (begin_frame_state_ == BEGIN_FRAME_STARTING)
+        begin_frame_state_ = BEGIN_FRAME_WAITING;
+      if (begin_frame_state_ == BEGIN_FRAME_DRAWING)
+        begin_frame_state_ = BEGIN_FRAME_IDLE;
       return;
 
     case ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS:
-      last_frame_number_where_check_for_completed_tile_uploads_called_ =
-          current_frame_number_;
+      last_frame_attempt_check_for_completed_tile_uploads_called_ =
+          current_frame_attempt_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED:
-      last_frame_number_where_tree_activation_attempted_ =
-          current_frame_number_;
+      last_frame_attempt_tree_activation_attempted_ =
+          current_frame_attempt_;
       return;
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
       DCHECK(!has_pending_tree_);
       DCHECK(visible_ || needs_forced_commit_);
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       needs_forced_commit_ = false;
       return;
 
     case ACTION_COMMIT:
       commit_count_++;
       if (expect_immediate_begin_frame_for_main_thread_)
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW;
       else
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
       // When impl-side painting, we draw on activation instead of on commit.
       if (!settings_.impl_side_painting)
         needs_redraw_ = true;
       if (draw_if_possible_failed_)
-        last_frame_number_where_draw_was_called_ = -1;
+        last_frame_attempt_draw_was_called_ = -1;
 
       if (needs_forced_redraw_after_next_commit_) {
         needs_forced_redraw_after_next_commit_ = false;
         needs_forced_redraw_ = true;
       }
 
       texture_state_ = LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD;
       return;
 
     case ACTION_DRAW_FORCED:
     case ACTION_DRAW_IF_POSSIBLE:
       needs_redraw_ = false;
       needs_forced_redraw_ = false;
       draw_if_possible_failed_ = false;
       swap_used_incomplete_tile_ = false;
-      if (inside_begin_frame_)
-        last_frame_number_where_draw_was_called_ = current_frame_number_;
+      last_frame_attempt_draw_was_called_ = current_frame_attempt_;
       if (commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW) {
         DCHECK(expect_immediate_begin_frame_for_main_thread_);
         commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
         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;
+      active_tree_has_been_drawn_ = true;
       return;
 
     case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
       DCHECK_EQ(commit_state_, COMMIT_STATE_IDLE);
       DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_LOST);
       output_surface_state_ = OUTPUT_SURFACE_CREATING;
       return;
 
     case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
       texture_state_ = LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD;
@@ skipping 28 matching lines @@
   if (needs_forced_redraw_)
     return true;
 
   if (visible_ && swap_used_incomplete_tile_)
     return true;
 
   return needs_redraw_ && visible_ &&
          output_surface_state_ == OUTPUT_SURFACE_ACTIVE;
 }
 
-void SchedulerStateMachine::DidEnterBeginFrame(BeginFrameArgs args) {
-  inside_begin_frame_ = true;
+void SchedulerStateMachine::StartBeginFrame(BeginFrameArgs args) {
+  current_frame_number_++;
+  current_frame_attempt_++;
   last_begin_frame_args_ = args;
+  if (active_tree_has_been_drawn_ && base::TimeTicks::Now() < args.deadline())
+     begin_frame_state_ = BEGIN_FRAME_STARTING;
+  else
+     begin_frame_state_ = BEGIN_FRAME_DRAWING;
 }
 
-void SchedulerStateMachine::DidLeaveBeginFrame() {
-  current_frame_number_++;
-  inside_begin_frame_ = false;
+void SchedulerStateMachine::OnBeginFrameDeadline() {
+  current_frame_attempt_++;
+  if (begin_frame_state_ == BEGIN_FRAME_WAITING)
+    begin_frame_state_ = BEGIN_FRAME_DRAWING;

[Sami, 2013/06/14 15:59:20]

Let me see if I got this right:

1. BeginFrame => BEGIN_FRAME_STARTING
2. Main thread processing starts => BEGIN_FRAME_WAITING
3. Deadline hit => BEGIN_FRAME_DRAWING
4. Main thread done, commit and activate tree => still in BEGIN_FRAME_DRAWING

Does this mean that we'll draw as soon as the tree activates even though we
passed the deadline? I think that's great for latency but maybe not what the
parent compositor is expecting :)

It also seems at odds with what happens if the tree activation happens right
before the deadline task runs, in which case we end up in BEGIN_FRAME_IDLE and
don't draw until the next BeginFrame.

[brianderson, 2013/06/14 18:42:36]

Almost:
2.a Main thread processing starts => BEGIN_FRAME_WAITING if active tree has been
drawn.
2.b Main thread processing starts => BEGIN_FRAME_DRAWING if active tree has not
been drawn.
The transition to BEGIN_FRAME_DRAWING will only occur for 3 and 4 if we are in
BEGIN_FRAME_WAITING. BEGIN_FRAME_DRAWING always transitions to BEGIN_FRAME_IDLE
(as part of UpdateState(ACTION_NONE), regardless of whether a draw actually
happened) which prevents us from going back to BEGIN_FRAME_DRAWING twice for the
same BeginFrame.
The logic should draw if activation occurs before the deadline.

 }
 
 void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; }
 
 void SchedulerStateMachine::SetNeedsRedraw() { needs_redraw_ = true; }
 
 void SchedulerStateMachine::DidSwapUseIncompleteTile() {
   swap_used_incomplete_tile_ = true;
 }
 
@@ skipping 46 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;
 }
 
 void SchedulerStateMachine::SetHasPendingTree(bool has_pending_tree) {
+  if (has_pending_tree_ && !has_pending_tree) {
+    // This is a new activation.
+    current_frame_attempt_++;
+    active_tree_has_been_drawn_ = false;
+    if (begin_frame_state_ == BEGIN_FRAME_STARTING) {
+      begin_frame_state_ = BEGIN_FRAME_DRAWING;
+    } else if (begin_frame_state_ == BEGIN_FRAME_WAITING) {
+      if (base::TimeTicks::Now() < last_begin_frame_args_.deadline())
+        begin_frame_state_ = BEGIN_FRAME_DRAWING;
+      else
+        begin_frame_state_ = BEGIN_FRAME_IDLE;
+    }
+  }
+
   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_ACTIVE;
 
   if (did_create_and_initialize_first_output_surface_) {
@@ skipping 11 matching lines @@
 bool SchedulerStateMachine::HasInitializedOutputSurface() const {
   return output_surface_state_ == OUTPUT_SURFACE_ACTIVE;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc