cc: Allow sending BeginMainFrame before draw or activation

cc/scheduler/scheduler_state_machine.h

 // 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.
 
 #ifndef CC_SCHEDULER_SCHEDULER_STATE_MACHINE_H_
 #define CC_SCHEDULER_SCHEDULER_STATE_MACHINE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 43 matching lines @@
     BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING,
     BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME,
     BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE,
   };
   static const char* BeginImplFrameStateToString(BeginImplFrameState state);
 
   enum CommitState {
     COMMIT_STATE_IDLE,
     COMMIT_STATE_FRAME_IN_PROGRESS,
     COMMIT_STATE_READY_TO_COMMIT,
-    COMMIT_STATE_WAITING_FOR_FIRST_DRAW,

[enne (OOO), 2014/01/23 21:51:55]

I'm not sure I follow the removal of this state.  Can that be done in a separate
patch?

[brianderson, 2014/01/23 23:31:35]

At ToT, COMMIT_STATE_WAITING_FOR_FIRST_DRAW can be replaced with
(has_pending_tree_ || active_tree_needs_first_draw_), so removing it in a
separate patch would be pretty easy.

I included it in this patch because I needed to decouple draw scheduling from
commit scheduling. By default, this patch starts the next commit before drawing
the previous commit and we'd never enter this state. Commit throttling is done
implicitly now via has_pending_tree_, active_tree_needs_first_draw_, and the
current settings.

I suppose I could keep the state and add COMMIT_STATE_WAITING_FOR_ACTIVATION to
be explicit about what the commit is waiting for, but that would complicate the
state transition logic and encode redundant state with the has_pending_tree and
active_tree_needs_first_draw_ variables.

   };
   static const char* CommitStateToString(CommitState state);
 
   enum TextureState {
     LAYER_TEXTURE_STATE_UNLOCKED,
     LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD,
     LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD,
   };
   static const char* TextureStateToString(TextureState state);
 
@@ skipping 15 matching lines @@
     FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION,
     FORCED_REDRAW_STATE_WAITING_FOR_DRAW,
   };
   static const char* ForcedRedrawOnTimeoutStateToString(
       ForcedRedrawOnTimeoutState state);
 
   bool CommitPending() const {
     return commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
            commit_state_ == COMMIT_STATE_READY_TO_COMMIT;
   }
+  CommitState commit_state() const { return commit_state_; }
 
   bool RedrawPending() const { return needs_redraw_; }
   bool ManageTilesPending() const { return needs_manage_tiles_; }
 
   enum Action {
     ACTION_NONE,
     ACTION_SEND_BEGIN_MAIN_FRAME,
     ACTION_COMMIT,
     ACTION_UPDATE_VISIBLE_TILES,
     ACTION_ACTIVATE_PENDING_TREE,
@@ skipping 107 matching lines @@
 
   // Indicates whether drawing would, at this time, make sense.
   // CanDraw can be used to suppress flashes or checkerboarding
   // when such behavior would be undesirable.
   void SetCanDraw(bool can);
 
   // Indicates that the pending tree is ready for activation.
   void NotifyReadyToActivate();
 
   bool has_pending_tree() const { return has_pending_tree_; }
+  bool active_tree_needs_first_draw() const {
+    return active_tree_needs_first_draw_;
+  }
 
   void DidManageTiles();
   void DidLoseOutputSurface();
   void DidCreateAndInitializeOutputSurface();
   bool HasInitializedOutputSurface() const;
 
   // True if we need to abort draws to make forward progress.
   bool PendingDrawsShouldBeAborted() const;
 
   bool SupportsProactiveBeginImplFrame() const;
@@ skipping 68 matching lines @@
   bool smoothness_takes_priority_;
   bool skip_begin_main_frame_to_reduce_latency_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SchedulerStateMachine);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_SCHEDULER_STATE_MACHINE_H_