cc: Implement deadine scheduling disabled by default

cc/scheduler/scheduler_state_machine.cc

Index: cc/scheduler/scheduler_state_machine.cc
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index 941f8de4d999d7a9e480c5727555b34bc43c4317..70a25c98cb62869d12e0169cd5bd4919058d32da 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -19,17 +19,20 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
       readback_state_(READBACK_STATE_IDLE),
       commit_count_(0),
-      current_frame_number_(0),
-      last_frame_number_where_begin_frame_sent_to_main_thread_(-1),
-      last_frame_number_swap_performed_(-1),
-      last_frame_number_where_update_visible_tiles_was_called_(-1),
+      begin_frame_count_(0),
+      draw_attempt_count_(0),
+      last_begin_frame_count_swap_performed_(-1),
+      last_draw_attempt_count_draw_was_called_(-1),
+      last_begin_frame_count_begin_frame_sent_to_main_thread_(-1),
+      last_draw_attempt_count_tree_activation_attempted_(-1),
+      last_draw_attempt_count_completed_tile_uploads_checked_(-1),
+      last_draw_attempt_count_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_commit_(false),
       main_thread_needs_layer_textures_(false),
-      inside_begin_frame_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
@@ -57,6 +60,22 @@ const char* SchedulerStateMachine::OutputSurfaceStateToString(
   return "???";
 }
 
+const char* SchedulerStateMachine::BeginFrameStateToString(
+    BeginFrameState state) {
+  switch (state) {
+    case BEGIN_FRAME_STATE_IDLE:
+      return "BEGIN_FRAME_STATE_IDLE";
+    case BEGIN_FRAME_STATE_INSIDE_BEGIN_FRAME:
+      return "BEGIN_FRAME_STATE_INSIDE_BEGIN_FRAME";
+    case BEGIN_FRAME_STATE_DEADLINE_PENDING:
+      return "BEGIN_FRAME_STATE_DEADLINE_PENDING";
+    case BEGIN_FRAME_STATE_INSIDE_DEADLINE:
+      return "BEGIN_FRAME_STATE_INSIDE_DEADLINE";
+  }
+  NOTREACHED();
+  return "???";
+}
+
 const char* SchedulerStateMachine::CommitStateToString(CommitState state) {
   switch (state) {
     case COMMIT_STATE_IDLE:
@@ -157,6 +176,8 @@ scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const  {
 
   scoped_ptr<base::DictionaryValue> major_state(new base::DictionaryValue);
   major_state->SetString("next_action", ActionToString(NextAction()));
+  major_state->SetString("commit_state",
+                         BeginFrameStateToString(begin_frame_state_));
   major_state->SetString("commit_state", CommitStateToString(commit_state_));
   major_state->SetString("texture_state_",
                          TextureStateToString(texture_state_));
@@ -198,27 +219,37 @@ scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const  {
 
   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("begin_frame_count_", begin_frame_count_);
+  minor_state->SetInteger("draw_attempt_count_", draw_attempt_count_);
+
+  minor_state->SetInteger("last_begin_frame_count_swap_performed_",
+                          last_begin_frame_count_swap_performed_);
+  minor_state->SetInteger("last_draw_attempt_count_draw_was_called_",
+                          last_draw_attempt_count_draw_was_called_);
+  minor_state->SetInteger(
+      "last_begin_frame_count_begin_frame_sent_to_main_thread_",
+      last_begin_frame_count_begin_frame_sent_to_main_thread_);
+  minor_state->SetInteger("last_draw_attempt_count_tree_activation_attempted_",
+                          last_draw_attempt_count_tree_activation_attempted_);
   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_swap_performed_);
+      "last_draw_attempt_count_completed_tile_uploads_checked_",
+      last_draw_attempt_count_completed_tile_uploads_checked_);
   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",
+      "last_draw_attempt_count_update_visible_tiles_was_called_",
+      last_draw_attempt_count_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_",
       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_commit", needs_commit_);
   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_);
@@ -236,17 +267,26 @@ scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const  {
 }
 
 bool SchedulerStateMachine::HasDrawnThisFrame() const {
-  return current_frame_number_ == last_frame_number_swap_performed_;
+  return begin_frame_count_ == last_begin_frame_count_swap_performed_;
 }
 
-bool SchedulerStateMachine::HasUpdatedVisibleTilesThisFrame() const {
-  return current_frame_number_ ==
-         last_frame_number_where_update_visible_tiles_was_called_;
+bool SchedulerStateMachine::HasDrawnThisDrawAttempt() const {
+  return draw_attempt_count_ == last_draw_attempt_count_draw_was_called_;
 }
 
 bool SchedulerStateMachine::HasSentBeginFrameToMainThreadThisFrame() const {
-  return current_frame_number_ ==
-         last_frame_number_where_begin_frame_sent_to_main_thread_;
+  return begin_frame_count_ ==
+         last_begin_frame_count_begin_frame_sent_to_main_thread_;
+}
+
+bool SchedulerStateMachine::HasUpdatedVisibleTilesThisDrawAttempt() const {
+  return draw_attempt_count_ ==
+         last_draw_attempt_count_update_visible_tiles_was_called_;
+}
+
+bool SchedulerStateMachine::HasActivatedPendingTreeThisDrawAttempt() const {
+  return draw_attempt_count_ ==
+         last_draw_attempt_count_tree_activation_attempted_;
 }
 
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
@@ -306,6 +346,9 @@ bool SchedulerStateMachine::ShouldBeginOutputSurfaceCreation() const {
 }
 
 bool SchedulerStateMachine::ShouldDraw() const {
+  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_REPLACEMENT_COMMIT_PENDING ||
@@ -330,8 +373,8 @@ bool SchedulerStateMachine::ShouldDraw() const {
   if (HasDrawnThisFrame())
     return false;
 
-  // We currently only draw within the BeginFrame.
-  if (!inside_begin_frame_)
+  // 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.
@@ -356,6 +399,8 @@ bool SchedulerStateMachine::ShouldActivatePendingTree() const {
   // There is nothing to activate.
   if (!has_pending_tree_)
     return false;
+  if (HasActivatedPendingTreeThisDrawAttempt())
+    return false;
 
   // If this is our first activation, we don't want to activate early.
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
@@ -376,7 +421,7 @@ bool SchedulerStateMachine::ShouldActivatePendingTree() const {
 bool SchedulerStateMachine::ShouldUpdateVisibleTiles() const {
   if (!settings_.impl_side_painting)
     return false;
-  if (HasUpdatedVisibleTilesThisFrame())
+  if (HasUpdatedVisibleTilesThisDrawAttempt())
     return false;
 
   // There's no reason to check for tiles if we don't have an output surface.
@@ -417,14 +462,28 @@ bool SchedulerStateMachine::ShouldSendBeginFrameToMainThread() const {
     return !CommitPending();
 
   // We do not need commits if we are not visible, unless there's a
-  // request for a forced commit.
+  // request for a readback.
   if (!visible_)
     return false;
 
+  // We shouldn't normally accept commits if there isn't an OutputSurface.
+  if (!HasInitializedOutputSurface())
+    return false;
+
   // We want to start the first commit after we get a new output surface ASAP.
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT)
     return true;
 
+  // We usually want to slave the main thread's BeginFrame to the impl thread's
+  // BeginFrame. However, if we aren't expecting a BeginFrame on the impl
+  // thread, we should send a BeginFrame to the main thread anyway to make
+  // progress.
+  // TODO(brianderson): Also allow sending BeginFrame to main thread while idle
+  // when the main thread isn't consuming user input.
+  if (begin_frame_state_ == BEGIN_FRAME_STATE_IDLE &&
+      BeginFrameNeededByImplThread())
+    return false;
+
   // We need a new commit for the forced redraw. This honors the
   // single commit per interval because the result will be swapped to screen.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT)
@@ -434,10 +493,6 @@ bool SchedulerStateMachine::ShouldSendBeginFrameToMainThread() const {
   if (HasSentBeginFrameToMainThreadThisFrame())
     return false;
 
-  // We shouldn't normally accept commits if there isn't an OutputSurface.
-  if (!HasInitializedOutputSurface())
-    return false;
-
   return true;
 }
 
@@ -484,8 +539,8 @@ void SchedulerStateMachine::UpdateState(Action action) {
       return;
 
     case ACTION_UPDATE_VISIBLE_TILES:
-      last_frame_number_where_update_visible_tiles_was_called_ =
-          current_frame_number_;
+      last_draw_attempt_count_update_visible_tiles_was_called_ =
+          draw_attempt_count_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE:
@@ -502,8 +557,8 @@ void SchedulerStateMachine::UpdateState(Action action) {
       needs_commit_ = false;
       if (readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED)
         readback_state_ = READBACK_STATE_FORCED_COMMIT_PENDING;
-      last_frame_number_where_begin_frame_sent_to_main_thread_ =
-          current_frame_number_;
+      last_begin_frame_count_begin_frame_sent_to_main_thread_ =
+          begin_frame_count_;
       return;
 
     case ACTION_COMMIT: {
@@ -543,6 +598,7 @@ void SchedulerStateMachine::UpdateState(Action action) {
 
 void SchedulerStateMachine::UpdateStateOnCommit(bool commit_was_aborted) {
   commit_count_++;
+  draw_attempt_count_++;
 
   // 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.
@@ -611,8 +667,10 @@ void SchedulerStateMachine::UpdateStateOnCommit(bool commit_was_aborted) {
   // This post-commit work is common to both completed and aborted commits.
   pending_tree_is_ready_for_activation_ = false;
 
-  if (draw_if_possible_failed_)
-    last_frame_number_swap_performed_ = -1;
+  if (draw_if_possible_failed_) {
+    last_begin_frame_count_swap_performed_ = -1;
+    last_draw_attempt_count_draw_was_called_ = -1;
+  }
 
   // If we are planing to draw with the new commit, lock the layer textures for
   // use on the impl thread. Otherwise, leave them unlocked.
@@ -623,6 +681,8 @@ void SchedulerStateMachine::UpdateStateOnCommit(bool commit_was_aborted) {
 }
 
 void SchedulerStateMachine::UpdateStateOnActivation() {
+  draw_attempt_count_++;
+
   // Update output surface state.
   if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
     output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
@@ -641,6 +701,7 @@ void SchedulerStateMachine::UpdateStateOnActivation() {
   pending_tree_is_ready_for_activation_ = false;
   active_tree_has_been_drawn_ = false;
   needs_redraw_ = true;
+  last_draw_attempt_count_tree_activation_attempted_ = draw_attempt_count_;
 }
 
 void SchedulerStateMachine::UpdateStateOnDraw(bool did_swap) {
@@ -673,10 +734,25 @@ void SchedulerStateMachine::UpdateStateOnDraw(bool did_swap) {
   needs_redraw_ = false;
   draw_if_possible_failed_ = false;
   active_tree_has_been_drawn_ = true;
+  last_draw_attempt_count_draw_was_called_ = draw_attempt_count_;
 
   if (did_swap) {
     swap_used_incomplete_tile_ = false;
-    last_frame_number_swap_performed_ = current_frame_number_;
+    last_begin_frame_count_swap_performed_ = begin_frame_count_;
+  }
+}
+
+void SchedulerStateMachine::AdvanceBeginFrameStateWhenNoActionsRemain() {
+  switch (begin_frame_state_) {
+    case BEGIN_FRAME_STATE_INSIDE_BEGIN_FRAME:
+      begin_frame_state_ = BEGIN_FRAME_STATE_DEADLINE_PENDING;
+      break;
+    case BEGIN_FRAME_STATE_INSIDE_DEADLINE:
+      begin_frame_state_ = BEGIN_FRAME_STATE_IDLE;
+      break;
+    case BEGIN_FRAME_STATE_IDLE:
+    case BEGIN_FRAME_STATE_DEADLINE_PENDING:
+      break;
   }
 }
 
@@ -686,6 +762,11 @@ void SchedulerStateMachine::SetMainThreadNeedsLayerTextures() {
   main_thread_needs_layer_textures_ = true;
 }
 
+bool SchedulerStateMachine::BeginFrameNeededByImplThread() const {
+  return BeginFrameNeededToDrawByImplThread() ||
+         ProactiveBeginFrameWantedByImplThread();
+}
+
 // These are the cases where we definitely (or almost definitely) have a
 // new frame to draw and can draw.
 bool SchedulerStateMachine::BeginFrameNeededToDrawByImplThread() const {
@@ -720,15 +801,22 @@ bool SchedulerStateMachine::BeginFrameNeededToDrawByImplThread() const {
 // actually have a new frame to draw when we receive the next BeginFrame.
 // Proactively requesting the BeginFrame helps hide the round trip latency of
 // the SetNeedsBeginFrame request that has to go to the Browser.
-// However, this is bad for the synchronous compoisitor because we have to
-// draw when we get the BeginFrame and could end up drawing many duplicate
-// frames.
 bool SchedulerStateMachine::ProactiveBeginFrameWantedByImplThread() const {
   // The output surface is the provider of BeginFrames for the impl thread,
   // so we are not going to get them even if we ask for them.
   if (!HasInitializedOutputSurface())
     return false;
 
+  // Proactive BeginFrames are bad for the synchronous compoisitor because we

[Sami, 2013/08/30 13:49:06]

Typo: compositor

+  // have to draw when we get the BeginFrame and could end up drawing many
+  // duplicate frames if our new frame isn't ready in time.
+  if (settings_.using_synchronous_renderer_compositor)
+    return false;
+
+  // Do not be proactive if vsync is off.
+  if (!settings_.throttle_frame_production)
+    return false;
+
   // Do not be proactive when invisible.
   if (!visible_)
     return false;
@@ -746,18 +834,33 @@ bool SchedulerStateMachine::ProactiveBeginFrameWantedByImplThread() const {
   return false;
 }
 
-void SchedulerStateMachine::DidEnterBeginFrame(const BeginFrameArgs& args) {
-  current_frame_number_++;
-  inside_begin_frame_ = true;
+void SchedulerStateMachine::OnBeginFrame(const BeginFrameArgs& args) {
+  begin_frame_count_++;
+  draw_attempt_count_++;
   last_begin_frame_args_ = args;
+  begin_frame_state_ = BEGIN_FRAME_STATE_INSIDE_BEGIN_FRAME;
 }
 
-void SchedulerStateMachine::DidLeaveBeginFrame() {
-  inside_begin_frame_ = false;
+bool SchedulerStateMachine::ShouldTriggerBeginFrameDeadlineEarly() const {
+  // TODO(brianderson): This should take into account multiple commit sources.

[Sami, 2013/08/30 13:49:06]

When could something like this happen? If there's both main thread animations
and input event handling going on? It would seem like being greedy like you've
done is a good default.

[brianderson, 2013/09/03 22:51:47]

This isn't so much an issue for Android as it is for ChromeOS, which can have
multiple child Renderers. If there are multiple child Renderers producing
output, this patch will go into a higher latency mode for the Renderer that lost
the commit race rather than waiting till the deadline for the slower Renderer to
commit.

+  return begin_frame_state_ == BEGIN_FRAME_STATE_DEADLINE_PENDING &&
+         !active_tree_has_been_drawn_;
+}
+
+bool SchedulerStateMachine::InsideBeginFrame() const {
+  return begin_frame_state_ != BEGIN_FRAME_STATE_IDLE;
+}
+
+void SchedulerStateMachine::OnBeginFrameDeadline() {
+  DCHECK_EQ(begin_frame_state_, BEGIN_FRAME_STATE_DEADLINE_PENDING);
+  draw_attempt_count_++;
+  begin_frame_state_ = BEGIN_FRAME_STATE_INSIDE_DEADLINE;
 }
 
 void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; }
 
+void SchedulerStateMachine::SetCanDraw(bool can_draw) { can_draw_ = can_draw; }
+
 void SchedulerStateMachine::SetNeedsRedraw() { needs_redraw_ = true; }
 
 void SchedulerStateMachine::DidSwapUseIncompleteTile() {
@@ -837,8 +940,6 @@ void SchedulerStateMachine::NotifyReadyToActivate() {
     pending_tree_is_ready_for_activation_ = true;
 }
 
-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;