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