Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(751)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/scheduler/scheduler_state_machine_unittest.cc

Issue 835783003: Convert the enum objects in cc/scheduler/scheduler_state_machine.h to C++ "enum class" objects (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« cc/scheduler/scheduler_state_machine.h ('K') | « cc/scheduler/scheduler_state_machine.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 1f377b5a1ca182404c3ca15aa90f604b024b96aa..f33fbd199a284c735ddd4a0609978de99737c959 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -14,8 +14,8 @@
// Value of: actual() Actual: 7
// Expected: expected() Which is: 0
// With:
-// Value of: actual() Actual: "ACTION_ANIMATE"
-// Expected: expected() Which is: "ACTION_NONE"
+// Value of: actual() Actual: "Action::ANIMATE"
+// Expected: expected() Which is: "Action::NONE"
#define EXPECT_ENUM_EQ(enum_tostring, expected, actual) \
EXPECT_STREQ(SchedulerStateMachine::enum_tostring(expected), \
SchedulerStateMachine::enum_tostring(actual))
@@ -34,18 +34,18 @@
#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) { \
+ 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); \
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE); \
} \
state.UpdateState(action); \
- if (action == SchedulerStateMachine::ACTION_NONE) { \
+ if (action == SchedulerStateMachine::Action::NONE) { \
if (state.begin_impl_frame_state() == \
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING) \
+ SchedulerStateMachine::BeginImplFrameState::BEGIN_FRAME_STARTING) \
state.OnBeginImplFrameDeadlinePending(); \
if (state.begin_impl_frame_state() == \
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) \
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE) \
state.OnBeginImplFrameIdle(); \
}
@@ -54,18 +54,20 @@ namespace cc {
namespace {
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, };
+ {
+ SchedulerStateMachine::BeginImplFrameState::IDLE,
+ SchedulerStateMachine::BeginImplFrameState::BEGIN_FRAME_STARTING,
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_BEGIN_FRAME,
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE,
+};
const SchedulerStateMachine::CommitState all_commit_states[] = {
- SchedulerStateMachine::COMMIT_STATE_IDLE,
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT,
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED,
- SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
- SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION,
- SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW};
+ SchedulerStateMachine::CommitState::IDLE,
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT,
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_STARTED,
+ SchedulerStateMachine::CommitState::READY_TO_COMMIT,
+ SchedulerStateMachine::CommitState::WAITING_FOR_ACTIVATION,
+ SchedulerStateMachine::CommitState::WAITING_FOR_DRAW};
// Exposes the protected state fields of the SchedulerStateMachine for testing
class StateMachine : public SchedulerStateMachine {
@@ -75,7 +77,7 @@ class StateMachine : public SchedulerStateMachine {
void CreateAndInitializeOutputSurfaceWithActivatedCommit() {
DidCreateAndInitializeOutputSurface();
- output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
+ output_surface_state_ = OutputSurfaceState::ACTIVE;
}
void SetCommitState(CommitState cs) { commit_state_ = cs; }
@@ -102,11 +104,11 @@ class StateMachine : public SchedulerStateMachine {
void SetNeedsRedraw(bool b) { needs_redraw_ = b; }
void SetNeedsForcedRedrawForTimeout(bool b) {
- forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
+ forced_redraw_state_ = ForcedRedrawOnTimeoutState::WAITING_FOR_COMMIT;
active_tree_needs_first_draw_ = true;
}
bool NeedsForcedRedrawForTimeout() const {
- return forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE;
+ return forced_redraw_state_ != ForcedRedrawOnTimeoutState::IDLE;
}
void SetActiveTreeNeedsFirstDraw(bool needs_first_draw) {
@@ -135,45 +137,45 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
StateMachine state(default_scheduler_settings);
state.SetCanStart();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION)
+ SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION)
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ state.SetCommitState(SchedulerStateMachine::CommitState::IDLE);
state.SetNeedsRedraw(false);
state.SetVisible(true);
EXPECT_FALSE(state.BeginFrameNeeded());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.BeginFrameNeeded());
state.OnBeginImplFrame(
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
}
// If commit requested but can_start is still false, do nothing.
{
StateMachine state(default_scheduler_settings);
- state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ state.SetCommitState(SchedulerStateMachine::CommitState::IDLE);
state.SetNeedsRedraw(false);
state.SetVisible(true);
state.SetNeedsCommit();
EXPECT_FALSE(state.BeginFrameNeeded());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.BeginFrameNeeded());
state.OnBeginImplFrame(
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
}
// If commit requested, begin a main frame.
{
StateMachine state(default_scheduler_settings);
- state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ state.SetCommitState(SchedulerStateMachine::CommitState::IDLE);
state.SetCanStart();
state.UpdateState(state.NextAction());
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
@@ -186,7 +188,7 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
state.OnBeginImplFrame(
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
// Begin the frame, make sure needs_commit and commit_state update correctly.
@@ -196,9 +198,9 @@ TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
state.UpdateState(state.NextAction());
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
state.SetVisible(true);
- state.UpdateState(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ state.UpdateState(SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
}
}
@@ -209,7 +211,7 @@ TEST(SchedulerStateMachineTest, MainFrameBeforeActivationEnabled) {
scheduler_settings.impl_side_painting = true;
scheduler_settings.main_frame_before_activation_enabled = true;
StateMachine state(scheduler_settings);
- state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ state.SetCommitState(SchedulerStateMachine::CommitState::IDLE);
state.SetCanStart();
state.UpdateState(state.NextAction());
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
@@ -223,47 +225,47 @@ TEST(SchedulerStateMachineTest, MainFrameBeforeActivationEnabled) {
// Commit to the pending tree.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify that the next commit starts while there is still a pending tree.
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify the pending commit doesn't overwrite the pending
// tree until the pending tree has been activated.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify NotifyReadyToActivate unblocks activation, draw, and
// commit in that order.
state.NotifyReadyToActivate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
}
TEST(SchedulerStateMachineTest,
@@ -279,16 +281,16 @@ TEST(SchedulerStateMachineTest,
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
// We're drawing now.
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.RedrawPending());
EXPECT_FALSE(state.CommitPending());
@@ -296,9 +298,9 @@ TEST(SchedulerStateMachineTest,
// Failing the draw makes us require a commit.
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.CommitPending());
}
@@ -316,14 +318,14 @@ TEST(SchedulerStateMachineTest, TestFailedDrawForMissingHighResNeedsCommit) {
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.RedrawPending());
EXPECT_FALSE(state.CommitPending());
@@ -331,7 +333,7 @@ TEST(SchedulerStateMachineTest, TestFailedDrawForMissingHighResNeedsCommit) {
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_FALSE(state.RedrawPending());
EXPECT_TRUE(state.CommitPending());
}
@@ -350,30 +352,30 @@ TEST(SchedulerStateMachineTest,
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
// We're drawing now.
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.RedrawPending());
EXPECT_FALSE(state.CommitPending());
// While still in the same BeginMainFrame callback on the main thread,
// set needs redraw again. This should not redraw.
state.SetNeedsRedraw(true);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Failing the draw for animation checkerboards makes us require a commit.
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_TRUE(state.RedrawPending());
}
@@ -390,23 +392,23 @@ TEST(SchedulerStateMachineTest,
// Start a commit.
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.CommitPending());
// Then initiate a draw.
state.SetNeedsRedraw(true);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
// Fail the draw.
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.BeginFrameNeeded());
EXPECT_TRUE(state.RedrawPending());
// But the commit is ongoing.
@@ -416,19 +418,19 @@ TEST(SchedulerStateMachineTest,
// continue the commit as usual.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.RedrawPending());
// The redraw should be forced at the end of the next BeginImplFrame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_FORCED);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
}
@@ -448,42 +450,44 @@ TEST(SchedulerStateMachineTest, TestFailedDrawsDoNotRestartForcedDraw) {
// Start a commit.
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.CommitPending());
// Then initiate a draw.
state.SetNeedsRedraw(true);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
// Fail the draw enough times to force a redraw,
// then once more for good measure.
for (int i = 0; i < draw_limit + 1; ++i)
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.BeginFrameNeeded());
EXPECT_TRUE(state.RedrawPending());
// But the commit is ongoing.
EXPECT_TRUE(state.CommitPending());
- EXPECT_TRUE(state.ForcedRedrawState() ==
- SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_COMMIT);
+ EXPECT_TRUE(
+ state.ForcedRedrawState() ==
+ SchedulerStateMachine::ForcedRedrawOnTimeoutState::WAITING_FOR_COMMIT);
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.RedrawPending());
EXPECT_FALSE(state.CommitPending());
// Now force redraw should be in waiting for activation
EXPECT_TRUE(state.ForcedRedrawState() ==
- SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION);
+ SchedulerStateMachine::ForcedRedrawOnTimeoutState::
+ WAITING_FOR_ACTIVATION);
// After failing additional draws, we should still be in a forced
// redraw, but not back in WAITING_FOR_COMMIT.
@@ -491,7 +495,8 @@ TEST(SchedulerStateMachineTest, TestFailedDrawsDoNotRestartForcedDraw) {
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
EXPECT_TRUE(state.RedrawPending());
EXPECT_TRUE(state.ForcedRedrawState() ==
- SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION);
+ SchedulerStateMachine::ForcedRedrawOnTimeoutState::
+ WAITING_FOR_ACTIVATION);
}
TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) {
@@ -507,34 +512,34 @@ TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) {
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_TRUE(state.RedrawPending());
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
// Failing the draw for animation checkerboards makes us require a commit.
state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.RedrawPending());
// We should not be trying to draw again now, but we have a commit pending.
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// We should try to draw again at the end of the next BeginImplFrame on
// the impl thread.
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) {
@@ -550,36 +555,36 @@ TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) {
// Draw the first frame.
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Before the next BeginImplFrame, set needs redraw again.
// This should not redraw until the next BeginImplFrame.
state.SetNeedsRedraw(true);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Move to another frame. This should now draw.
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// We just swapped, so we should proactively request another BeginImplFrame.
EXPECT_TRUE(state.BeginFrameNeeded());
@@ -605,16 +610,16 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnBeginImplFrame) {
state.SetBeginImplFrameState(all_begin_impl_frame_states[j]);
bool visible =
(all_begin_impl_frame_states[j] !=
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE);
state.SetVisible(visible);
// Case 1: needs_commit=false
- EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
+ EXPECT_NE(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE,
state.NextAction());
// Case 2: needs_commit=true
state.SetNeedsCommit();
- EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
+ EXPECT_NE(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE,
state.NextAction())
<< state.AsValue()->ToString();
}
@@ -630,18 +635,19 @@ TEST(SchedulerStateMachineTest, TestNextActionDrawsOnBeginImplFrame) {
state.SetCanDraw(true);
state.SetCommitState(all_commit_states[i]);
state.SetBeginImplFrameState(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE);
state.SetNeedsRedraw(true);
state.SetVisible(true);
SchedulerStateMachine::Action expected_action;
if (all_commit_states[i] ==
- SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT) {
- expected_action = SchedulerStateMachine::ACTION_COMMIT;
+ SchedulerStateMachine::CommitState::READY_TO_COMMIT) {
+ expected_action = SchedulerStateMachine::Action::COMMIT;
} else {
- expected_action = SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
- EXPECT_ACTION(SchedulerStateMachine::ACTION_ANIMATE);
+ expected_action =
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE;
+ EXPECT_ACTION(SchedulerStateMachine::Action::ANIMATE);
state.UpdateState(state.NextAction());
}
@@ -671,16 +677,16 @@ TEST(SchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible) {
state.SetNeedsRedraw(true);
if (j == 1) {
state.SetBeginImplFrameState(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE);
}
// Case 1: needs_commit=false.
- EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
+ EXPECT_NE(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE,
state.NextAction());
// Case 2: needs_commit=true.
state.SetNeedsCommit();
- EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
+ EXPECT_NE(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE,
state.NextAction())
<< state.AsValue()->ToString();
}
@@ -707,7 +713,7 @@ TEST(SchedulerStateMachineTest, TestCanRedraw_StopsDraw) {
CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
state.SetCanDraw(false);
- EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
+ EXPECT_NE(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE,
state.NextAction());
}
}
@@ -727,18 +733,20 @@ TEST(SchedulerStateMachineTest,
state.SetVisible(true);
state.SetCanDraw(false);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest, TestSetNeedsCommitIsNotLost) {
@@ -756,9 +764,9 @@ TEST(SchedulerStateMachineTest, TestSetNeedsCommitIsNotLost) {
// Begin the frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
// Now, while the frame is in progress, set another commit.
state.SetNeedsCommit();
@@ -767,49 +775,49 @@ TEST(SchedulerStateMachineTest, TestSetNeedsCommitIsNotLost) {
// Let the frame finish.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::READY_TO_COMMIT);
// Expect to commit regardless of BeginImplFrame state.
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
+ SchedulerStateMachine::BeginImplFrameState::BEGIN_FRAME_STARTING);
+ EXPECT_ACTION(SchedulerStateMachine::Action::COMMIT);
state.OnBeginImplFrameDeadlinePending();
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_BEGIN_FRAME);
+ EXPECT_ACTION(SchedulerStateMachine::Action::COMMIT);
state.OnBeginImplFrameDeadline();
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::COMMIT);
state.OnBeginImplFrameIdle();
- EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BeginImplFrameState::IDLE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::COMMIT);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
+ SchedulerStateMachine::BeginImplFrameState::BEGIN_FRAME_STARTING);
+ EXPECT_ACTION(SchedulerStateMachine::Action::COMMIT);
// Finish the commit, then make sure we start the next commit immediately
// and draw on the next BeginImplFrame.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest, TestFullCycle) {
@@ -827,37 +835,37 @@ TEST(SchedulerStateMachineTest, TestFullCycle) {
// Begin the frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Tell the scheduler the frame finished.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::READY_TO_COMMIT);
// Commit.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_TRUE(state.needs_redraw());
// Expect to do nothing until BeginImplFrame deadline
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// At BeginImplFrame deadline, draw.
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
// Should be synchronized, no draw needed, no action needed.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
EXPECT_FALSE(state.needs_redraw());
}
@@ -877,51 +885,51 @@ TEST(SchedulerStateMachineTest, TestFullCycleWithMainThreadLowLatencyMode) {
// Begin the frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Tell the scheduler the frame finished.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::READY_TO_COMMIT);
// Commit.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_TRUE(state.needs_redraw());
// Now commit should wait for draw.
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::WAITING_FOR_DRAW);
// Swap throttled. Do not draw.
state.DidSwapBuffers();
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.DidSwapBuffersComplete();
// Haven't draw since last commit, do not begin new main frame.
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// At BeginImplFrame deadline, draw.
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
// Now will be able to start main frame.
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
EXPECT_FALSE(state.needs_redraw());
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest,
@@ -942,73 +950,73 @@ TEST(SchedulerStateMachineTest,
// Begin the frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Tell the scheduler the frame finished.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::READY_TO_COMMIT);
// Commit.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
// Now commit should wait for activation.
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION);
+ SchedulerStateMachine::CommitState::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);
state.SetNeedsCommit();
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Cannot BeginMainFrame yet since last commit is not yet activated and drawn.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::CommitState::WAITING_FOR_ACTIVATION);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Now activate sync tree.
state.NotifyReadyToActivate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_TRUE(state.needs_redraw());
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::WAITING_FOR_DRAW);
// Swap throttled. Do not draw.
state.DidSwapBuffers();
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.DidSwapBuffersComplete();
// Haven't draw since last commit, do not begin new main frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// At BeginImplFrame deadline, draw. This draws unblocks BeginMainFrame.
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
// Now will be able to start main frame.
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
EXPECT_FALSE(state.needs_redraw());
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
@@ -1026,47 +1034,47 @@ TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
// Begin the frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Request another commit while the commit is in flight.
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Tell the scheduler the frame finished.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::READY_TO_COMMIT);
// First commit.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_TRUE(state.needs_redraw());
// Expect to do nothing until BeginImplFrame deadline.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// At BeginImplFrame deadline, draw.
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidDrawIfPossibleCompleted(DRAW_SUCCESS);
state.DidSwapBuffersComplete();
// Should be synchronized, no draw needed, no action needed.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
EXPECT_FALSE(state.needs_redraw());
// Next BeginImplFrame should initiate second commit.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {
@@ -1076,7 +1084,7 @@ TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {
state.UpdateState(state.NextAction());
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
// See ThreadProxy::BeginMainFrame "EarlyOut_NotVisible" /
@@ -1096,11 +1104,11 @@ TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
// Begin the frame while visible.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Become invisible and abort BeginMainFrame.
state.SetVisible(false);
@@ -1111,31 +1119,31 @@ TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
EXPECT_TRUE(state.NeedsCommit());
// We should now be back in the idle state as if we never started the frame.
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// We shouldn't do anything on the BeginImplFrame deadline.
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Become visible again.
state.SetVisible(true);
// Although we have aborted on this frame and haven't cancelled the commit
// (i.e. need another), don't send another BeginMainFrame yet.
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.NeedsCommit());
// Start a new frame.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
// We should be starting the commit now.
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
// See ThreadProxy::BeginMainFrame "EarlyOut_NoUpdates" case.
@@ -1152,11 +1160,11 @@ TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) {
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
// Abort the commit, true means that the BeginMainFrame was sent but there
// was no work to do on the main thread.
@@ -1166,29 +1174,29 @@ TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) {
EXPECT_FALSE(state.NeedsCommit());
// Even though the commit was aborted, we still expect to draw the new frame.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify another commit doesn't start on another frame either.
EXPECT_FALSE(state.NeedsCommit());
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify another commit can start if requested, though.
state.SetNeedsCommit();
- EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE);
+ EXPECT_COMMIT_STATE(SchedulerStateMachine::CommitState::IDLE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION(SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest, TestFirstContextCreation) {
@@ -1199,21 +1207,21 @@ TEST(SchedulerStateMachineTest, TestFirstContextCreation) {
state.SetCanDraw(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Check that the first init does not SetNeedsCommit.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Check that a needs commit initiates a BeginMainFrame.
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
@@ -1226,15 +1234,15 @@ TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
state.SetVisible(true);
state.SetCanDraw(true);
- EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
+ EXPECT_NE(SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION,
state.NextAction());
state.DidLoseOutputSurface();
- EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ EXPECT_ACTION(SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
state.UpdateState(state.NextAction());
// Once context recreation begins, nothing should happen.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Recreate the context.
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
@@ -1242,7 +1250,7 @@ TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) {
// When the context is recreated, we should begin a commit.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest,
@@ -1257,122 +1265,124 @@ TEST(SchedulerStateMachineTest,
state.SetVisible(true);
state.SetCanDraw(true);
- EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION,
+ EXPECT_NE(SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION,
state.NextAction());
state.DidLoseOutputSurface();
EXPECT_EQ(state.output_surface_state(),
- SchedulerStateMachine::OUTPUT_SURFACE_LOST);
+ SchedulerStateMachine::OutputSurfaceState::LOST);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Once context recreation begins, nothing should happen.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// While context is recreating, commits shouldn't begin.
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Recreate the context
state.DidCreateAndInitializeOutputSurface();
- EXPECT_EQ(state.output_surface_state(),
- SchedulerStateMachine::OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT);
+ EXPECT_EQ(
+ state.output_surface_state(),
+ SchedulerStateMachine::OutputSurfaceState::WAITING_FOR_FIRST_COMMIT);
EXPECT_FALSE(state.RedrawPending());
// When the context is recreated, we wait until the next BeginImplFrame
// before starting.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// When the BeginFrame comes in we should begin a commit
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_COMMIT_STATE(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
// Until that commit finishes, we shouldn't be drawing or animate.
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Finish the commit, which should make the surface active.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_EQ(state.output_surface_state(),
- SchedulerStateMachine::OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_EQ(
+ state.output_surface_state(),
+ SchedulerStateMachine::OutputSurfaceState::WAITING_FOR_FIRST_ACTIVATION);
state.NotifyReadyToActivate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_EQ(state.output_surface_state(),
- SchedulerStateMachine::OUTPUT_SURFACE_ACTIVE);
+ SchedulerStateMachine::OutputSurfaceState::ACTIVE);
// Finishing the first commit after initializing an output surface should
// automatically cause a redraw.
EXPECT_TRUE(state.RedrawPending());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.RedrawPending());
// Next frame as no work to do.
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Once the context is recreated, whether we draw should be based on
// SetCanDraw if waiting on first draw after activate.
state.SetNeedsRedraw(true);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.SetCanDraw(false);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
state.SetCanDraw(true);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Once the context is recreated, whether we draw should be based on
// SetCanDraw if waiting on first draw after activate.
state.SetNeedsRedraw(true);
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Activate so we need the first draw
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
state.NotifyReadyToActivate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.active_tree_needs_first_draw());
EXPECT_TRUE(state.needs_redraw());
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.SetCanDraw(false);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION(SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
state.SetCanDraw(true);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
}
TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
@@ -1390,52 +1400,53 @@ TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
// Set damage and expect a draw.
state.SetNeedsRedraw(true);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Cause a lost context while the BeginMainFrame is in flight.
state.DidLoseOutputSurface();
// Ask for another draw. Expect nothing happens.
state.SetNeedsRedraw(true);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
// Finish the frame, and commit.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
// We will abort the draw when the output surface is lost if we are
// waiting for the first draw to unblock the main thread.
EXPECT_TRUE(state.active_tree_needs_first_draw());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
- // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE
- EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ // Expect to begin context recreation only in BeginImplFrameState::IDLE
+ EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BeginImplFrameState::IDLE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::BeginImplFrameState::BEGIN_FRAME_STARTING);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadlinePending();
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_BEGIN_FRAME);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest,
@@ -1450,21 +1461,21 @@ TEST(SchedulerStateMachineTest,
// Get a commit in flight.
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Set damage and expect a draw.
state.SetNeedsRedraw(true);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Cause a lost context while the BeginMainFrame is in flight.
state.DidLoseOutputSurface();
@@ -1472,57 +1483,58 @@ TEST(SchedulerStateMachineTest,
// Ask for another draw and also set needs commit. Expect nothing happens.
state.SetNeedsRedraw(true);
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Finish the frame, and commit.
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
EXPECT_TRUE(state.active_tree_needs_first_draw());
// Because the output surface is missing, we expect the draw to abort.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
- // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE
- EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ // Expect to begin context recreation only in BeginImplFrameState::IDLE
+ EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BeginImplFrameState::IDLE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::BeginImplFrameState::BEGIN_FRAME_STARTING);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadlinePending();
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_BEGIN_FRAME);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_IMPL_FRAME_STATE(
- SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::BeginImplFrameState::INSIDE_DEADLINE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameIdle();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
// After we get a new output surface, the commit flow should start.
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest, DontDrawBeforeCommitAfterLostOutputSurface) {
@@ -1538,13 +1550,13 @@ TEST(SchedulerStateMachineTest, DontDrawBeforeCommitAfterLostOutputSurface) {
// Cause a lost output surface, and restore it.
state.DidLoseOutputSurface();
- EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ EXPECT_ACTION(SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
state.UpdateState(state.NextAction());
state.DidCreateAndInitializeOutputSurface();
EXPECT_FALSE(state.RedrawPending());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION(SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
}
TEST(SchedulerStateMachineTest,
@@ -1559,20 +1571,21 @@ TEST(SchedulerStateMachineTest,
state.SetCanDraw(true);
state.SetCommitState(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
// Cause a lost context.
state.DidLoseOutputSurface();
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
EXPECT_TRUE(state.PendingActivationsShouldBeForced());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE);
EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
}
TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) {
@@ -1583,7 +1596,7 @@ TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) {
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
state.SetVisible(false);
state.SetNeedsCommit();
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) {
@@ -1594,16 +1607,17 @@ TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) {
state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
state.SetVisible(false);
state.SetCommitState(
- SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
+ SchedulerStateMachine::CommitState::BEGIN_MAIN_FRAME_SENT);
state.SetNeedsCommit();
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION(SchedulerStateMachine::Action::COMMIT);
state.UpdateState(state.NextAction());
EXPECT_TRUE(state.active_tree_needs_first_draw());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
+ EXPECT_ACTION_UPDATE_STATE(
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_ABORT);
}
TEST(SchedulerStateMachineTest, TestInitialActionsWhenContextLost) {
@@ -1620,17 +1634,18 @@ TEST(SchedulerStateMachineTest, TestInitialActionsWhenContextLost) {
// When we are visible, we normally want to begin output surface creation
// as soon as possible.
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+ SchedulerStateMachine::Action::BEGIN_OUTPUT_SURFACE_CREATION);
state.DidCreateAndInitializeOutputSurface();
- EXPECT_EQ(state.output_surface_state(),
- SchedulerStateMachine::OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT);
+ EXPECT_EQ(
+ state.output_surface_state(),
+ SchedulerStateMachine::OutputSurfaceState::WAITING_FOR_FIRST_COMMIT);
// We should not send a BeginMainFrame when we are invisible, even if we've
// lost the output surface and are trying to get the first commit, since the
// main thread will just abort anyway.
state.SetVisible(false);
- EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest, ReportIfNotDrawing) {
@@ -1682,10 +1697,10 @@ TEST(SchedulerStateMachineTest,
state.SetNeedsCommit();
// We should start the commit normally.
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Since only the scroll offset changed, the main thread will abort the
// commit.
@@ -1703,20 +1718,20 @@ void FinishPreviousCommitAndDrawWithoutExitingDeadline(
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.NotifyReadyToActivate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ACTIVATE_SYNC_TREE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
}
@@ -1735,10 +1750,10 @@ TEST(SchedulerStateMachineTest, TestImplLatencyTakesPriority) {
state.SetNeedsRedraw(true);
state.SetNeedsCommit();
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify the deadline is not triggered early until we enter
// prefer impl latency mode.
@@ -1749,33 +1764,33 @@ TEST(SchedulerStateMachineTest, TestImplLatencyTakesPriority) {
// Trigger the deadline.
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
state.DidSwapBuffers();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.DidSwapBuffersComplete();
// Request a new commit and finish the previous one.
state.SetNeedsCommit();
FinishPreviousCommitAndDrawWithoutExitingDeadline(&state);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.DidSwapBuffersComplete();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Finish the previous commit and draw it.
FinishPreviousCommitAndDrawWithoutExitingDeadline(&state);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// Verify we do not send another BeginMainFrame if was are swap throttled
// and did not just swap.
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
}
TEST(SchedulerStateMachineTest,
@@ -1792,12 +1807,12 @@ TEST(SchedulerStateMachineTest,
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
state.DidLoseOutputSurface();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
// The deadline should be triggered immediately when output surface is lost.
EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately());
}
@@ -1815,15 +1830,15 @@ TEST(SchedulerStateMachineTest, TestSetNeedsAnimate) {
// Test requesting an animation that, when run, causes us to draw.
state.SetNeedsAnimate();
EXPECT_TRUE(state.BeginFrameNeeded());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
state.OnBeginImplFrameDeadlinePending();
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
}
TEST(SchedulerStateMachineTest, TestAnimateBeforeCommit) {
@@ -1838,20 +1853,20 @@ TEST(SchedulerStateMachineTest, TestAnimateBeforeCommit) {
// Check that animations are updated before we start a commit.
state.SetNeedsAnimate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
state.OnBeginImplFrameDeadlinePending();
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
}
TEST(SchedulerStateMachineTest, TestAnimateAfterCommitBeforeDraw) {
@@ -1866,25 +1881,25 @@ TEST(SchedulerStateMachineTest, TestAnimateAfterCommitBeforeDraw) {
// Check that animations are updated before we start a commit.
state.SetNeedsAnimate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.SetNeedsCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
EXPECT_TRUE(state.BeginFrameNeeded());
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
+ SchedulerStateMachine::Action::SEND_BEGIN_MAIN_FRAME);
state.NotifyBeginMainFrameStarted();
state.NotifyReadyToCommit();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::COMMIT);
state.OnBeginImplFrameDeadlinePending();
state.OnBeginImplFrameDeadline();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
}
TEST(SchedulerStateMachineTest, TestSetNeedsAnimateAfterAnimate) {
@@ -1901,17 +1916,17 @@ TEST(SchedulerStateMachineTest, TestSetNeedsAnimateAfterAnimate) {
// frame.
state.SetNeedsRedraw(true);
EXPECT_TRUE(state.BeginFrameNeeded());
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrame(CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::ANIMATE);
state.SetNeedsAnimate();
- EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+ EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::Action::NONE);
state.OnBeginImplFrameDeadline();
EXPECT_ACTION_UPDATE_STATE(
- SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
+ SchedulerStateMachine::Action::DRAW_AND_SWAP_IF_POSSIBLE);
}
TEST(SchedulerStateMachineTest, TestForwardBeginFramesToChildren) {
« cc/scheduler/scheduler_state_machine.h ('K') | « cc/scheduler/scheduler_state_machine.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698