cc: Implement deadine scheduling disabled by default

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),
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
       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),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_has_been_drawn_(true),
       draw_if_possible_failed_(false),
       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:
       return "OUTPUT_SURFACE_LOST";
     case OUTPUT_SURFACE_CREATING:
       return "OUTPUT_SURFACE_CREATING";
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
       return "OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT";
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return "OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION";
   }
   NOTREACHED();
   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:
       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";
@@ skipping 80 matching lines @@
   }
   NOTREACHED();
   return "???";
 }
 
 scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const  {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
   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_));
   major_state->SetString("output_surface_state_",
                          OutputSurfaceStateToString(output_surface_state_));
   major_state->SetString(
       "forced_redraw_state",
       ForcedRedrawOnTimeoutStateToString(forced_redraw_state_));
   major_state->SetString("readback_state",
                          SynchronousReadbackStateToString(readback_state_));
@@ skipping 21 matching lines @@
       (last_begin_frame_args_.frame_time - base::TimeTicks()).InMicroseconds() /
           1000.0L);
   timestamps_state->SetDouble(
       "6_deadline",
       (last_begin_frame_args_.deadline - base::TimeTicks()).InMicroseconds() /
           1000.0L);
   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("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_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_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_update_visible_tiles_was_called",
-      last_frame_number_where_update_visible_tiles_was_called_);
-  minor_state->SetInteger("consecutive_failed_draws",
+      "last_draw_attempt_count_completed_tile_uploads_checked_",
+      last_draw_attempt_count_completed_tile_uploads_checked_);
+  minor_state->SetInteger(
+      "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_);
   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_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 {
   // These are all the cases where we normally cannot or do not want to draw
   // but, if needs_redraw_ is true and we do not draw to make forward progress,
   // we might deadlock with the main thread.
   // This should be a superset of PendingActivationsShouldBeForced() since
   // activation of the pending tree is blocked by drawing of the active tree and
   // the main thread might be blocked on activation of the most recent commit.
   if (PendingActivationsShouldBeForced())
@@ skipping 39 matching lines @@
   // readback.
   if (!active_tree_has_been_drawn_ || has_pending_tree_)
     return false;
 
   // We need to create the output surface if we don't have one and we haven't
   // started creating one yet.
   return output_surface_state_ == OUTPUT_SURFACE_LOST;
 }
 
 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 ||
       readback_state_ == READBACK_STATE_REPLACEMENT_COMMIT_ACTIVATING)
     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);
     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_has_been_drawn_;
 
   // 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_)
+  // 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.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) {
     DCHECK_EQ(commit_state_, COMMIT_STATE_WAITING_FOR_FIRST_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);
   return false;
 }
 
 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)
     return pending_tree_is_ready_for_activation_;
 
   // We don't want to activate a second tree before drawing the first one.
   if (!active_tree_has_been_drawn_)
     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())
+  if (HasUpdatedVisibleTilesThisDrawAttempt())
     return false;
 
   // There's no reason to check for tiles if we don't have an output surface.
   if (!HasInitializedOutputSurface())
     return false;
 
   // We always want to update the most recent visible tiles before drawing
   // so we draw with fewer missing tiles.
   if (ShouldDraw())
     return true;
@@ skipping 20 matching lines @@
     return false;
 
   // We want to handle readback commits immediately to unblock the main thread.
   // Note: This BeginFrame will correspond to the replacement commit that comes
   // after the readback commit itself, so we only send the BeginFrame if a
   // commit isn't already pending behind the readback.
   if (readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED)
     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)
     return true;
 
   // After this point, we only start a commit once per frame.
   if (HasSentBeginFrameToMainThreadThisFrame())
     return false;
 
-  // We shouldn't normally accept commits if there isn't an OutputSurface.
-  if (!HasInitializedOutputSurface())
-    return false;
-
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
   return commit_state_ == COMMIT_STATE_READY_TO_COMMIT;
 }
 
 SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
   if (ShouldAcquireLayerTexturesForMainThread())
     return ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD;
@@ skipping 26 matching lines @@
   DCHECK(!(forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW &&
            readback_state_ == READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK));
 }
 
 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_;
+      last_draw_attempt_count_update_visible_tiles_was_called_ =
+          draw_attempt_count_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE:
       UpdateStateOnActivation();
       return;
 
     case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
       DCHECK(!has_pending_tree_);
       DCHECK(visible_ ||
              readback_state_ == READBACK_STATE_FORCED_COMMIT_REQUESTED ||
              forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT ||
              output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT);
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       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: {
       bool commit_was_aborted = false;
       UpdateStateOnCommit(commit_was_aborted);
       return;
     }
 
     case ACTION_DRAW_AND_SWAP_FORCED:
     case ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
@@ skipping 19 matching lines @@
 
     case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
       texture_state_ = LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD;
       main_thread_needs_layer_textures_ = false;
       return;
   }
 }
 
 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.
   has_pending_tree_ = settings_.impl_side_painting && !commit_was_aborted;
 
   // Update state related to readbacks.
   if (readback_state_ == READBACK_STATE_FORCED_COMMIT_PENDING) {
     // Update the state if this is the readback commit.
     readback_state_ = has_pending_tree_
                           ? READBACK_STATE_WAITING_FOR_ACTIVATION
@@ skipping 48 matching lines @@
       (!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_has_been_drawn_ = false;
   }
 
   // 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.
   if (has_pending_tree_ || needs_redraw_)
     texture_state_ = LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD;
   else
     texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED;
 }
 
 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;
 
   // Update readback state
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION)
     forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_DRAW;
 
   // Update forced redraw state
   if (readback_state_ == READBACK_STATE_WAITING_FOR_ACTIVATION)
     readback_state_ = READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK;
   else if (readback_state_ == READBACK_STATE_REPLACEMENT_COMMIT_ACTIVATING)
     readback_state_ = READBACK_STATE_IDLE;
 
   has_pending_tree_ = false;
   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) {
   DCHECK(readback_state_ != READBACK_STATE_REPLACEMENT_COMMIT_PENDING &&
          readback_state_ != READBACK_STATE_REPLACEMENT_COMMIT_ACTIVATING)
       << *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);
@@ skipping 12 matching lines @@
              !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_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;
+  }
+}
+
 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::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 {
   // 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;
 
   // If we can't draw, don't tick until we are notified that we can draw again.
   if (!can_draw_)
@@ skipping 14 matching lines @@
   if (swap_used_incomplete_tile_)
     return true;
 
   return needs_redraw_;
 }
 
 // These are cases where we are very likely to draw soon, but might not
 // 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;
 
   // We should proactively request a BeginFrame if a commit is pending
   // because we will want to draw if the commit completes quickly.
   if (needs_commit_ || commit_state_ != COMMIT_STATE_IDLE)
     return true;
 
   // If the pending tree activates quickly, we'll want a BeginFrame soon
   // to draw the new active tree.
   if (has_pending_tree_)
     return true;
 
   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() {
   swap_used_incomplete_tile_ = true;
 }
 
 void SchedulerStateMachine::DidDrawIfPossibleCompleted(bool success) {
   draw_if_possible_failed_ = !success;
   if (draw_if_possible_failed_) {
     needs_redraw_ = true;
@@ skipping 59 matching lines @@
     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::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;
 
   if (did_create_and_initialize_first_output_surface_) {
     // TODO(boliu): See if we can remove this when impl-side painting is always
     // on. Does anything on the main thread need to update after recreate?
     needs_commit_ = true;
   }
   did_create_and_initialize_first_output_surface_ = true;
@@ skipping 13 matching lines @@
   NOTREACHED();
   return false;
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc