cc: Use BeginFrameArgs

cc/scheduler/scheduler_state_machine.h

Index: cc/scheduler/scheduler_state_machine.h
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index 325ac1cd35a264a392ef802fb491fac0932135b6..18e0ae449b152077134e43c0c3f9108c6096befe 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -31,10 +31,22 @@ class CC_EXPORT SchedulerStateMachine {
   // settings must be valid for the lifetime of this class.
   explicit SchedulerStateMachine(const SchedulerSettings& settings);
 
+  // Note: BeginFrameState will always cycle through all the states in order.
+  // Whether or not it actually waits or draws, it will at least try to wait in
+  // BEGIN_FRAME_STATE_DEADLINE_PENDING and try to draw in
+  // BEGIN_FRAME_STATE_INSIDE_DEADLINE
+  enum BeginFrameState {
+    BEGIN_FRAME_STATE_IDLE,
+    BEGIN_FRAME_STATE_INSIDE_BEGIN_FRAME,
+    BEGIN_FRAME_STATE_DEADLINE_PENDING,
+    BEGIN_FRAME_STATE_INSIDE_DEADLINE,
+  };
+
   enum CommitState {
     COMMIT_STATE_IDLE,
     COMMIT_STATE_FRAME_IN_PROGRESS,
     COMMIT_STATE_READY_TO_COMMIT,
+    COMMIT_STATE_WAITING_FOR_ACTIVATION,
     COMMIT_STATE_WAITING_FOR_FIRST_DRAW,
     COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW,
   };
@@ -45,6 +57,23 @@ class CC_EXPORT SchedulerStateMachine {
     LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD,
   };
 
+  enum SynchronousReadbackState {

[brianderson, 2013/07/18 02:02:49]

This state is used to make sure:
1) We do not perform the readback until the readback commit has been activated.
2) We do not swap the commit associated with the readback to screen.
3) We know when it is safe to swap again. (The readback commit has been replaced
by a new commit on the active tree.)

+    READBACK_STATE_IDLE,
+    READBACK_STATE_FORCED_COMMIT_REQUESTED,
+    READBACK_STATE_FORCED_COMMIT_PENDING,
+    READBACK_STATE_WAITING_FOR_ACTIVATION,
+    READBACK_STATE_WAITING_FOR_DRAW_AND_READBACK,
+    READBACK_STATE_REPLACEMENT_COMMIT_PENDING,
+    READBACK_STATE_REPLACEMENT_COMMIT_ACTIVATING,
+  };
+
+  enum ForcedRedrawOnTimeoutState {
+    FORCED_REDRAW_STATE_IDLE,
+    FORCED_REDRAW_STATE_WAITING_FOR_COMMIT,
+    FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION,
+    FORCED_REDRAW_STATE_WAITING_FOR_DRAW,
+  };
+
   enum OutputSurfaceState {
     OUTPUT_SURFACE_ACTIVE,
     OUTPUT_SURFACE_LOST,
@@ -52,8 +81,7 @@ class CC_EXPORT SchedulerStateMachine {
   };
 
   bool CommitPending() const {
-    return commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
-           commit_state_ == COMMIT_STATE_READY_TO_COMMIT;
+    return commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS;
   }
 
   bool RedrawPending() const { return needs_redraw_; }
@@ -64,25 +92,29 @@ class CC_EXPORT SchedulerStateMachine {
     ACTION_COMMIT,
     ACTION_CHECK_FOR_COMPLETED_TILE_UPLOADS,
     ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED,
-    ACTION_DRAW_IF_POSSIBLE,
-    ACTION_DRAW_FORCED,
+    ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
+    ACTION_DRAW_AND_SWAP_FORCED,

[brianderson, 2013/07/18 02:02:49]

We still keep the forced draw for when we have skipped too many frames because
of checkerboarding. The concept has been mostly decoupled from the forced draw
associated with readback.

+    ACTION_DRAW_AND_READBACK,

[brianderson, 2013/07/18 02:02:49]

The readback no longer swaps.

     ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
     ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD,
   };
   Action NextAction() const;
   void UpdateState(Action action);
+  void AdvanceBeginFrameStateWhenNoActionsRemain();
 
   // Indicates whether the main thread needs a begin frame callback in order to
   // make progress.
+  bool BeginFrameNeededByImplThread() const;
   bool BeginFrameNeededToDrawByImplThread() const;
-  bool ProactiveBeginFrameWantedByImplThread() const;
+  bool BeginFrameProactivelyNeededByImplThread() const;
 
   // Indicates that the system has entered and left a BeginFrame callback.
   // The scheduler will not draw more than once in a given BeginFrame
   // callback.
-  void DidEnterBeginFrame(const BeginFrameArgs& args);
-  void DidLeaveBeginFrame();
-  bool inside_begin_frame() const { return inside_begin_frame_; }
+  void OnBeginFrame(const BeginFrameArgs& args);
+  void OnBeginFrameDeadline();
+  bool ShouldTriggerBeginFrameDeadlineEarly() const;
+  bool InsideBeginFrame() const;
 
   // Indicates whether the LayerTreeHostImpl is visible.
   void SetVisible(bool visible);
@@ -91,15 +123,11 @@ class CC_EXPORT SchedulerStateMachine {
   // or the screen being damaged and simply needing redisplay.
   void SetNeedsRedraw();
 
-  // As SetNeedsRedraw(), but ensures the draw will definitely happen even if
-  // we are not visible.
-  void SetNeedsForcedRedraw();
-
   // Indicates that a redraw is required because we are currently rendering
   // with a low resolution or checkerboarded tile.
   void DidSwapUseIncompleteTile();
 
-  // Indicates whether ACTION_DRAW_IF_POSSIBLE drew to the screen or not.
+  // Indicates whether ACTION_DRAW_AND_SWAP_IF_POSSIBLE drew to the screen.
   void DidDrawIfPossibleCompleted(bool success);
 
   // Indicates that a new commit flow needs to be performed, either to pull
@@ -111,7 +139,7 @@ class CC_EXPORT SchedulerStateMachine {
   // thread even if we are not visible.  After this call we expect to go through
   // the forced commit flow and then return to waiting for a non-forced
   // begin frame to finish.
-  void SetNeedsForcedCommit();
+  void SetNeedsForcedCommitForReadback();
 
   // Call this only in response to receiving an
   // ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD from NextAction.
@@ -125,8 +153,8 @@ class CC_EXPORT SchedulerStateMachine {
 
   // Request exclusive access to the textures that back single buffered
   // layers on behalf of the main thread. Upon acquisition,
-  // ACTION_DRAW_IF_POSSIBLE will not draw until the main thread releases the
-  // textures to the impl thread by committing the layers.
+  // ACTION_DRAW_AND_SWAP_IF_POSSIBLE will not draw until the main thread
+  // releases the textures to the impl thread by committing the layers.
   void SetMainThreadNeedsLayerTextures();
 
   // Set that we can create the first OutputSurface and start the scheduler.
@@ -135,14 +163,15 @@ class CC_EXPORT SchedulerStateMachine {
   // Indicates whether drawing would, at this time, make sense.
   // CanDraw can be used to supress flashes or checkerboarding
   // when such behavior would be undesirable.
-  void SetCanDraw(bool can);
+  void SetCanDraw(bool can_draw);
 
-  // Indicates whether or not there is a pending tree.  This influences
-  // whether or not we can succesfully commit at this time.  If the
+  // Indicates whether or not there is a pending tree (which may be null)
+  // and whether the active tree is null or not.  This
+  // influences whether or not we can succesfully commit at this time.  If the
   // last commit is still being processed (but not blocking), it may not
   // be possible to take another commit yet.  This overrides force commit,
   // as a commit is already still in flight.
-  void SetHasPendingTree(bool has_pending_tree);
+  void SetHasTrees(bool has_pending_tree, bool active_tree_is_null);
   bool has_pending_tree() const { return has_pending_tree_; }
 
   void DidLoseOutputSurface();
@@ -161,34 +190,42 @@ class CC_EXPORT SchedulerStateMachine {
  protected:
   bool ShouldDrawForced() const;
   bool ScheduledToDraw() const;
+  bool WillDrawNewTree() const;
   bool ShouldDraw() const;
+  bool ShouldDrawInternal(BeginFrameState begin_frame_state) const;
   bool ShouldAttemptTreeActivation() const;
   bool ShouldAcquireLayerTexturesForMainThread() const;
   bool ShouldCheckForCompletedTileUploads() const;
+  bool ShouldSendBeginFrameToMainThread() const;
   bool HasDrawnThisFrame() const;
-  bool HasAttemptedTreeActivationThisFrame() const;
-  bool HasCheckedForCompletedTileUploadsThisFrame() const;
+  bool HasAttemptedTreeActivationThisDrawAttempt() const;
+  bool HasCheckedForCompletedTileUploadsThisDrawAttempt() const;
+  bool HasSentBeginFrameToMainThreadThisFrame() const;
 
   const SchedulerSettings settings_;
 
   CommitState commit_state_;
   int commit_count_;
 
-  int current_frame_number_;
-  int last_frame_number_where_draw_was_called_;
-  int last_frame_number_where_tree_activation_attempted_;
-  int last_frame_number_where_check_for_completed_tile_uploads_called_;
+  int begin_frame_count_;
+  int begin_frame_deadline_count_;
+  int draw_attempt_count_;
+  int last_begin_frame_count_draw_was_called_;
+  int last_begin_frame_count_begin_frame_sent_to_main_thread_;
+  int last_draw_attempt_count_tree_activation_attempted_;
+  int last_draw_attempt_count_completed_tile_uploads_checked_;
   int consecutive_failed_draws_;
   int maximum_number_of_failed_draws_before_draw_is_forced_;
   bool needs_redraw_;
   bool swap_used_incomplete_tile_;
-  bool needs_forced_redraw_;
-  bool needs_forced_redraw_after_next_commit_;
+  SynchronousReadbackState readback_state_;
+  ForcedRedrawOnTimeoutState forced_redraw_state_;
   bool needs_commit_;
-  bool needs_forced_commit_;
-  bool expect_immediate_begin_frame_for_main_thread_;
   bool main_thread_needs_layer_textures_;
-  bool inside_begin_frame_;
+  BeginFrameState begin_frame_state_;
+  bool commit_tree_has_been_drawn_;
+  bool active_tree_has_been_drawn_;
+  bool active_tree_is_null_;
   BeginFrameArgs last_begin_frame_args_;
   bool visible_;
   bool can_start_;