cc/scheduler_state_machine_unittest.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/scheduler_state_machine.h"
   6
   7 #include "cc/scheduler.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace cc {
  11
  12 namespace {
  13
  14 const SchedulerStateMachine::CommitState allCommitStates[] = {
  15     SchedulerStateMachine::COMMIT_STATE_IDLE,
  16     SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
  17     SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT,
  18     SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW
  19 };
  20
  21 // Exposes the protected state fields of the SchedulerStateMachine for testing
  22 class StateMachine : public SchedulerStateMachine {
  23 public:
  24     StateMachine(const SchedulerSettings& schedulerSettings)
  25       : SchedulerStateMachine(schedulerSettings) { }
  26     void setCommitState(CommitState cs) { m_commitState = cs; }
  27     CommitState commitState() const { return  m_commitState; }
  28
  29     bool needsCommit() const { return m_needsCommit; }
  30
  31     void setNeedsRedraw(bool b) { m_needsRedraw = b; }
  32     bool needsRedraw() const { return m_needsRedraw; }
  33
  34     void setNeedsForcedRedraw(bool b) { m_needsForcedRedraw = b; }
  35     bool needsForcedRedraw() const { return m_needsForcedRedraw; }
  36
  37     bool canDraw() const { return m_canDraw; }
  38     bool insideVSync() const { return m_insideVSync; }
  39     bool visible() const { return m_visible; }
  40 };
  41
  42 TEST(SchedulerStateMachineTest, TestNextActionBeginsFrameIfNeeded)
  43 {
  44     SchedulerSettings defaultSchedulerSettings;
  45
  46     // If no commit needed, do nothing
  47     {
  48         StateMachine state(defaultSchedulerSettings);
  49         state.setCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
  50         state.setCanBeginFrame(true);
  51         state.setNeedsRedraw(false);
  52         state.setVisible(true);
  53
  54         EXPECT_FALSE(state.vsyncCallbackNeeded());
  55
  56         state.didLeaveVSync();
  57         EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
  58         EXPECT_FALSE(state.vsyncCallbackNeeded());
  59         state.didEnterVSync();
  60         EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
  61     }
  62
  63     // If commit requested but canBeginFrame is still false, do nothing.
  64     {
  65         StateMachine state(defaultSchedulerSettings);
  66         state.setCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
  67         state.setNeedsRedraw(false);
  68         state.setVisible(true);
  69
  70         EXPECT_FALSE(state.vsyncCallbackNeeded());
  71
  72         state.didLeaveVSync();
  73         EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
  74         EXPECT_FALSE(state.vsyncCallbackNeeded());
  75         state.didEnterVSync();
  76         EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
  77     }
  78
  79
  80     // If commit requested, begin a frame
  81     {
  82         StateMachine state(defaultSchedulerSettings);
  83         state.setCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
  84         state.setCanBeginFrame(true);
  85         state.setNeedsRedraw(false);
  86         state.setVisible(true);
  87         EXPECT_FALSE(state.vsyncCallbackNeeded());
  88     }
  89
  90     // Begin the frame, make sure needsCommit and commitState update correctly.
  91     {
  92         StateMachine state(defaultSchedulerSettings);
  93         state.setCanBeginFrame(true);
  94         state.setVisible(true);
  95         state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
  96         EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
  97         EXPECT_FALSE(state.needsCommit());
  98         EXPECT_FALSE(state.vsyncCallbackNeeded());
  99     }
 100 }
 101
 102 TEST(SchedulerStateMachineTest, TestSetForcedRedrawDoesNotSetsNormalRedraw)
 103 {
 104     SchedulerSettings defaultSchedulerSettings;
 105     SchedulerStateMachine state(defaultSchedulerSettings);
 106     state.setCanDraw(true);
 107     state.setNeedsForcedRedraw();
 108     EXPECT_FALSE(state.redrawPending());
 109     EXPECT_TRUE(state.vsyncCallbackNeeded());
 110 }
 111
 112 TEST(SchedulerStateMachineTest, TestFailedDrawSetsNeedsCommitAndDoesNotDrawAgain)
 113 {
 114     SchedulerSettings defaultSchedulerSettings;
 115     SchedulerStateMachine state(defaultSchedulerSettings);
 116     state.setCanBeginFrame(true);
 117     state.setVisible(true);
 118     state.setCanDraw(true);
 119     state.setNeedsRedraw();
 120     EXPECT_TRUE(state.redrawPending());
 121     EXPECT_TRUE(state.vsyncCallbackNeeded());
 122     state.didEnterVSync();
 123
 124     // We're drawing now.
 125     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 126     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 127     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 128     EXPECT_FALSE(state.redrawPending());
 129     EXPECT_FALSE(state.commitPending());
 130
 131     // Failing the draw makes us require a commit.
 132     state.didDrawIfPossibleCompleted(false);
 133     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 134     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 135     EXPECT_TRUE(state.redrawPending());
 136     EXPECT_TRUE(state.commitPending());
 137 }
 138
 139 TEST(SchedulerStateMachineTest, TestSetNeedsRedrawDuringFailedDrawDoesNotRemoveNeedsRedraw)
 140 {
 141     SchedulerSettings defaultSchedulerSettings;
 142     SchedulerStateMachine state(defaultSchedulerSettings);
 143     state.setCanBeginFrame(true);
 144     state.setVisible(true);
 145     state.setCanDraw(true);
 146     state.setNeedsRedraw();
 147     EXPECT_TRUE(state.redrawPending());
 148     EXPECT_TRUE(state.vsyncCallbackNeeded());
 149     state.didEnterVSync();
 150
 151     // We're drawing now.
 152     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 153     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 154     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 155     EXPECT_FALSE(state.redrawPending());
 156     EXPECT_FALSE(state.commitPending());
 157
 158     // While still in the same vsync callback, set needs redraw again.
 159     // This should not redraw.
 160     state.setNeedsRedraw();
 161     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 162
 163     // Failing the draw makes us require a commit.
 164     state.didDrawIfPossibleCompleted(false);
 165     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 166     EXPECT_TRUE(state.redrawPending());
 167 }
 168
 169 TEST(SchedulerStateMachineTest, TestCommitAfterFailedDrawAllowsDrawInSameFrame)
 170 {
 171     SchedulerSettings defaultSchedulerSettings;
 172     SchedulerStateMachine state(defaultSchedulerSettings);
 173     state.setCanBeginFrame(true);
 174     state.setVisible(true);
 175     state.setCanDraw(true);
 176
 177     // Start a commit.
 178     state.setNeedsCommit();
 179     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 180     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 181     EXPECT_TRUE(state.commitPending());
 182
 183     // Then initiate a draw.
 184     state.setNeedsRedraw();
 185     EXPECT_TRUE(state.vsyncCallbackNeeded());
 186     state.didEnterVSync();
 187     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 188     EXPECT_TRUE(state.redrawPending());
 189
 190     // Fail the draw.
 191     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 192     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 193     state.didDrawIfPossibleCompleted(false);
 194     EXPECT_TRUE(state.redrawPending());
 195     // But the commit is ongoing.
 196     EXPECT_TRUE(state.commitPending());
 197
 198     // Finish the commit.
 199     state.beginFrameComplete();
 200     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 201     state.updateState(SchedulerStateMachine::ACTION_COMMIT);
 202     EXPECT_TRUE(state.redrawPending());
 203
 204     // And we should be allowed to draw again.
 205     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 206 }
 207
 208 TEST(SchedulerStateMachineTest, TestCommitAfterFailedAndSuccessfulDrawDoesNotAllowDrawInSameFrame)
 209 {
 210     SchedulerSettings defaultSchedulerSettings;
 211     SchedulerStateMachine state(defaultSchedulerSettings);
 212     state.setCanBeginFrame(true);
 213     state.setVisible(true);
 214     state.setCanDraw(true);
 215
 216     // Start a commit.
 217     state.setNeedsCommit();
 218     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 219     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 220     EXPECT_TRUE(state.commitPending());
 221
 222     // Then initiate a draw.
 223     state.setNeedsRedraw();
 224     EXPECT_TRUE(state.vsyncCallbackNeeded());
 225     state.didEnterVSync();
 226     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 227     EXPECT_TRUE(state.redrawPending());
 228
 229     // Fail the draw.
 230     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 231     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 232     state.didDrawIfPossibleCompleted(false);
 233     EXPECT_TRUE(state.redrawPending());
 234     // But the commit is ongoing.
 235     EXPECT_TRUE(state.commitPending());
 236
 237     // Force a draw.
 238     state.setNeedsForcedRedraw();
 239     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 240
 241     // Do the forced draw.
 242     state.updateState(SchedulerStateMachine::ACTION_DRAW_FORCED);
 243     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 244     EXPECT_FALSE(state.redrawPending());
 245     // And the commit is still ongoing.
 246     EXPECT_TRUE(state.commitPending());
 247
 248     // Finish the commit.
 249     state.beginFrameComplete();
 250     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 251     state.updateState(SchedulerStateMachine::ACTION_COMMIT);
 252     EXPECT_TRUE(state.redrawPending());
 253
 254     // And we should not be allowed to draw again in the same frame..
 255     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 256 }
 257
 258 TEST(SchedulerStateMachineTest, TestFailedDrawsWillEventuallyForceADrawAfterTheNextCommit)
 259 {
 260     SchedulerSettings defaultSchedulerSettings;
 261     SchedulerStateMachine state(defaultSchedulerSettings);
 262     state.setCanBeginFrame(true);
 263     state.setVisible(true);
 264     state.setCanDraw(true);
 265     state.setMaximumNumberOfFailedDrawsBeforeDrawIsForced(1);
 266
 267     // Start a commit.
 268     state.setNeedsCommit();
 269     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 270     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 271     EXPECT_TRUE(state.commitPending());
 272
 273     // Then initiate a draw.
 274     state.setNeedsRedraw();
 275     EXPECT_TRUE(state.vsyncCallbackNeeded());
 276     state.didEnterVSync();
 277     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 278     EXPECT_TRUE(state.redrawPending());
 279
 280     // Fail the draw.
 281     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 282     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 283     state.didDrawIfPossibleCompleted(false);
 284     EXPECT_TRUE(state.redrawPending());
 285     // But the commit is ongoing.
 286     EXPECT_TRUE(state.commitPending());
 287
 288     // Finish the commit. Note, we should not yet be forcing a draw, but should
 289     // continue the commit as usual.
 290     state.beginFrameComplete();
 291     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 292     state.updateState(SchedulerStateMachine::ACTION_COMMIT);
 293     EXPECT_TRUE(state.redrawPending());
 294
 295     // The redraw should be forced in this case.
 296     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 297 }
 298
 299 TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedNextVSync)
 300 {
 301     SchedulerSettings defaultSchedulerSettings;
 302     SchedulerStateMachine state(defaultSchedulerSettings);
 303     state.setCanBeginFrame(true);
 304     state.setVisible(true);
 305     state.setCanDraw(true);
 306
 307     // Start a draw.
 308     state.setNeedsRedraw();
 309     EXPECT_TRUE(state.vsyncCallbackNeeded());
 310     state.didEnterVSync();
 311     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 312     EXPECT_TRUE(state.redrawPending());
 313
 314     // Fail the draw.
 315     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 316     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 317     state.didDrawIfPossibleCompleted(false);
 318     EXPECT_TRUE(state.redrawPending());
 319
 320     // We should not be trying to draw again now, but we have a commit pending.
 321     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 322
 323     state.didLeaveVSync();
 324     EXPECT_TRUE(state.vsyncCallbackNeeded());
 325     state.didEnterVSync();
 326
 327     // We should try draw again in the next vsync.
 328     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 329 }
 330
 331 TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame)
 332 {
 333     SchedulerSettings defaultSchedulerSettings;
 334     SchedulerStateMachine state(defaultSchedulerSettings);
 335     state.setVisible(true);
 336     state.setCanDraw(true);
 337     state.setNeedsRedraw();
 338     EXPECT_TRUE(state.vsyncCallbackNeeded());
 339     state.didEnterVSync();
 340     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 341     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 342
 343     // While still in the same vsync callback, set needs redraw again.
 344     // This should not redraw.
 345     state.setNeedsRedraw();
 346     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 347
 348     // Move to another frame. This should now draw.
 349     state.didDrawIfPossibleCompleted(true);
 350     state.didLeaveVSync();
 351     EXPECT_TRUE(state.vsyncCallbackNeeded());
 352     state.didEnterVSync();
 353
 354     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 355     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 356     state.didDrawIfPossibleCompleted(true);
 357     EXPECT_FALSE(state.vsyncCallbackNeeded());
 358 }
 359
 360 TEST(SchedulerStateMachineTest, TestNextActionDrawsOnVSync)
 361 {
 362     SchedulerSettings defaultSchedulerSettings;
 363
 364     // When not on vsync, or on vsync but not visible, don't draw.
 365     size_t numCommitStates = sizeof(allCommitStates) / sizeof(SchedulerStateMachine::CommitState);
 366     for (size_t i = 0; i < numCommitStates; ++i) {
 367         for (unsigned j = 0; j < 2; ++j) {
 368             StateMachine state(defaultSchedulerSettings);
 369             state.setCommitState(allCommitStates[i]);
 370             bool visible = j;
 371             if (!visible) {
 372                 state.didEnterVSync();
 373                 state.setVisible(false);
 374             } else
 375                 state.setVisible(true);
 376
 377             // Case 1: needsCommit=false
 378             EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 379
 380             // Case 2: needsCommit=true
 381             state.setNeedsCommit();
 382             EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 383         }
 384     }
 385
 386     // When on vsync, or not on vsync but needsForcedRedraw set, should always draw except if you're ready to commit, in which case commit.
 387     for (size_t i = 0; i < numCommitStates; ++i) {
 388         for (unsigned j = 0; j < 2; ++j) {
 389             StateMachine state(defaultSchedulerSettings);
 390             state.setCanDraw(true);
 391             state.setCommitState(allCommitStates[i]);
 392             bool forcedDraw = j;
 393             if (!forcedDraw) {
 394                 state.didEnterVSync();
 395                 state.setNeedsRedraw(true);
 396                 state.setVisible(true);
 397             } else
 398                 state.setNeedsForcedRedraw(true);
 399
 400             SchedulerStateMachine::Action expectedAction;
 401             if (allCommitStates[i] != SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT)
 402                 expectedAction = forcedDraw ? SchedulerStateMachine::ACTION_DRAW_FORCED : SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE;
 403             else
 404                 expectedAction = SchedulerStateMachine::ACTION_COMMIT;
 405
 406             // Case 1: needsCommit=false.
 407             EXPECT_TRUE(state.vsyncCallbackNeeded());
 408             EXPECT_EQ(expectedAction, state.nextAction());
 409
 410             // Case 2: needsCommit=true.
 411             state.setNeedsCommit();
 412             EXPECT_TRUE(state.vsyncCallbackNeeded());
 413             EXPECT_EQ(expectedAction, state.nextAction());
 414         }
 415     }
 416 }
 417
 418 TEST(SchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible)
 419 {
 420     SchedulerSettings defaultSchedulerSettings;
 421
 422     size_t numCommitStates = sizeof(allCommitStates) / sizeof(SchedulerStateMachine::CommitState);
 423     for (size_t i = 0; i < numCommitStates; ++i) {
 424         // There shouldn't be any drawing regardless of vsync.
 425         for (unsigned j = 0; j < 2; ++j) {
 426             StateMachine state(defaultSchedulerSettings);
 427             state.setCommitState(allCommitStates[i]);
 428             state.setVisible(false);
 429             state.setNeedsRedraw(true);
 430             state.setNeedsForcedRedraw(false);
 431             if (j == 1)
 432                 state.didEnterVSync();
 433
 434             // Case 1: needsCommit=false.
 435             EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 436
 437             // Case 2: needsCommit=true.
 438             state.setNeedsCommit();
 439             EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 440         }
 441     }
 442 }
 443
 444 TEST(SchedulerStateMachineTest, TestCanRedraw_StopsDraw)
 445 {
 446     SchedulerSettings defaultSchedulerSettings;
 447
 448     size_t numCommitStates = sizeof(allCommitStates) / sizeof(SchedulerStateMachine::CommitState);
 449     for (size_t i = 0; i < numCommitStates; ++i) {
 450         // There shouldn't be any drawing regardless of vsync.
 451         for (unsigned j = 0; j < 2; ++j) {
 452             StateMachine state(defaultSchedulerSettings);
 453             state.setCommitState(allCommitStates[i]);
 454             state.setVisible(false);
 455             state.setNeedsRedraw(true);
 456             state.setNeedsForcedRedraw(false);
 457             if (j == 1)
 458                 state.didEnterVSync();
 459
 460             state.setCanDraw(false);
 461             EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 462         }
 463     }
 464 }
 465
 466 TEST(SchedulerStateMachineTest, TestCanRedrawWithWaitingForFirstDrawMakesProgress)
 467 {
 468     SchedulerSettings defaultSchedulerSettings;
 469     StateMachine state(defaultSchedulerSettings);
 470     state.setCommitState(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW);
 471     state.setCanBeginFrame(true);
 472     state.setNeedsCommit();
 473     state.setNeedsRedraw(true);
 474     state.setVisible(true);
 475     state.setCanDraw(false);
 476     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 477 }
 478
 479 TEST(SchedulerStateMachineTest, TestSetNeedsCommitIsNotLost)
 480 {
 481     SchedulerSettings defaultSchedulerSettings;
 482     StateMachine state(defaultSchedulerSettings);
 483     state.setCanBeginFrame(true);
 484     state.setNeedsCommit();
 485     state.setVisible(true);
 486     state.setCanDraw(true);
 487
 488     // Begin the frame.
 489     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 490     state.updateState(state.nextAction());
 491     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 492
 493     // Now, while the frame is in progress, set another commit.
 494     state.setNeedsCommit();
 495     EXPECT_TRUE(state.needsCommit());
 496
 497     // Let the frame finish.
 498     state.beginFrameComplete();
 499     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 500
 501     // Expect to commit regardless of vsync state.
 502     state.didLeaveVSync();
 503     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 504     state.didEnterVSync();
 505     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 506
 507     // Commit and make sure we draw on next vsync
 508     state.updateState(SchedulerStateMachine::ACTION_COMMIT);
 509     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 510     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 511     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 512     state.didDrawIfPossibleCompleted(true);
 513
 514     // Verify that another commit will begin.
 515     state.didLeaveVSync();
 516     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 517 }
 518
 519 TEST(SchedulerStateMachineTest, TestFullCycle)
 520 {
 521     SchedulerSettings defaultSchedulerSettings;
 522     StateMachine state(defaultSchedulerSettings);
 523     state.setCanBeginFrame(true);
 524     state.setVisible(true);
 525     state.setCanDraw(true);
 526
 527     // Start clean and set commit.
 528     state.setNeedsCommit();
 529     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 530
 531     // Begin the frame.
 532     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 533     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 534     EXPECT_FALSE(state.needsCommit());
 535     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 536
 537     // Tell the scheduler the frame finished.
 538     state.beginFrameComplete();
 539     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 540     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 541
 542     // Commit.
 543     state.updateState(SchedulerStateMachine::ACTION_COMMIT);
 544     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 545     EXPECT_TRUE(state.needsRedraw());
 546
 547     // Expect to do nothing until vsync.
 548     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 549
 550     // At vsync, draw.
 551     state.didEnterVSync();
 552     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 553     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 554     state.didDrawIfPossibleCompleted(true);
 555     state.didLeaveVSync();
 556
 557     // Should be synchronized, no draw needed, no action needed.
 558     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.commitState());
 559     EXPECT_FALSE(state.needsRedraw());
 560     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 561 }
 562
 563 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween)
 564 {
 565     SchedulerSettings defaultSchedulerSettings;
 566     StateMachine state(defaultSchedulerSettings);
 567     state.setCanBeginFrame(true);
 568     state.setVisible(true);
 569     state.setCanDraw(true);
 570
 571     // Start clean and set commit.
 572     state.setNeedsCommit();
 573     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 574
 575     // Begin the frame.
 576     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 577     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 578     EXPECT_FALSE(state.needsCommit());
 579     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 580
 581     // Request another commit while the commit is in flight.
 582     state.setNeedsCommit();
 583     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 584
 585     // Tell the scheduler the frame finished.
 586     state.beginFrameComplete();
 587     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 588     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 589
 590     // Commit.
 591     state.updateState(SchedulerStateMachine::ACTION_COMMIT);
 592     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 593     EXPECT_TRUE(state.needsRedraw());
 594
 595     // Expect to do nothing until vsync.
 596     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 597
 598     // At vsync, draw.
 599     state.didEnterVSync();
 600     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 601     state.updateState(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE);
 602     state.didDrawIfPossibleCompleted(true);
 603     state.didLeaveVSync();
 604
 605     // Should be synchronized, no draw needed, no action needed.
 606     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.commitState());
 607     EXPECT_FALSE(state.needsRedraw());
 608     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 609 }
 610
 611 TEST(SchedulerStateMachineTest, TestRequestCommitInvisible)
 612 {
 613     SchedulerSettings defaultSchedulerSettings;
 614     StateMachine state(defaultSchedulerSettings);
 615     state.setNeedsCommit();
 616     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 617 }
 618
 619 TEST(SchedulerStateMachineTest, TestGoesInvisibleBeforeBeginFrameCompletes)
 620 {
 621     SchedulerSettings defaultSchedulerSettings;
 622     StateMachine state(defaultSchedulerSettings);
 623     state.setCanBeginFrame(true);
 624     state.setVisible(true);
 625     state.setCanDraw(true);
 626
 627     // Start clean and set commit.
 628     state.setNeedsCommit();
 629     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 630
 631     // Begin the frame while visible.
 632     state.updateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
 633     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 634     EXPECT_FALSE(state.needsCommit());
 635     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 636
 637     // Become invisible and abort the beginFrame.
 638     state.setVisible(false);
 639     state.beginFrameAborted();
 640
 641     // We should now be back in the idle state as if we didn't start a frame at all.
 642     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.commitState());
 643     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 644
 645     // Become visible again
 646     state.setVisible(true);
 647
 648     // We should be beginning a frame now
 649     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.commitState());
 650     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 651
 652     // Begin the frame
 653     state.updateState(state.nextAction());
 654
 655     // We should be starting the commit now
 656     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 657 }
 658
 659 TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle)
 660 {
 661     SchedulerSettings defaultSchedulerSettings;
 662     StateMachine state(defaultSchedulerSettings);
 663     state.setCanBeginFrame(true);
 664     state.setVisible(true);
 665     state.setCanDraw(true);
 666
 667     state.didLoseOutputSurface();
 668
 669     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 670     state.updateState(state.nextAction());
 671
 672     // Once context recreation begins, nothing should happen.
 673     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 674
 675     // Recreate the context
 676     state.didRecreateOutputSurface();
 677
 678     // When the context is recreated, we should begin a commit
 679     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 680     state.updateState(state.nextAction());
 681 }
 682
 683 TEST(SchedulerStateMachineTest, TestContextLostWhenIdleAndCommitRequestedWhileRecreating)
 684 {
 685     SchedulerSettings defaultSchedulerSettings;
 686     StateMachine state(defaultSchedulerSettings);
 687     state.setCanBeginFrame(true);
 688     state.setVisible(true);
 689     state.setCanDraw(true);
 690
 691     state.didLoseOutputSurface();
 692
 693     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 694     state.updateState(state.nextAction());
 695
 696     // Once context recreation begins, nothing should happen.
 697     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 698
 699     // While context is recreating, commits shouldn't begin.
 700     state.setNeedsCommit();
 701     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 702
 703     // Recreate the context
 704     state.didRecreateOutputSurface();
 705
 706     // When the context is recreated, we should begin a commit
 707     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 708     state.updateState(state.nextAction());
 709
 710     // Once the context is recreated, whether we draw should be based on
 711     // setCanDraw.
 712     state.setNeedsRedraw(true);
 713     state.didEnterVSync();
 714     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 715     state.setCanDraw(false);
 716     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 717     state.setCanDraw(true);
 718     state.didLeaveVSync();
 719 }
 720
 721 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress)
 722 {
 723     SchedulerSettings defaultSchedulerSettings;
 724     StateMachine state(defaultSchedulerSettings);
 725     state.setCanBeginFrame(true);
 726     state.setVisible(true);
 727     state.setCanDraw(true);
 728
 729     // Get a commit in flight.
 730     state.setNeedsCommit();
 731     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 732     state.updateState(state.nextAction());
 733
 734     // Set damage and expect a draw.
 735     state.setNeedsRedraw(true);
 736     state.didEnterVSync();
 737     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 738     state.updateState(state.nextAction());
 739     state.didLeaveVSync();
 740
 741     // Cause a lost context while the begin frame is in flight.
 742     state.didLoseOutputSurface();
 743
 744     // Ask for another draw. Expect nothing happens.
 745     state.setNeedsRedraw(true);
 746     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 747
 748     // Finish the frame, and commit.
 749     state.beginFrameComplete();
 750     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 751     state.updateState(state.nextAction());
 752
 753     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 754
 755     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 756     state.updateState(state.nextAction());
 757
 758     // Expect to be told to begin context recreation, independent of vsync state
 759     state.didEnterVSync();
 760     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 761     state.didLeaveVSync();
 762     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 763 }
 764
 765 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgressAndAnotherCommitRequested)
 766 {
 767     SchedulerSettings defaultSchedulerSettings;
 768     StateMachine state(defaultSchedulerSettings);
 769     state.setCanBeginFrame(true);
 770     state.setVisible(true);
 771     state.setCanDraw(true);
 772
 773     // Get a commit in flight.
 774     state.setNeedsCommit();
 775     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 776     state.updateState(state.nextAction());
 777
 778     // Set damage and expect a draw.
 779     state.setNeedsRedraw(true);
 780     state.didEnterVSync();
 781     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 782     state.updateState(state.nextAction());
 783     state.didLeaveVSync();
 784
 785     // Cause a lost context while the begin frame is in flight.
 786     state.didLoseOutputSurface();
 787
 788     // Ask for another draw and also set needs commit. Expect nothing happens.
 789     state.setNeedsRedraw(true);
 790     state.setNeedsCommit();
 791     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 792
 793     // Finish the frame, and commit.
 794     state.beginFrameComplete();
 795     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 796     state.updateState(state.nextAction());
 797
 798     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 799
 800     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.nextAction());
 801     state.updateState(state.nextAction());
 802
 803     // Expect to be told to begin context recreation, independent of vsync state
 804     state.didEnterVSync();
 805     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 806     state.didLeaveVSync();
 807     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 808 }
 809
 810
 811 TEST(SchedulerStateMachineTest, TestFinishAllRenderingWhileContextLost)
 812 {
 813     SchedulerSettings defaultSchedulerSettings;
 814     StateMachine state(defaultSchedulerSettings);
 815     state.setVisible(true);
 816     state.setCanDraw(true);
 817
 818     // Cause a lost context lost.
 819     state.didLoseOutputSurface();
 820
 821     // Ask a forced redraw and verify it ocurrs.
 822     state.setNeedsForcedRedraw(true);
 823     state.didEnterVSync();
 824     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 825     state.didLeaveVSync();
 826
 827     // Clear the forced redraw bit.
 828     state.setNeedsForcedRedraw(false);
 829
 830     // Expect to be told to begin context recreation, independent of vsync state
 831     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_RECREATION, state.nextAction());
 832     state.updateState(state.nextAction());
 833
 834     // Ask a forced redraw and verify it ocurrs.
 835     state.setNeedsForcedRedraw(true);
 836     state.didEnterVSync();
 837     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 838     state.didLeaveVSync();
 839 }
 840
 841 TEST(SchedulerStateMachineTest, TestBeginFrameWhenInvisibleAndForceCommit)
 842 {
 843     SchedulerSettings defaultSchedulerSettings;
 844     StateMachine state(defaultSchedulerSettings);
 845     state.setCanBeginFrame(true);
 846     state.setVisible(false);
 847     state.setNeedsCommit();
 848     state.setNeedsForcedCommit();
 849     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 850 }
 851
 852 TEST(SchedulerStateMachineTest, TestBeginFrameWhenCanBeginFrameFalseAndForceCommit)
 853 {
 854     SchedulerSettings defaultSchedulerSettings;
 855     StateMachine state(defaultSchedulerSettings);
 856     state.setVisible(true);
 857     state.setCanDraw(true);
 858     state.setNeedsCommit();
 859     state.setNeedsForcedCommit();
 860     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 861 }
 862
 863 TEST(SchedulerStateMachineTest, TestBeginFrameWhenCommitInProgress)
 864 {
 865     SchedulerSettings defaultSchedulerSettings;
 866     StateMachine state(defaultSchedulerSettings);
 867     state.setCanBeginFrame(true);
 868     state.setVisible(false);
 869     state.setCommitState(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS);
 870     state.setNeedsCommit();
 871
 872     state.beginFrameComplete();
 873     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 874     state.updateState(state.nextAction());
 875
 876     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_DRAW, state.commitState());
 877
 878     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 879 }
 880
 881 TEST(SchedulerStateMachineTest, TestBeginFrameWhenForcedCommitInProgress)
 882 {
 883     SchedulerSettings defaultSchedulerSettings;
 884     StateMachine state(defaultSchedulerSettings);
 885     state.setCanBeginFrame(true);
 886     state.setVisible(false);
 887     state.setCommitState(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS);
 888     state.setNeedsCommit();
 889     state.setNeedsForcedCommit();
 890
 891     state.beginFrameComplete();
 892     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 893     state.updateState(state.nextAction());
 894
 895     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW, state.commitState());
 896
 897     // If we are waiting for forced draw then we know a begin frame is already in flight.
 898     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 899 }
 900
 901 TEST(SchedulerStateMachineTest, TestBeginFrameWhenContextLost)
 902 {
 903     SchedulerSettings defaultSchedulerSettings;
 904     StateMachine state(defaultSchedulerSettings);
 905     state.setCanBeginFrame(true);
 906     state.setVisible(true);
 907     state.setCanDraw(true);
 908     state.setNeedsCommit();
 909     state.setNeedsForcedCommit();
 910     state.didLoseOutputSurface();
 911     EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.nextAction());
 912 }
 913
 914 TEST(SchedulerStateMachineTest, TestImmediateBeginFrame)
 915 {
 916     SchedulerSettings defaultSchedulerSettings;
 917     StateMachine state(defaultSchedulerSettings);
 918     state.setCanBeginFrame(true);
 919     state.setVisible(true);
 920     state.setCanDraw(true);
 921
 922     // Schedule a forced frame, commit it, draw it.
 923     state.setNeedsCommit();
 924     state.setNeedsForcedCommit();
 925     state.updateState(state.nextAction());
 926     state.beginFrameComplete();
 927     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 928     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 929     state.updateState(state.nextAction());
 930
 931     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW, state.commitState());
 932
 933     state.didEnterVSync();
 934     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 935     state.setNeedsForcedRedraw(true);
 936     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 937     state.updateState(state.nextAction());
 938     state.didDrawIfPossibleCompleted(true);
 939     state.didLeaveVSync();
 940
 941     // Should be waiting for the normal begin frame
 942     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState());
 943 }
 944
 945 TEST(SchedulerStateMachineTest, TestImmediateBeginFrameDuringCommit)
 946 {
 947     SchedulerSettings defaultSchedulerSettings;
 948     StateMachine state(defaultSchedulerSettings);
 949     state.setCanBeginFrame(true);
 950     state.setVisible(true);
 951     state.setCanDraw(true);
 952
 953     // Start a normal commit.
 954     state.setNeedsCommit();
 955     state.updateState(state.nextAction());
 956
 957     // Schedule a forced frame, commit it, draw it.
 958     state.setNeedsCommit();
 959     state.setNeedsForcedCommit();
 960     state.updateState(state.nextAction());
 961     state.beginFrameComplete();
 962     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 963     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 964     state.updateState(state.nextAction());
 965
 966     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW, state.commitState());
 967
 968     state.didEnterVSync();
 969     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
 970     state.setNeedsForcedRedraw(true);
 971     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
 972     state.updateState(state.nextAction());
 973     state.didDrawIfPossibleCompleted(true);
 974     state.didLeaveVSync();
 975
 976     // Should be waiting for the normal begin frame
 977     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState()) << state.toString();
 978 }
 979
 980 TEST(SchedulerStateMachineTest, ImmediateBeginFrameWhileInvisible)
 981 {
 982     SchedulerSettings defaultSchedulerSettings;
 983     StateMachine state(defaultSchedulerSettings);
 984     state.setCanBeginFrame(true);
 985     state.setVisible(true);
 986     state.setCanDraw(true);
 987
 988     state.setNeedsCommit();
 989     state.updateState(state.nextAction());
 990
 991     state.setNeedsCommit();
 992     state.setNeedsForcedCommit();
 993     state.updateState(state.nextAction());
 994     state.beginFrameComplete();
 995
 996     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
 997     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
 998     state.updateState(state.nextAction());
 999
1000     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW, state.commitState());
1001
1002     state.didEnterVSync();
1003     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
1004     state.setNeedsForcedRedraw(true);
1005     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
1006     state.updateState(state.nextAction());
1007     state.didDrawIfPossibleCompleted(true);
1008     state.didLeaveVSync();
1009
1010     // Should be waiting for the normal begin frame
1011     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS, state.commitState()) << state.toString();
1012
1013
1014     // Become invisible and abort the "normal" begin frame.
1015     state.setVisible(false);
1016     state.beginFrameAborted();
1017
1018     // Should be back in the idle state, but needing a commit.
1019     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.commitState());
1020     EXPECT_TRUE(state.needsCommit());
1021 }
1022
1023 TEST(SchedulerStateMachineTest, ImmediateBeginFrameWhileCantDraw)
1024 {
1025     SchedulerSettings defaultSchedulerSettings;
1026     StateMachine state(defaultSchedulerSettings);
1027     state.setCanBeginFrame(true);
1028     state.setVisible(true);
1029     state.setCanDraw(false);
1030
1031     state.setNeedsCommit();
1032     state.updateState(state.nextAction());
1033
1034     state.setNeedsCommit();
1035     state.setNeedsForcedCommit();
1036     state.updateState(state.nextAction());
1037     state.beginFrameComplete();
1038
1039     EXPECT_EQ(SchedulerStateMachine::ACTION_COMMIT, state.nextAction());
1040     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, state.commitState());
1041     state.updateState(state.nextAction());
1042
1043     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW, state.commitState());
1044
1045     state.didEnterVSync();
1046     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.nextAction());
1047     state.setNeedsForcedRedraw(true);
1048     EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.nextAction());
1049     state.updateState(state.nextAction());
1050     state.didDrawIfPossibleCompleted(true);
1051     state.didLeaveVSync();
1052 }
1053
1054 }  // namespace
1055 }  // namespace cc