cc: Remove SchedulerStateMachine::UpdateState

cc/scheduler/scheduler_state_machine_unittest.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/trace_event/trace_event.h"
 #include "cc/scheduler/scheduler.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 22 matching lines @@
   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);     \
   }                                                                         \
-  state.UpdateState(action);                                                \
+  WillPerformAction(&state, action);                                        \
   if (action == SchedulerStateMachine::ACTION_NONE) {                       \
     if (state.begin_impl_frame_state() ==                                   \
         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING) \
       state.OnBeginImplFrameDeadlinePending();                              \
     if (state.begin_impl_frame_state() ==                                   \
         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)      \
       state.OnBeginImplFrameIdle();                                         \
   }
 
-#define SET_UP_STATE(state)                                    \
-  state.SetCanStart();                                         \
-  state.UpdateState(state.NextAction());                       \
-  state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); \
-  state.SetVisible(true);                                      \
+#define SET_UP_STATE(state)                                         \
+  state.SetCanStart();                                              \
+  EXPECT_ACTION_UPDATE_STATE(                                       \
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); \
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);   \
+  state.CreateAndInitializeOutputSurfaceWithActivatedCommit();      \
+  state.SetVisible(true);                                           \
   state.SetCanDraw(true);
 
 namespace cc {
 
 namespace {
 
+void WillPerformAction(SchedulerStateMachine* sm,
+                       SchedulerStateMachine::Action action) {
+  switch (action) {
+    case SchedulerStateMachine::ACTION_NONE:
+      return;
+
+    case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE:
+      sm->WillActivate();
+      return;
+
+    case SchedulerStateMachine::ACTION_ANIMATE:
+      sm->WillAnimate();
+      return;
+
+    case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
+      sm->WillSendBeginMainFrame();
+      return;
+
+    case SchedulerStateMachine::ACTION_COMMIT: {
+      bool commit_has_no_updates = false;
+      sm->WillCommit(commit_has_no_updates);
+      return;
+    }
+
+    case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED:
+    case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE: {
+      bool did_request_swap = true;
+      sm->WillDraw(did_request_swap);
+      return;
+    }
+
+    case SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT: {
+      bool did_request_swap = false;
+      sm->WillDraw(did_request_swap);
+      return;
+    }
+
+    case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
+      sm->WillBeginOutputSurfaceCreation();
+      return;
+
+    case SchedulerStateMachine::ACTION_PREPARE_TILES:
+      sm->WillPrepareTiles();
+      return;
+
+    case SchedulerStateMachine::ACTION_INVALIDATE_OUTPUT_SURFACE:
+      sm->WillInvalidateOutputSurface();
+      return;
+  }
+}
+
 const SchedulerStateMachine::BeginImplFrameState all_begin_impl_frame_states[] =
     {SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE,
      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING,
      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,
     SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT,
     SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_STARTED,
@@ skipping 65 matching lines @@
   bool PendingActivationsShouldBeForced() const {
     return SchedulerStateMachine::PendingActivationsShouldBeForced();
   }
 
   void SetHasPendingTree(bool has_pending_tree) {
     has_pending_tree_ = has_pending_tree;
   }
 
   using SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately;
   using SchedulerStateMachine::ProactiveBeginFrameWanted;
-  using SchedulerStateMachine::UpdateStateOnCommit;
+  using SchedulerStateMachine::WillCommit;
 };
 
 TEST(SchedulerStateMachineTest, BeginFrameNeeded) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
   EXPECT_ACTION_UPDATE_STATE(
-      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION)
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetBeginMainFrameState(
       SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
 
   // Don't request BeginFrames if we are idle.
   state.SetVisible(true);
   state.SetNeedsRedraw(false);
   state.SetNeedsAnimateForTest(false);
   EXPECT_FALSE(state.BeginFrameNeeded());
 
@@ skipping 27 matching lines @@
 }
 
 TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
   SchedulerSettings default_scheduler_settings;
 
   // If no commit needed, do nothing.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCanStart();
     EXPECT_ACTION_UPDATE_STATE(
-        SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION)
+        SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+    EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
 
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_FALSE(state.NeedsCommit());
 
     state.OnBeginImplFrame();
@@ skipping 23 matching lines @@
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_TRUE(state.NeedsCommit());
   }
 
   // If commit requested, begin a main frame.
   {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetCanStart();
-    state.UpdateState(state.NextAction());
+    EXPECT_ACTION_UPDATE_STATE(
+        SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+    EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
     state.SetNeedsBeginMainFrame();
 
     // Expect nothing to happen until after OnBeginImplFrame.
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
     EXPECT_TRUE(state.NeedsCommit());
     EXPECT_TRUE(state.BeginFrameNeeded());
 
     state.OnBeginImplFrame();
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
     EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
     EXPECT_FALSE(state.NeedsCommit());
   }
 
   // If commit requested and can't draw, still begin a main frame.
   {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetCanStart();
-    state.UpdateState(state.NextAction());
+    EXPECT_ACTION_UPDATE_STATE(
+        SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+    EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
     state.SetNeedsBeginMainFrame();
     state.SetCanDraw(false);
 
     // Expect nothing to happen until after OnBeginImplFrame.
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
@@ skipping 369 matching lines @@
   size_t num_begin_main_frame_states =
       sizeof(begin_main_frame_states) /
       sizeof(SchedulerStateMachine::BeginMainFrameState);
   size_t num_begin_impl_frame_states =
       sizeof(all_begin_impl_frame_states) /
       sizeof(SchedulerStateMachine::BeginImplFrameState);
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     for (size_t j = 0; j < num_begin_impl_frame_states; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
-      state.UpdateState(state.NextAction());
+      EXPECT_ACTION_UPDATE_STATE(
+          SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+      EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
       state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
       state.SetBeginMainFrameState(begin_main_frame_states[i]);
       state.SetBeginImplFrameState(all_begin_impl_frame_states[j]);
       bool visible =
           (all_begin_impl_frame_states[j] !=
            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
       state.SetVisible(visible);
 
       // Case 1: needs_begin_main_frame=false
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
                 state.NextAction());
 
       // Case 2: needs_begin_main_frame=true
       state.SetNeedsBeginMainFrame();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
                 state.NextAction())
           << state.AsValue()->ToString();
     }
   }
 
   // When in BeginImplFrame deadline we should always draw for SetNeedsRedraw
   // except if we're ready to commit, in which case we expect a commit first.
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     StateMachine state(default_scheduler_settings);
     state.SetCanStart();
-    state.UpdateState(state.NextAction());
+    EXPECT_ACTION_UPDATE_STATE(
+        SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+    EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetCanDraw(true);
     state.SetBeginMainFrameState(begin_main_frame_states[i]);
     state.SetBeginImplFrameState(
         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
 
     state.SetNeedsRedraw(true);
     state.SetVisible(true);
 
     SchedulerStateMachine::Action expected_action;
     if (begin_main_frame_states[i] ==
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT) {
       expected_action = SchedulerStateMachine::ACTION_COMMIT;
     } else {
       expected_action = SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
-      EXPECT_ACTION(SchedulerStateMachine::ACTION_ANIMATE);
-      state.UpdateState(state.NextAction());
+      EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
     }
 
     // Case 1: needs_begin_main_frame=false.
     EXPECT_ACTION(expected_action);
 
     // Case 2: needs_begin_main_frame=true.
     state.SetNeedsBeginMainFrame();
     EXPECT_ACTION(expected_action);
   }
 }
 
 TEST(SchedulerStateMachineTest, TestNoBeginMainFrameStatesRedrawWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
 
   size_t num_begin_main_frame_states =
       sizeof(begin_main_frame_states) /
       sizeof(SchedulerStateMachine::BeginMainFrameState);
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     // There shouldn't be any drawing regardless of BeginImplFrame.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
-      state.UpdateState(state.NextAction());
+      EXPECT_ACTION_UPDATE_STATE(
+          SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+      EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
       state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
       state.SetBeginMainFrameState(begin_main_frame_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       if (j == 1) {
         state.SetBeginImplFrameState(
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
       }
 
       // Case 1: needs_begin_main_frame=false.
@@ skipping 13 matching lines @@
   SchedulerSettings default_scheduler_settings;
 
   size_t num_begin_main_frame_states =
       sizeof(begin_main_frame_states) /
       sizeof(SchedulerStateMachine::BeginMainFrameState);
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     // There shouldn't be any drawing regardless of BeginImplFrame.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
-      state.UpdateState(state.NextAction());
+      EXPECT_ACTION_UPDATE_STATE(
+          SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+      EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
       state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
       state.SetBeginMainFrameState(begin_main_frame_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       if (j == 1)
         state.OnBeginImplFrame();
 
       state.SetCanDraw(false);
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 }
 
 TEST(SchedulerStateMachineTest,
      TestCanRedrawWithWaitingForFirstDrawMakesProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
 
   state.SetActiveTreeNeedsFirstDraw(true);
   state.SetNeedsBeginMainFrame();
   state.SetNeedsRedraw(true);
   state.SetVisible(true);
   state.SetCanDraw(false);
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
@@ skipping 322 matching lines @@
   // Next BeginImplFrame should initiate second commit.
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }
 
 TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetNeedsBeginMainFrame();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 }
 
 // See ThreadProxy::BeginMainFrame "EarlyOut_NotVisible" /
 // "EarlyOut_OutputSurfaceLost" cases.
 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
@@ skipping 43 matching lines @@
   // We should be starting the commit now.
   EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 }
 
 // See ThreadProxy::BeginMainFrame "EarlyOut_NoUpdates" case.
 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.DidCreateAndInitializeOutputSurface();
   state.SetVisible(true);
   state.SetCanDraw(true);
 
   // Get into a begin frame / commit state.
   state.SetNeedsBeginMainFrame();
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
   EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
@@ skipping 60 matching lines @@
 
 TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   SET_UP_STATE(state)
 
   EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
             state.NextAction());
   state.DidLoseOutputSurface();
 
-  EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // Once context recreation begins, nothing should happen.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // Recreate the context.
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
 
   // When the context is recreated, we should begin a commit.
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
@@ skipping 274 matching lines @@
 
 TEST(SchedulerStateMachineTest, DontDrawBeforeCommitAfterLostOutputSurface) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   SET_UP_STATE(state)
 
   state.SetNeedsRedraw(true);
 
   // Cause a lost output surface, and restore it.
   state.DidLoseOutputSurface();
-  EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.DidCreateAndInitializeOutputSurface();
 
   EXPECT_FALSE(state.RedrawPending());
   state.OnBeginImplFrame();
   EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }
 
 TEST(SchedulerStateMachineTest,
      TestPendingActivationsShouldBeForcedAfterLostOutputSurface) {
   SchedulerSettings default_scheduler_settings;
@@ skipping 14 matching lines @@
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
 
   EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
 }
 
 TEST(SchedulerStateMachineTest, TestNoBeginFrameNeededWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetVisible(true);
 
   EXPECT_FALSE(state.BeginFrameNeeded());
   state.SetNeedsRedraw(true);
   EXPECT_TRUE(state.BeginFrameNeeded());
 
   state.SetVisible(false);
   EXPECT_FALSE(state.BeginFrameNeeded());
 
   state.SetVisible(true);
   EXPECT_TRUE(state.BeginFrameNeeded());
 }
 
 TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetVisible(false);
   state.SetNeedsBeginMainFrame();
   EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
   EXPECT_FALSE(state.BeginFrameNeeded());
 
   // When become visible again, the needs commit should still be pending.
   state.SetVisible(true);
   EXPECT_TRUE(state.BeginFrameNeeded());
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }
 
 TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
-  state.UpdateState(state.NextAction());
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetVisible(false);
   state.SetBeginMainFrameState(
       SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
   state.SetNeedsBeginMainFrame();
 
+  // After the commit completes, activation and draw happen immediately
+  // because we are not visible.
   state.NotifyBeginMainFrameStarted();
   state.NotifyReadyToCommit();
-  EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
-  state.UpdateState(state.NextAction());
-  state.NotifyReadyToActivate();
-  EXPECT_ACTION(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
-  state.UpdateState(state.NextAction());
-
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
   EXPECT_TRUE(state.active_tree_needs_first_draw());
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 }
 
 TEST(SchedulerStateMachineTest, TestInitialActionsWhenContextLost) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   SET_UP_STATE(state)
   state.SetNeedsBeginMainFrame();
   state.DidLoseOutputSurface();
 
   // When we are visible, we normally want to begin output surface creation
@@ skipping 305 matching lines @@
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }
 
 TEST(SchedulerStateMachineTest, EarlyOutCommitWantsProactiveBeginFrame) {
   SchedulerSettings settings;
   StateMachine state(settings);
   SET_UP_STATE(state);
 
   EXPECT_FALSE(state.ProactiveBeginFrameWanted());
   bool commit_has_no_updates = true;
-  state.UpdateStateOnCommit(commit_has_no_updates);
+  state.WillCommit(commit_has_no_updates);
   EXPECT_TRUE(state.ProactiveBeginFrameWanted());
   state.OnBeginImplFrame();
   EXPECT_FALSE(state.ProactiveBeginFrameWanted());
 }
 
 }  // namespace
 }  // namespace cc