cc: Remove frame queuing from the scheduler.

cc/scheduler/scheduler_state_machine_unittest.cc

Index: cc/scheduler/scheduler_state_machine_unittest.cc
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index c433bba9951ce35093a2a08d1ea0bd314c6081cb..d0595db4c501ca9f06cd54cbea11b95f0433c786 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -35,18 +35,18 @@
   EXPECT_ENUM_EQ(ActionToString, expected, state.NextAction()) \
       << state.AsValue()->ToString()
 
-#define EXPECT_ACTION_UPDATE_STATE(action)                                  \
-  EXPECT_ACTION(action);                                                    \
-  if (action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE ||  \
-      action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED) {       \
-    EXPECT_IMPL_FRAME_STATE(                                                \
-        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);     \
-  }                                                                         \
-  PerformAction(&state, action);                                            \
-  if (action == SchedulerStateMachine::ACTION_NONE) {                       \
-    if (state.begin_impl_frame_state() ==                                   \
-        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)      \
-      state.OnBeginImplFrameIdle();                                         \
+#define EXPECT_ACTION_UPDATE_STATE(action)                                 \
+  EXPECT_ACTION(action);                                                   \
+  if (action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE || \
+      action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED) {      \
+    EXPECT_IMPL_FRAME_STATE(                                               \
+        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);    \
+  }                                                                        \
+  PerformAction(&state, action);                                           \
+  if (action == SchedulerStateMachine::ACTION_NONE) {                      \
+    if (state.begin_impl_frame_state() ==                                  \
+        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)     \
+      state.OnBeginImplFrameIdle();                                        \
   }
 
 #define SET_UP_STATE(state)                                         \
@@ -62,9 +62,11 @@ namespace cc {
 namespace {
 
 const SchedulerStateMachine::BeginImplFrameState all_begin_impl_frame_states[] =
-    {SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE,
-     SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME,
-     SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE, };
+    {
+        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE,
+        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME,
+        SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE,
+};
 
 const SchedulerStateMachine::BeginMainFrameState begin_main_frame_states[] = {
     SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE,
@@ -1115,55 +1117,70 @@ TEST(SchedulerStateMachineTest, TestFullCycleWithCommitToActive) {
 
   // Commit.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
-
-  // Now commit should wait for activation.
+  // Now commit should wait for activation but only momentarily.
   EXPECT_MAIN_FRAME_STATE(
       SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_WAITING_FOR_ACTIVATION);
 
-  // No activation yet, so this commit is not drawn yet. Force to draw this
-  // frame, and still block BeginMainFrame.
-  state.SetNeedsRedraw(true);
+  // Commit always calls NotifyReadyToActivate in this mode.
+  state.NotifyReadyToActivate();
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
+  EXPECT_MAIN_FRAME_STATE(
+      SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW);
+
+  // No draw because we haven't received NotifyReadyToDraw yet.

[brianderson, 2016/09/09 07:35:58]

Thanks for fixing this test. How was it drawing before without the
NotifyReadyToDraw!?

[sunnyps, 2016/09/09 21:21:54]

The scheduler doesn't post a deadline until we get the NotifyReadyToDraw. The
state machine is oblivious about this. After removing retro frames it's possible
for the deadline to run if a new frame comes in.

I plan to simplify the scheduler deadline logic in a follow-up CL.

+  state.OnBeginImplFrameDeadline();
+  EXPECT_TRUE(state.active_tree_needs_first_draw());
+  EXPECT_TRUE(state.needs_redraw());
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+
+  // Cannot BeginMainFrame yet since last commit is not ready to draw.
   state.SetNeedsBeginMainFrame();
+  state.OnBeginImplFrame();
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+  EXPECT_MAIN_FRAME_STATE(
+      SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW);
+
+  // Now call ready to draw which will allow the draw to happen and
+  // BeginMainFrame to be sent.
+  state.NotifyReadyToDraw();
   state.OnBeginImplFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+  state.DidSwapBuffers();
 
-  // Cannot BeginMainFrame yet since last commit is not yet activated and drawn.
+  // Swap throttled from this point.
   state.OnBeginImplFrame();
-  EXPECT_MAIN_FRAME_STATE(
-      SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_WAITING_FOR_ACTIVATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
-  // Now activate sync tree.
+  // Commit, activate and notify ready to draw.
+  state.NotifyBeginMainFrameStarted();
+  state.NotifyReadyToCommit();
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
   state.NotifyReadyToActivate();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
+  state.NotifyReadyToDraw();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
-  EXPECT_TRUE(state.active_tree_needs_first_draw());
-  EXPECT_TRUE(state.needs_redraw());
-  EXPECT_MAIN_FRAME_STATE(
-      SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW);
 
   // Swap throttled. Do not draw.
-  state.DidSwapBuffers();
   state.OnBeginImplFrameDeadline();
+  EXPECT_TRUE(state.active_tree_needs_first_draw());
+  EXPECT_TRUE(state.needs_redraw());
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
-  state.DidSwapBuffersComplete();
 
-  // Haven't draw since last commit, do not begin new main frame.
+  // Haven't drawn since last commit, do not begin new main frame.
+  state.SetNeedsBeginMainFrame();
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+  EXPECT_MAIN_FRAME_STATE(
+      SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_WAITING_FOR_DRAW);
 
-  // At BeginImplFrame deadline, draw. This draws unblocks BeginMainFrame.
+  // Swap ack and draw which also unblocks BeginMainFrame.
+  state.DidSwapBuffersComplete();
   state.OnBeginImplFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  state.DidSwapBuffers();
-  state.DidSwapBuffersComplete();
-
-  // Now will be able to start main frame.
-  EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
-  EXPECT_FALSE(state.needs_redraw());
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }