| OLD | NEW |
|---|
| (Empty) | |
| 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/scheduler_state_machine.h" |
| 6 |
| 7 #include "base/trace_event/trace_event.h" |
| 8 #include "cc/scheduler/scheduler.h" |
| 9 #include "cc/test/begin_frame_args_test.h" |
| 10 #include "testing/gtest/include/gtest/gtest.h" |
| 11 |
| 12 // Macro to compare two enum values and get nice output. |
| 13 // Without: |
| 14 // Value of: actual() Actual: 7 |
| 15 // Expected: expected() Which is: 0 |
| 16 // With: |
| 17 // Value of: actual() Actual: "ACTION_ANIMATE" |
| 18 // Expected: expected() Which is: "ACTION_NONE" |
| 19 #define EXPECT_ENUM_EQ(enum_tostring, expected, actual) \ |
| 20 EXPECT_STREQ(SchedulerStateMachine::enum_tostring(expected), \ |
| 21 SchedulerStateMachine::enum_tostring(actual)) |
| 22 |
| 23 #define EXPECT_IMPL_FRAME_STATE(expected) \ |
| 24 EXPECT_ENUM_EQ(BeginImplFrameStateToString, expected, \ |
| 25 state.begin_impl_frame_state()) \ |
| 26 << state.AsValue()->ToString() |
| 27 |
| 28 #define EXPECT_COMMIT_STATE(expected) \ |
| 29 EXPECT_ENUM_EQ(CommitStateToString, expected, state.CommitState()) |
| 30 |
| 31 #define EXPECT_ACTION(expected) \ |
| 32 EXPECT_ENUM_EQ(ActionToString, expected, state.NextAction()) \ |
| 33 << state.AsValue()->ToString() |
| 34 |
| 35 #define EXPECT_ACTION_UPDATE_STATE(action) \ |
| 36 EXPECT_ACTION(action); \ |
| 37 if (action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE || \ |
| 38 action == SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED) { \ |
| 39 EXPECT_IMPL_FRAME_STATE( \ |
| 40 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); \ |
| 41 } \ |
| 42 state.UpdateState(action); \ |
| 43 if (action == SchedulerStateMachine::ACTION_NONE) { \ |
| 44 if (state.begin_impl_frame_state() == \ |
| 45 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING) \ |
| 46 state.OnBeginImplFrameDeadlinePending(); \ |
| 47 if (state.begin_impl_frame_state() == \ |
| 48 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) \ |
| 49 state.OnBeginImplFrameIdle(); \ |
| 50 } |
| 51 |
| 52 #define SET_UP_STATE(state) \ |
| 53 state.SetCanStart(); \ |
| 54 state.UpdateState(state.NextAction()); \ |
| 55 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); \ |
| 56 state.SetVisible(true); \ |
| 57 state.SetCanDraw(true); |
| 58 |
| 59 namespace cc { |
| 60 |
| 61 namespace { |
| 62 |
| 63 const SchedulerStateMachine::BeginImplFrameState all_begin_impl_frame_states[] = |
| 64 {SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE, |
| 65 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING, |
| 66 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME, |
| 67 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE, }; |
| 68 |
| 69 const SchedulerStateMachine::CommitState all_commit_states[] = { |
| 70 SchedulerStateMachine::COMMIT_STATE_IDLE, |
| 71 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT, |
| 72 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED, |
| 73 SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT, |
| 74 SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION, |
| 75 SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW}; |
| 76 |
| 77 // Exposes the protected state fields of the SchedulerStateMachine for testing |
| 78 class StateMachine : public SchedulerStateMachine { |
| 79 public: |
| 80 explicit StateMachine(const SchedulerSettings& scheduler_settings) |
| 81 : SchedulerStateMachine(scheduler_settings) {} |
| 82 |
| 83 void CreateAndInitializeOutputSurfaceWithActivatedCommit() { |
| 84 DidCreateAndInitializeOutputSurface(); |
| 85 output_surface_state_ = OUTPUT_SURFACE_ACTIVE; |
| 86 } |
| 87 |
| 88 void SetCommitState(CommitState cs) { commit_state_ = cs; } |
| 89 CommitState CommitState() const { return commit_state_; } |
| 90 |
| 91 ForcedRedrawOnTimeoutState ForcedRedrawState() const { |
| 92 return forced_redraw_state_; |
| 93 } |
| 94 |
| 95 void SetBeginImplFrameState(BeginImplFrameState bifs) { |
| 96 begin_impl_frame_state_ = bifs; |
| 97 } |
| 98 |
| 99 BeginImplFrameState begin_impl_frame_state() const { |
| 100 return begin_impl_frame_state_; |
| 101 } |
| 102 |
| 103 OutputSurfaceState output_surface_state() const { |
| 104 return output_surface_state_; |
| 105 } |
| 106 |
| 107 bool NeedsCommit() const { return needs_commit_; } |
| 108 |
| 109 void SetNeedsRedraw(bool b) { needs_redraw_ = b; } |
| 110 |
| 111 void SetNeedsForcedRedrawForTimeout(bool b) { |
| 112 forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT; |
| 113 active_tree_needs_first_draw_ = true; |
| 114 } |
| 115 bool NeedsForcedRedrawForTimeout() const { |
| 116 return forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE; |
| 117 } |
| 118 |
| 119 void SetActiveTreeNeedsFirstDraw(bool needs_first_draw) { |
| 120 active_tree_needs_first_draw_ = needs_first_draw; |
| 121 } |
| 122 |
| 123 bool CanDraw() const { return can_draw_; } |
| 124 bool Visible() const { return visible_; } |
| 125 |
| 126 bool PendingActivationsShouldBeForced() const { |
| 127 return SchedulerStateMachine::PendingActivationsShouldBeForced(); |
| 128 } |
| 129 |
| 130 void SetHasPendingTree(bool has_pending_tree) { |
| 131 has_pending_tree_ = has_pending_tree; |
| 132 } |
| 133 |
| 134 using SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately; |
| 135 using SchedulerStateMachine::ProactiveBeginFrameWanted; |
| 136 using SchedulerStateMachine::UpdateStateOnCommit; |
| 137 }; |
| 138 |
| 139 TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) { |
| 140 SchedulerSettings default_scheduler_settings; |
| 141 |
| 142 // If no commit needed, do nothing. |
| 143 { |
| 144 StateMachine state(default_scheduler_settings); |
| 145 state.SetCanStart(); |
| 146 EXPECT_ACTION_UPDATE_STATE( |
| 147 SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION) |
| 148 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 149 state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 150 state.SetNeedsRedraw(false); |
| 151 state.SetVisible(true); |
| 152 |
| 153 EXPECT_FALSE(state.BeginFrameNeeded()); |
| 154 |
| 155 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 156 EXPECT_FALSE(state.BeginFrameNeeded()); |
| 157 state.OnBeginImplFrame(); |
| 158 |
| 159 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 160 state.OnBeginImplFrameDeadline(); |
| 161 } |
| 162 |
| 163 // If commit requested but can_start is still false, do nothing. |
| 164 { |
| 165 StateMachine state(default_scheduler_settings); |
| 166 state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 167 state.SetNeedsRedraw(false); |
| 168 state.SetVisible(true); |
| 169 state.SetNeedsCommit(); |
| 170 |
| 171 EXPECT_FALSE(state.BeginFrameNeeded()); |
| 172 |
| 173 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 174 EXPECT_FALSE(state.BeginFrameNeeded()); |
| 175 state.OnBeginImplFrame(); |
| 176 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 177 state.OnBeginImplFrameDeadline(); |
| 178 } |
| 179 |
| 180 // If commit requested, begin a main frame. |
| 181 { |
| 182 StateMachine state(default_scheduler_settings); |
| 183 state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 184 state.SetCanStart(); |
| 185 state.UpdateState(state.NextAction()); |
| 186 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 187 state.SetNeedsRedraw(false); |
| 188 state.SetVisible(true); |
| 189 state.SetNeedsCommit(); |
| 190 |
| 191 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 192 |
| 193 state.OnBeginImplFrame(); |
| 194 EXPECT_ACTION_UPDATE_STATE( |
| 195 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 196 } |
| 197 |
| 198 // Begin the frame, make sure needs_commit and commit_state update correctly. |
| 199 { |
| 200 StateMachine state(default_scheduler_settings); |
| 201 state.SetCanStart(); |
| 202 state.UpdateState(state.NextAction()); |
| 203 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 204 state.SetVisible(true); |
| 205 state.UpdateState(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 206 EXPECT_COMMIT_STATE( |
| 207 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 208 EXPECT_FALSE(state.NeedsCommit()); |
| 209 } |
| 210 } |
| 211 |
| 212 // Explicitly test main_frame_before_activation_enabled = true |
| 213 TEST(SchedulerStateMachineTest, MainFrameBeforeActivationEnabled) { |
| 214 SchedulerSettings scheduler_settings; |
| 215 scheduler_settings.impl_side_painting = true; |
| 216 scheduler_settings.main_frame_before_activation_enabled = true; |
| 217 StateMachine state(scheduler_settings); |
| 218 state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 219 SET_UP_STATE(state) |
| 220 state.SetNeedsRedraw(false); |
| 221 state.SetNeedsCommit(); |
| 222 |
| 223 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 224 |
| 225 // Commit to the pending tree. |
| 226 state.OnBeginImplFrame(); |
| 227 EXPECT_ACTION_UPDATE_STATE( |
| 228 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 229 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 230 |
| 231 state.NotifyBeginMainFrameStarted(); |
| 232 state.NotifyReadyToCommit(); |
| 233 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 234 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 235 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 236 |
| 237 state.OnBeginImplFrameDeadline(); |
| 238 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 239 |
| 240 // Verify that the next commit starts while there is still a pending tree. |
| 241 state.SetNeedsCommit(); |
| 242 state.OnBeginImplFrame(); |
| 243 EXPECT_ACTION_UPDATE_STATE( |
| 244 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 245 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 246 |
| 247 // Verify the pending commit doesn't overwrite the pending |
| 248 // tree until the pending tree has been activated. |
| 249 state.NotifyBeginMainFrameStarted(); |
| 250 state.NotifyReadyToCommit(); |
| 251 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 252 |
| 253 // Verify NotifyReadyToActivate unblocks activation, draw, and |
| 254 // commit in that order. |
| 255 state.NotifyReadyToActivate(); |
| 256 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
| 257 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 258 |
| 259 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 260 state.OnBeginImplFrameDeadline(); |
| 261 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 262 EXPECT_ACTION_UPDATE_STATE( |
| 263 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 264 state.DidSwapBuffers(); |
| 265 state.DidSwapBuffersComplete(); |
| 266 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 267 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 268 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 269 } |
| 270 |
| 271 TEST(SchedulerStateMachineTest, |
| 272 TestFailedDrawForAnimationCheckerboardSetsNeedsCommitAndDoesNotDrawAgain) { |
| 273 SchedulerSettings default_scheduler_settings; |
| 274 StateMachine state(default_scheduler_settings); |
| 275 SET_UP_STATE(state) |
| 276 state.SetNeedsRedraw(true); |
| 277 EXPECT_TRUE(state.RedrawPending()); |
| 278 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 279 state.OnBeginImplFrame(); |
| 280 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 281 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 282 state.OnBeginImplFrameDeadline(); |
| 283 |
| 284 // We're drawing now. |
| 285 EXPECT_ACTION_UPDATE_STATE( |
| 286 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 287 state.DidSwapBuffers(); |
| 288 state.DidSwapBuffersComplete(); |
| 289 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 290 |
| 291 EXPECT_FALSE(state.RedrawPending()); |
| 292 EXPECT_FALSE(state.CommitPending()); |
| 293 |
| 294 // Failing the draw makes us require a commit. |
| 295 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
| 296 state.OnBeginImplFrame(); |
| 297 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 298 EXPECT_ACTION_UPDATE_STATE( |
| 299 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 300 EXPECT_TRUE(state.RedrawPending()); |
| 301 EXPECT_TRUE(state.CommitPending()); |
| 302 } |
| 303 |
| 304 TEST(SchedulerStateMachineTest, TestFailedDrawForMissingHighResNeedsCommit) { |
| 305 SchedulerSettings default_scheduler_settings; |
| 306 StateMachine state(default_scheduler_settings); |
| 307 SET_UP_STATE(state) |
| 308 state.SetNeedsRedraw(true); |
| 309 EXPECT_TRUE(state.RedrawPending()); |
| 310 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 311 |
| 312 state.OnBeginImplFrame(); |
| 313 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 314 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 315 state.OnBeginImplFrameDeadline(); |
| 316 EXPECT_ACTION_UPDATE_STATE( |
| 317 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 318 state.DidSwapBuffers(); |
| 319 state.DidSwapBuffersComplete(); |
| 320 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 321 EXPECT_FALSE(state.RedrawPending()); |
| 322 EXPECT_FALSE(state.CommitPending()); |
| 323 |
| 324 // Missing high res content requires a commit (but not a redraw) |
| 325 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT); |
| 326 state.OnBeginImplFrame(); |
| 327 EXPECT_ACTION_UPDATE_STATE( |
| 328 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 329 EXPECT_FALSE(state.RedrawPending()); |
| 330 EXPECT_TRUE(state.CommitPending()); |
| 331 } |
| 332 |
| 333 TEST(SchedulerStateMachineTest, |
| 334 TestsetNeedsRedrawDuringFailedDrawDoesNotRemoveNeedsRedraw) { |
| 335 SchedulerSettings default_scheduler_settings; |
| 336 StateMachine state(default_scheduler_settings); |
| 337 SET_UP_STATE(state) |
| 338 state.SetNeedsRedraw(true); |
| 339 EXPECT_TRUE(state.RedrawPending()); |
| 340 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 341 state.OnBeginImplFrame(); |
| 342 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 343 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 344 state.OnBeginImplFrameDeadline(); |
| 345 |
| 346 // We're drawing now. |
| 347 EXPECT_ACTION_UPDATE_STATE( |
| 348 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 349 state.DidSwapBuffers(); |
| 350 state.DidSwapBuffersComplete(); |
| 351 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 352 EXPECT_FALSE(state.RedrawPending()); |
| 353 EXPECT_FALSE(state.CommitPending()); |
| 354 |
| 355 // While still in the same BeginMainFrame callback on the main thread, |
| 356 // set needs redraw again. This should not redraw. |
| 357 state.SetNeedsRedraw(true); |
| 358 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 359 |
| 360 // Failing the draw for animation checkerboards makes us require a commit. |
| 361 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
| 362 state.OnBeginImplFrame(); |
| 363 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 364 EXPECT_ACTION_UPDATE_STATE( |
| 365 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 366 EXPECT_TRUE(state.RedrawPending()); |
| 367 } |
| 368 |
| 369 TEST(SchedulerStateMachineTest, |
| 370 TestFailedDrawsEventuallyForceDrawAfterNextCommit) { |
| 371 SchedulerSettings scheduler_settings; |
| 372 scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced_ = 1; |
| 373 StateMachine state(scheduler_settings); |
| 374 SET_UP_STATE(state) |
| 375 |
| 376 // Start a commit. |
| 377 state.SetNeedsCommit(); |
| 378 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 379 state.OnBeginImplFrame(); |
| 380 EXPECT_ACTION_UPDATE_STATE( |
| 381 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 382 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 383 EXPECT_TRUE(state.CommitPending()); |
| 384 |
| 385 // Then initiate a draw. |
| 386 state.SetNeedsRedraw(true); |
| 387 state.OnBeginImplFrameDeadline(); |
| 388 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 389 EXPECT_ACTION_UPDATE_STATE( |
| 390 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 391 |
| 392 // Fail the draw. |
| 393 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
| 394 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 395 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 396 EXPECT_TRUE(state.RedrawPending()); |
| 397 // But the commit is ongoing. |
| 398 EXPECT_TRUE(state.CommitPending()); |
| 399 |
| 400 // Finish the commit. Note, we should not yet be forcing a draw, but should |
| 401 // continue the commit as usual. |
| 402 state.NotifyBeginMainFrameStarted(); |
| 403 state.NotifyReadyToCommit(); |
| 404 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 405 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 406 EXPECT_TRUE(state.RedrawPending()); |
| 407 |
| 408 // The redraw should be forced at the end of the next BeginImplFrame. |
| 409 state.OnBeginImplFrame(); |
| 410 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 411 EXPECT_ACTION_UPDATE_STATE( |
| 412 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 413 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 414 state.OnBeginImplFrameDeadline(); |
| 415 EXPECT_ACTION_UPDATE_STATE( |
| 416 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_FORCED); |
| 417 state.DidSwapBuffers(); |
| 418 state.DidSwapBuffersComplete(); |
| 419 } |
| 420 |
| 421 TEST(SchedulerStateMachineTest, TestFailedDrawsDoNotRestartForcedDraw) { |
| 422 SchedulerSettings scheduler_settings; |
| 423 int draw_limit = 1; |
| 424 scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced_ = |
| 425 draw_limit; |
| 426 scheduler_settings.impl_side_painting = true; |
| 427 StateMachine state(scheduler_settings); |
| 428 SET_UP_STATE(state) |
| 429 |
| 430 // Start a commit. |
| 431 state.SetNeedsCommit(); |
| 432 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 433 state.OnBeginImplFrame(); |
| 434 EXPECT_ACTION_UPDATE_STATE( |
| 435 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 436 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 437 EXPECT_TRUE(state.CommitPending()); |
| 438 |
| 439 // Then initiate a draw. |
| 440 state.SetNeedsRedraw(true); |
| 441 state.OnBeginImplFrameDeadline(); |
| 442 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 443 EXPECT_ACTION_UPDATE_STATE( |
| 444 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 445 |
| 446 // Fail the draw enough times to force a redraw, |
| 447 // then once more for good measure. |
| 448 for (int i = 0; i < draw_limit + 1; ++i) |
| 449 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
| 450 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 451 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 452 EXPECT_TRUE(state.RedrawPending()); |
| 453 // But the commit is ongoing. |
| 454 EXPECT_TRUE(state.CommitPending()); |
| 455 EXPECT_TRUE(state.ForcedRedrawState() == |
| 456 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_COMMIT); |
| 457 |
| 458 state.NotifyBeginMainFrameStarted(); |
| 459 state.NotifyReadyToCommit(); |
| 460 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 461 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 462 EXPECT_TRUE(state.RedrawPending()); |
| 463 EXPECT_FALSE(state.CommitPending()); |
| 464 |
| 465 // Now force redraw should be in waiting for activation |
| 466 EXPECT_TRUE(state.ForcedRedrawState() == |
| 467 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION); |
| 468 |
| 469 // After failing additional draws, we should still be in a forced |
| 470 // redraw, but not back in WAITING_FOR_COMMIT. |
| 471 for (int i = 0; i < draw_limit + 1; ++i) |
| 472 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
| 473 EXPECT_TRUE(state.RedrawPending()); |
| 474 EXPECT_TRUE(state.ForcedRedrawState() == |
| 475 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION); |
| 476 } |
| 477 |
| 478 TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) { |
| 479 SchedulerSettings default_scheduler_settings; |
| 480 StateMachine state(default_scheduler_settings); |
| 481 SET_UP_STATE(state) |
| 482 |
| 483 // Start a draw. |
| 484 state.SetNeedsRedraw(true); |
| 485 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 486 state.OnBeginImplFrame(); |
| 487 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 488 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 489 state.OnBeginImplFrameDeadline(); |
| 490 EXPECT_TRUE(state.RedrawPending()); |
| 491 EXPECT_ACTION_UPDATE_STATE( |
| 492 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 493 |
| 494 // Failing the draw for animation checkerboards makes us require a commit. |
| 495 state.DidDrawIfPossibleCompleted(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
| 496 EXPECT_ACTION_UPDATE_STATE( |
| 497 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 498 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 499 EXPECT_TRUE(state.RedrawPending()); |
| 500 |
| 501 // We should not be trying to draw again now, but we have a commit pending. |
| 502 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 503 state.OnBeginImplFrame(); |
| 504 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 505 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 506 |
| 507 // We should try to draw again at the end of the next BeginImplFrame on |
| 508 // the impl thread. |
| 509 state.OnBeginImplFrameDeadline(); |
| 510 EXPECT_ACTION_UPDATE_STATE( |
| 511 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 512 state.DidSwapBuffers(); |
| 513 state.DidSwapBuffersComplete(); |
| 514 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 515 } |
| 516 |
| 517 TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) { |
| 518 SchedulerSettings default_scheduler_settings; |
| 519 StateMachine state(default_scheduler_settings); |
| 520 SET_UP_STATE(state) |
| 521 state.SetNeedsRedraw(true); |
| 522 |
| 523 // Draw the first frame. |
| 524 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 525 state.OnBeginImplFrame(); |
| 526 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 527 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 528 |
| 529 state.OnBeginImplFrameDeadline(); |
| 530 EXPECT_ACTION_UPDATE_STATE( |
| 531 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 532 state.DidSwapBuffers(); |
| 533 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 534 state.DidSwapBuffersComplete(); |
| 535 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 536 |
| 537 // Before the next BeginImplFrame, set needs redraw again. |
| 538 // This should not redraw until the next BeginImplFrame. |
| 539 state.SetNeedsRedraw(true); |
| 540 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 541 |
| 542 // Move to another frame. This should now draw. |
| 543 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 544 state.OnBeginImplFrame(); |
| 545 |
| 546 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 547 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 548 |
| 549 state.OnBeginImplFrameDeadline(); |
| 550 EXPECT_ACTION_UPDATE_STATE( |
| 551 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 552 state.DidSwapBuffers(); |
| 553 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 554 state.DidSwapBuffersComplete(); |
| 555 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 556 |
| 557 // We just swapped, so we should proactively request another BeginImplFrame. |
| 558 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 559 } |
| 560 |
| 561 TEST(SchedulerStateMachineTest, TestNextActionDrawsOnBeginImplFrame) { |
| 562 SchedulerSettings default_scheduler_settings; |
| 563 |
| 564 // When not in BeginImplFrame deadline, or in BeginImplFrame deadline |
| 565 // but not visible, don't draw. |
| 566 size_t num_commit_states = |
| 567 sizeof(all_commit_states) / sizeof(SchedulerStateMachine::CommitState); |
| 568 size_t num_begin_impl_frame_states = |
| 569 sizeof(all_begin_impl_frame_states) / |
| 570 sizeof(SchedulerStateMachine::BeginImplFrameState); |
| 571 for (size_t i = 0; i < num_commit_states; ++i) { |
| 572 for (size_t j = 0; j < num_begin_impl_frame_states; ++j) { |
| 573 StateMachine state(default_scheduler_settings); |
| 574 state.SetCanStart(); |
| 575 state.UpdateState(state.NextAction()); |
| 576 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 577 state.SetCommitState(all_commit_states[i]); |
| 578 state.SetBeginImplFrameState(all_begin_impl_frame_states[j]); |
| 579 bool visible = |
| 580 (all_begin_impl_frame_states[j] != |
| 581 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
| 582 state.SetVisible(visible); |
| 583 |
| 584 // Case 1: needs_commit=false |
| 585 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE, |
| 586 state.NextAction()); |
| 587 |
| 588 // Case 2: needs_commit=true |
| 589 state.SetNeedsCommit(); |
| 590 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE, |
| 591 state.NextAction()) |
| 592 << state.AsValue()->ToString(); |
| 593 } |
| 594 } |
| 595 |
| 596 // When in BeginImplFrame deadline we should always draw for SetNeedsRedraw |
| 597 // except if we're ready to commit, in which case we expect a commit first. |
| 598 for (size_t i = 0; i < num_commit_states; ++i) { |
| 599 StateMachine state(default_scheduler_settings); |
| 600 state.SetCanStart(); |
| 601 state.UpdateState(state.NextAction()); |
| 602 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 603 state.SetCanDraw(true); |
| 604 state.SetCommitState(all_commit_states[i]); |
| 605 state.SetBeginImplFrameState( |
| 606 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
| 607 |
| 608 state.SetNeedsRedraw(true); |
| 609 state.SetVisible(true); |
| 610 |
| 611 SchedulerStateMachine::Action expected_action; |
| 612 if (all_commit_states[i] == |
| 613 SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT) { |
| 614 expected_action = SchedulerStateMachine::ACTION_COMMIT; |
| 615 } else { |
| 616 expected_action = SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE; |
| 617 EXPECT_ACTION(SchedulerStateMachine::ACTION_ANIMATE); |
| 618 state.UpdateState(state.NextAction()); |
| 619 } |
| 620 |
| 621 // Case 1: needs_commit=false. |
| 622 EXPECT_ACTION(expected_action); |
| 623 |
| 624 // Case 2: needs_commit=true. |
| 625 state.SetNeedsCommit(); |
| 626 EXPECT_ACTION(expected_action); |
| 627 } |
| 628 } |
| 629 |
| 630 TEST(SchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible) { |
| 631 SchedulerSettings default_scheduler_settings; |
| 632 |
| 633 size_t num_commit_states = |
| 634 sizeof(all_commit_states) / sizeof(SchedulerStateMachine::CommitState); |
| 635 for (size_t i = 0; i < num_commit_states; ++i) { |
| 636 // There shouldn't be any drawing regardless of BeginImplFrame. |
| 637 for (size_t j = 0; j < 2; ++j) { |
| 638 StateMachine state(default_scheduler_settings); |
| 639 state.SetCanStart(); |
| 640 state.UpdateState(state.NextAction()); |
| 641 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 642 state.SetCommitState(all_commit_states[i]); |
| 643 state.SetVisible(false); |
| 644 state.SetNeedsRedraw(true); |
| 645 if (j == 1) { |
| 646 state.SetBeginImplFrameState( |
| 647 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
| 648 } |
| 649 |
| 650 // Case 1: needs_commit=false. |
| 651 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE, |
| 652 state.NextAction()); |
| 653 |
| 654 // Case 2: needs_commit=true. |
| 655 state.SetNeedsCommit(); |
| 656 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE, |
| 657 state.NextAction()) |
| 658 << state.AsValue()->ToString(); |
| 659 } |
| 660 } |
| 661 } |
| 662 |
| 663 TEST(SchedulerStateMachineTest, TestCanRedraw_StopsDraw) { |
| 664 SchedulerSettings default_scheduler_settings; |
| 665 |
| 666 size_t num_commit_states = |
| 667 sizeof(all_commit_states) / sizeof(SchedulerStateMachine::CommitState); |
| 668 for (size_t i = 0; i < num_commit_states; ++i) { |
| 669 // There shouldn't be any drawing regardless of BeginImplFrame. |
| 670 for (size_t j = 0; j < 2; ++j) { |
| 671 StateMachine state(default_scheduler_settings); |
| 672 state.SetCanStart(); |
| 673 state.UpdateState(state.NextAction()); |
| 674 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 675 state.SetCommitState(all_commit_states[i]); |
| 676 state.SetVisible(false); |
| 677 state.SetNeedsRedraw(true); |
| 678 if (j == 1) |
| 679 state.OnBeginImplFrame(); |
| 680 |
| 681 state.SetCanDraw(false); |
| 682 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE, |
| 683 state.NextAction()); |
| 684 } |
| 685 } |
| 686 } |
| 687 |
| 688 TEST(SchedulerStateMachineTest, |
| 689 TestCanRedrawWithWaitingForFirstDrawMakesProgress) { |
| 690 SchedulerSettings default_scheduler_settings; |
| 691 StateMachine state(default_scheduler_settings); |
| 692 state.SetCanStart(); |
| 693 state.UpdateState(state.NextAction()); |
| 694 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 695 |
| 696 state.SetActiveTreeNeedsFirstDraw(true); |
| 697 state.SetNeedsCommit(); |
| 698 state.SetNeedsRedraw(true); |
| 699 state.SetVisible(true); |
| 700 state.SetCanDraw(false); |
| 701 state.OnBeginImplFrame(); |
| 702 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 703 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 704 EXPECT_ACTION_UPDATE_STATE( |
| 705 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 706 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 707 state.NotifyBeginMainFrameStarted(); |
| 708 state.NotifyReadyToCommit(); |
| 709 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 710 state.OnBeginImplFrameDeadline(); |
| 711 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 712 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 713 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 714 } |
| 715 |
| 716 TEST(SchedulerStateMachineTest, TestSetNeedsCommitIsNotLost) { |
| 717 SchedulerSettings scheduler_settings; |
| 718 StateMachine state(scheduler_settings); |
| 719 SET_UP_STATE(state) |
| 720 state.SetNeedsCommit(); |
| 721 |
| 722 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 723 |
| 724 // Begin the frame. |
| 725 state.OnBeginImplFrame(); |
| 726 EXPECT_ACTION_UPDATE_STATE( |
| 727 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 728 EXPECT_COMMIT_STATE( |
| 729 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 730 |
| 731 // Now, while the frame is in progress, set another commit. |
| 732 state.SetNeedsCommit(); |
| 733 EXPECT_TRUE(state.NeedsCommit()); |
| 734 |
| 735 // Let the frame finish. |
| 736 state.NotifyBeginMainFrameStarted(); |
| 737 state.NotifyReadyToCommit(); |
| 738 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT); |
| 739 |
| 740 // Expect to commit regardless of BeginImplFrame state. |
| 741 EXPECT_IMPL_FRAME_STATE( |
| 742 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING); |
| 743 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
| 744 |
| 745 state.OnBeginImplFrameDeadlinePending(); |
| 746 EXPECT_IMPL_FRAME_STATE( |
| 747 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
| 748 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
| 749 |
| 750 state.OnBeginImplFrameDeadline(); |
| 751 EXPECT_IMPL_FRAME_STATE( |
| 752 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
| 753 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
| 754 |
| 755 state.OnBeginImplFrameIdle(); |
| 756 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
| 757 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
| 758 |
| 759 state.OnBeginImplFrame(); |
| 760 EXPECT_IMPL_FRAME_STATE( |
| 761 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING); |
| 762 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
| 763 |
| 764 // Finish the commit, then make sure we start the next commit immediately |
| 765 // and draw on the next BeginImplFrame. |
| 766 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 767 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 768 EXPECT_ACTION_UPDATE_STATE( |
| 769 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 770 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 771 |
| 772 state.OnBeginImplFrameDeadline(); |
| 773 |
| 774 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 775 EXPECT_ACTION_UPDATE_STATE( |
| 776 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 777 state.DidSwapBuffers(); |
| 778 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 779 state.DidSwapBuffersComplete(); |
| 780 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 781 } |
| 782 |
| 783 TEST(SchedulerStateMachineTest, TestFullCycle) { |
| 784 SchedulerSettings default_scheduler_settings; |
| 785 StateMachine state(default_scheduler_settings); |
| 786 SET_UP_STATE(state) |
| 787 |
| 788 // Start clean and set commit. |
| 789 state.SetNeedsCommit(); |
| 790 |
| 791 // Begin the frame. |
| 792 state.OnBeginImplFrame(); |
| 793 EXPECT_ACTION_UPDATE_STATE( |
| 794 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 795 EXPECT_COMMIT_STATE( |
| 796 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 797 EXPECT_FALSE(state.NeedsCommit()); |
| 798 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 799 |
| 800 // Tell the scheduler the frame finished. |
| 801 state.NotifyBeginMainFrameStarted(); |
| 802 state.NotifyReadyToCommit(); |
| 803 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT); |
| 804 |
| 805 // Commit. |
| 806 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 807 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 808 EXPECT_TRUE(state.needs_redraw()); |
| 809 |
| 810 // Expect to do nothing until BeginImplFrame deadline |
| 811 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 812 |
| 813 // At BeginImplFrame deadline, draw. |
| 814 state.OnBeginImplFrameDeadline(); |
| 815 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 816 EXPECT_ACTION_UPDATE_STATE( |
| 817 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 818 state.DidSwapBuffers(); |
| 819 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 820 state.DidSwapBuffersComplete(); |
| 821 |
| 822 // Should be synchronized, no draw needed, no action needed. |
| 823 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 824 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 825 EXPECT_FALSE(state.needs_redraw()); |
| 826 } |
| 827 |
| 828 TEST(SchedulerStateMachineTest, TestFullCycleWithMainThreadLowLatencyMode) { |
| 829 SchedulerSettings scheduler_settings; |
| 830 scheduler_settings.main_thread_should_always_be_low_latency = true; |
| 831 StateMachine state(scheduler_settings); |
| 832 SET_UP_STATE(state) |
| 833 |
| 834 // Start clean and set commit. |
| 835 state.SetNeedsCommit(); |
| 836 |
| 837 // Begin the frame. |
| 838 state.OnBeginImplFrame(); |
| 839 EXPECT_ACTION_UPDATE_STATE( |
| 840 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 841 EXPECT_COMMIT_STATE( |
| 842 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 843 EXPECT_FALSE(state.NeedsCommit()); |
| 844 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 845 |
| 846 // Tell the scheduler the frame finished. |
| 847 state.NotifyBeginMainFrameStarted(); |
| 848 state.NotifyReadyToCommit(); |
| 849 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT); |
| 850 |
| 851 // Commit. |
| 852 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 853 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 854 EXPECT_TRUE(state.needs_redraw()); |
| 855 |
| 856 // Now commit should wait for draw. |
| 857 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW); |
| 858 |
| 859 // Swap throttled. Do not draw. |
| 860 state.DidSwapBuffers(); |
| 861 state.OnBeginImplFrameDeadline(); |
| 862 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 863 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 864 state.DidSwapBuffersComplete(); |
| 865 |
| 866 // Haven't draw since last commit, do not begin new main frame. |
| 867 state.SetNeedsCommit(); |
| 868 state.OnBeginImplFrame(); |
| 869 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 870 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 871 |
| 872 // At BeginImplFrame deadline, draw. |
| 873 state.OnBeginImplFrameDeadline(); |
| 874 EXPECT_ACTION_UPDATE_STATE( |
| 875 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 876 state.DidSwapBuffers(); |
| 877 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 878 state.DidSwapBuffersComplete(); |
| 879 |
| 880 // Now will be able to start main frame. |
| 881 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 882 EXPECT_FALSE(state.needs_redraw()); |
| 883 EXPECT_ACTION_UPDATE_STATE( |
| 884 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 885 } |
| 886 |
| 887 TEST(SchedulerStateMachineTest, |
| 888 TestFullCycleWithMainThreadLowLatencyMode_ImplSidePaint) { |
| 889 SchedulerSettings scheduler_settings; |
| 890 scheduler_settings.main_thread_should_always_be_low_latency = true; |
| 891 scheduler_settings.impl_side_painting = true; |
| 892 StateMachine state(scheduler_settings); |
| 893 SET_UP_STATE(state) |
| 894 |
| 895 // Start clean and set commit. |
| 896 state.SetNeedsCommit(); |
| 897 |
| 898 // Begin the frame. |
| 899 state.OnBeginImplFrame(); |
| 900 EXPECT_ACTION_UPDATE_STATE( |
| 901 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 902 EXPECT_COMMIT_STATE( |
| 903 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 904 EXPECT_FALSE(state.NeedsCommit()); |
| 905 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 906 |
| 907 // Tell the scheduler the frame finished. |
| 908 state.NotifyBeginMainFrameStarted(); |
| 909 state.NotifyReadyToCommit(); |
| 910 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT); |
| 911 |
| 912 // Commit. |
| 913 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 914 |
| 915 // Now commit should wait for activation. |
| 916 EXPECT_COMMIT_STATE( |
| 917 SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION); |
| 918 |
| 919 // No activation yet, so this commit is not drawn yet. Force to draw this |
| 920 // frame, and still block BeginMainFrame. |
| 921 state.SetNeedsRedraw(true); |
| 922 state.SetNeedsCommit(); |
| 923 state.OnBeginImplFrameDeadline(); |
| 924 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 925 EXPECT_ACTION_UPDATE_STATE( |
| 926 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 927 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 928 |
| 929 // Cannot BeginMainFrame yet since last commit is not yet activated and drawn. |
| 930 state.OnBeginImplFrame(); |
| 931 EXPECT_COMMIT_STATE( |
| 932 SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_ACTIVATION); |
| 933 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 934 |
| 935 // Now activate sync tree. |
| 936 state.NotifyReadyToActivate(); |
| 937 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
| 938 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 939 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 940 EXPECT_TRUE(state.needs_redraw()); |
| 941 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_WAITING_FOR_DRAW); |
| 942 |
| 943 // Swap throttled. Do not draw. |
| 944 state.DidSwapBuffers(); |
| 945 state.OnBeginImplFrameDeadline(); |
| 946 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 947 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 948 state.DidSwapBuffersComplete(); |
| 949 |
| 950 // Haven't draw since last commit, do not begin new main frame. |
| 951 state.OnBeginImplFrame(); |
| 952 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 953 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 954 |
| 955 // At BeginImplFrame deadline, draw. This draws unblocks BeginMainFrame. |
| 956 state.OnBeginImplFrameDeadline(); |
| 957 EXPECT_ACTION_UPDATE_STATE( |
| 958 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 959 state.DidSwapBuffers(); |
| 960 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 961 state.DidSwapBuffersComplete(); |
| 962 |
| 963 // Now will be able to start main frame. |
| 964 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 965 EXPECT_FALSE(state.needs_redraw()); |
| 966 EXPECT_ACTION_UPDATE_STATE( |
| 967 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 968 } |
| 969 |
| 970 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) { |
| 971 SchedulerSettings default_scheduler_settings; |
| 972 StateMachine state(default_scheduler_settings); |
| 973 SET_UP_STATE(state) |
| 974 |
| 975 // Start clean and set commit. |
| 976 state.SetNeedsCommit(); |
| 977 |
| 978 // Begin the frame. |
| 979 state.OnBeginImplFrame(); |
| 980 EXPECT_ACTION_UPDATE_STATE( |
| 981 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 982 EXPECT_COMMIT_STATE( |
| 983 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 984 EXPECT_FALSE(state.NeedsCommit()); |
| 985 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 986 |
| 987 // Request another commit while the commit is in flight. |
| 988 state.SetNeedsCommit(); |
| 989 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 990 |
| 991 // Tell the scheduler the frame finished. |
| 992 state.NotifyBeginMainFrameStarted(); |
| 993 state.NotifyReadyToCommit(); |
| 994 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT); |
| 995 |
| 996 // First commit. |
| 997 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 998 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 999 EXPECT_TRUE(state.needs_redraw()); |
| 1000 |
| 1001 // Expect to do nothing until BeginImplFrame deadline. |
| 1002 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1003 |
| 1004 // At BeginImplFrame deadline, draw. |
| 1005 state.OnBeginImplFrameDeadline(); |
| 1006 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1007 EXPECT_ACTION_UPDATE_STATE( |
| 1008 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1009 state.DidSwapBuffers(); |
| 1010 state.DidDrawIfPossibleCompleted(DRAW_SUCCESS); |
| 1011 state.DidSwapBuffersComplete(); |
| 1012 |
| 1013 // Should be synchronized, no draw needed, no action needed. |
| 1014 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1015 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 1016 EXPECT_FALSE(state.needs_redraw()); |
| 1017 |
| 1018 // Next BeginImplFrame should initiate second commit. |
| 1019 state.OnBeginImplFrame(); |
| 1020 EXPECT_ACTION_UPDATE_STATE( |
| 1021 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1022 } |
| 1023 |
| 1024 TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) { |
| 1025 SchedulerSettings default_scheduler_settings; |
| 1026 StateMachine state(default_scheduler_settings); |
| 1027 state.SetCanStart(); |
| 1028 state.UpdateState(state.NextAction()); |
| 1029 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 1030 state.SetNeedsCommit(); |
| 1031 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1032 } |
| 1033 |
| 1034 // See ThreadProxy::BeginMainFrame "EarlyOut_NotVisible" / |
| 1035 // "EarlyOut_OutputSurfaceLost" cases. |
| 1036 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) { |
| 1037 SchedulerSettings default_scheduler_settings; |
| 1038 StateMachine state(default_scheduler_settings); |
| 1039 SET_UP_STATE(state) |
| 1040 |
| 1041 // Start clean and set commit. |
| 1042 state.SetNeedsCommit(); |
| 1043 |
| 1044 // Begin the frame while visible. |
| 1045 state.OnBeginImplFrame(); |
| 1046 EXPECT_ACTION_UPDATE_STATE( |
| 1047 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1048 EXPECT_COMMIT_STATE( |
| 1049 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 1050 EXPECT_FALSE(state.NeedsCommit()); |
| 1051 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1052 |
| 1053 // Become invisible and abort BeginMainFrame. |
| 1054 state.SetVisible(false); |
| 1055 state.BeginMainFrameAborted(CommitEarlyOutReason::ABORTED_NOT_VISIBLE); |
| 1056 |
| 1057 // NeedsCommit should now be true again because we never actually did a |
| 1058 // commit. |
| 1059 EXPECT_TRUE(state.NeedsCommit()); |
| 1060 |
| 1061 // We should now be back in the idle state as if we never started the frame. |
| 1062 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 1063 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1064 |
| 1065 // We shouldn't do anything on the BeginImplFrame deadline. |
| 1066 state.OnBeginImplFrameDeadline(); |
| 1067 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1068 |
| 1069 // Become visible again. |
| 1070 state.SetVisible(true); |
| 1071 |
| 1072 // Although we have aborted on this frame and haven't cancelled the commit |
| 1073 // (i.e. need another), don't send another BeginMainFrame yet. |
| 1074 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 1075 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1076 EXPECT_TRUE(state.NeedsCommit()); |
| 1077 |
| 1078 // Start a new frame. |
| 1079 state.OnBeginImplFrame(); |
| 1080 EXPECT_ACTION_UPDATE_STATE( |
| 1081 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1082 |
| 1083 // We should be starting the commit now. |
| 1084 EXPECT_COMMIT_STATE( |
| 1085 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 1086 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1087 } |
| 1088 |
| 1089 // See ThreadProxy::BeginMainFrame "EarlyOut_NoUpdates" case. |
| 1090 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) { |
| 1091 SchedulerSettings default_scheduler_settings; |
| 1092 StateMachine state(default_scheduler_settings); |
| 1093 state.SetCanStart(); |
| 1094 state.UpdateState(state.NextAction()); |
| 1095 state.DidCreateAndInitializeOutputSurface(); |
| 1096 state.SetVisible(true); |
| 1097 state.SetCanDraw(true); |
| 1098 |
| 1099 // Get into a begin frame / commit state. |
| 1100 state.SetNeedsCommit(); |
| 1101 state.OnBeginImplFrame(); |
| 1102 EXPECT_ACTION_UPDATE_STATE( |
| 1103 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1104 EXPECT_COMMIT_STATE( |
| 1105 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 1106 EXPECT_FALSE(state.NeedsCommit()); |
| 1107 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1108 |
| 1109 // Abort the commit, true means that the BeginMainFrame was sent but there |
| 1110 // was no work to do on the main thread. |
| 1111 state.BeginMainFrameAborted(CommitEarlyOutReason::FINISHED_NO_UPDATES); |
| 1112 |
| 1113 // NeedsCommit should now be false because the commit was actually handled. |
| 1114 EXPECT_FALSE(state.NeedsCommit()); |
| 1115 |
| 1116 // Even though the commit was aborted, we still expect to draw the new frame. |
| 1117 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1118 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1119 state.OnBeginImplFrameDeadline(); |
| 1120 EXPECT_ACTION_UPDATE_STATE( |
| 1121 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1122 state.DidSwapBuffers(); |
| 1123 state.DidSwapBuffersComplete(); |
| 1124 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1125 |
| 1126 // Verify another commit doesn't start on another frame either. |
| 1127 EXPECT_FALSE(state.NeedsCommit()); |
| 1128 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 1129 |
| 1130 state.OnBeginImplFrame(); |
| 1131 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1132 state.OnBeginImplFrameDeadline(); |
| 1133 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1134 |
| 1135 // Verify another commit can start if requested, though. |
| 1136 state.SetNeedsCommit(); |
| 1137 EXPECT_COMMIT_STATE(SchedulerStateMachine::COMMIT_STATE_IDLE); |
| 1138 state.OnBeginImplFrame(); |
| 1139 EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1140 } |
| 1141 |
| 1142 TEST(SchedulerStateMachineTest, TestFirstContextCreation) { |
| 1143 SchedulerSettings default_scheduler_settings; |
| 1144 StateMachine state(default_scheduler_settings); |
| 1145 state.SetCanStart(); |
| 1146 state.SetVisible(true); |
| 1147 state.SetCanDraw(true); |
| 1148 |
| 1149 EXPECT_ACTION_UPDATE_STATE( |
| 1150 SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1151 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 1152 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1153 |
| 1154 // Check that the first init does not SetNeedsCommit. |
| 1155 state.OnBeginImplFrame(); |
| 1156 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1157 state.OnBeginImplFrameDeadline(); |
| 1158 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1159 |
| 1160 // Check that a needs commit initiates a BeginMainFrame. |
| 1161 state.SetNeedsCommit(); |
| 1162 state.OnBeginImplFrame(); |
| 1163 EXPECT_ACTION_UPDATE_STATE( |
| 1164 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1165 } |
| 1166 |
| 1167 TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) { |
| 1168 SchedulerSettings default_scheduler_settings; |
| 1169 StateMachine state(default_scheduler_settings); |
| 1170 SET_UP_STATE(state) |
| 1171 |
| 1172 EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION, |
| 1173 state.NextAction()); |
| 1174 state.DidLoseOutputSurface(); |
| 1175 |
| 1176 EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1177 state.UpdateState(state.NextAction()); |
| 1178 |
| 1179 // Once context recreation begins, nothing should happen. |
| 1180 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1181 |
| 1182 // Recreate the context. |
| 1183 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 1184 |
| 1185 // When the context is recreated, we should begin a commit. |
| 1186 state.OnBeginImplFrame(); |
| 1187 EXPECT_ACTION_UPDATE_STATE( |
| 1188 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1189 } |
| 1190 |
| 1191 TEST(SchedulerStateMachineTest, |
| 1192 TestContextLostWhenIdleAndCommitRequestedWhileRecreating) { |
| 1193 SchedulerSettings default_scheduler_settings; |
| 1194 // We use impl side painting because it's the more complicated version. |
| 1195 default_scheduler_settings.impl_side_painting = true; |
| 1196 StateMachine state(default_scheduler_settings); |
| 1197 SET_UP_STATE(state) |
| 1198 |
| 1199 EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION, |
| 1200 state.NextAction()); |
| 1201 state.DidLoseOutputSurface(); |
| 1202 EXPECT_EQ(state.output_surface_state(), |
| 1203 SchedulerStateMachine::OUTPUT_SURFACE_LOST); |
| 1204 |
| 1205 EXPECT_ACTION_UPDATE_STATE( |
| 1206 SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1207 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1208 |
| 1209 // Once context recreation begins, nothing should happen. |
| 1210 state.OnBeginImplFrame(); |
| 1211 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1212 state.OnBeginImplFrameDeadline(); |
| 1213 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1214 |
| 1215 // While context is recreating, commits shouldn't begin. |
| 1216 state.SetNeedsCommit(); |
| 1217 state.OnBeginImplFrame(); |
| 1218 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1219 state.OnBeginImplFrameDeadline(); |
| 1220 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1221 |
| 1222 // Recreate the context |
| 1223 state.DidCreateAndInitializeOutputSurface(); |
| 1224 EXPECT_EQ(state.output_surface_state(), |
| 1225 SchedulerStateMachine::OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT); |
| 1226 EXPECT_FALSE(state.RedrawPending()); |
| 1227 |
| 1228 // When the context is recreated, we wait until the next BeginImplFrame |
| 1229 // before starting. |
| 1230 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1231 |
| 1232 // When the BeginFrame comes in we should begin a commit |
| 1233 state.OnBeginImplFrame(); |
| 1234 EXPECT_ACTION_UPDATE_STATE( |
| 1235 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1236 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1237 EXPECT_COMMIT_STATE( |
| 1238 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 1239 |
| 1240 // Until that commit finishes, we shouldn't be drawing or animate. |
| 1241 state.OnBeginImplFrameDeadline(); |
| 1242 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1243 |
| 1244 // Finish the commit, which should make the surface active. |
| 1245 state.NotifyBeginMainFrameStarted(); |
| 1246 state.NotifyReadyToCommit(); |
| 1247 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1248 EXPECT_EQ(state.output_surface_state(), |
| 1249 SchedulerStateMachine::OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION); |
| 1250 state.NotifyReadyToActivate(); |
| 1251 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
| 1252 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1253 EXPECT_EQ(state.output_surface_state(), |
| 1254 SchedulerStateMachine::OUTPUT_SURFACE_ACTIVE); |
| 1255 |
| 1256 // Finishing the first commit after initializing an output surface should |
| 1257 // automatically cause a redraw. |
| 1258 EXPECT_TRUE(state.RedrawPending()); |
| 1259 state.OnBeginImplFrame(); |
| 1260 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1261 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1262 state.OnBeginImplFrameDeadline(); |
| 1263 EXPECT_ACTION_UPDATE_STATE( |
| 1264 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1265 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1266 EXPECT_FALSE(state.RedrawPending()); |
| 1267 |
| 1268 // Next frame as no work to do. |
| 1269 state.OnBeginImplFrame(); |
| 1270 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1271 state.OnBeginImplFrameDeadline(); |
| 1272 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1273 |
| 1274 // Once the context is recreated, whether we draw should be based on |
| 1275 // SetCanDraw if waiting on first draw after activate. |
| 1276 state.SetNeedsRedraw(true); |
| 1277 state.OnBeginImplFrame(); |
| 1278 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1279 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1280 state.OnBeginImplFrameDeadline(); |
| 1281 EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1282 state.SetCanDraw(false); |
| 1283 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1284 state.SetCanDraw(true); |
| 1285 EXPECT_ACTION_UPDATE_STATE( |
| 1286 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1287 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1288 |
| 1289 // Once the context is recreated, whether we draw should be based on |
| 1290 // SetCanDraw if waiting on first draw after activate. |
| 1291 state.SetNeedsRedraw(true); |
| 1292 state.SetNeedsCommit(); |
| 1293 state.OnBeginImplFrame(); |
| 1294 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1295 EXPECT_ACTION_UPDATE_STATE( |
| 1296 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1297 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1298 // Activate so we need the first draw |
| 1299 state.NotifyBeginMainFrameStarted(); |
| 1300 state.NotifyReadyToCommit(); |
| 1301 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1302 state.NotifyReadyToActivate(); |
| 1303 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
| 1304 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1305 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 1306 EXPECT_TRUE(state.needs_redraw()); |
| 1307 |
| 1308 state.OnBeginImplFrameDeadline(); |
| 1309 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1310 EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1311 state.SetCanDraw(false); |
| 1312 EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 1313 state.SetCanDraw(true); |
| 1314 EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1315 } |
| 1316 |
| 1317 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) { |
| 1318 SchedulerSettings scheduler_settings; |
| 1319 StateMachine state(scheduler_settings); |
| 1320 SET_UP_STATE(state) |
| 1321 |
| 1322 // Get a commit in flight. |
| 1323 state.SetNeedsCommit(); |
| 1324 |
| 1325 // Set damage and expect a draw. |
| 1326 state.SetNeedsRedraw(true); |
| 1327 state.OnBeginImplFrame(); |
| 1328 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1329 EXPECT_ACTION_UPDATE_STATE( |
| 1330 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1331 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1332 state.OnBeginImplFrameDeadline(); |
| 1333 EXPECT_ACTION_UPDATE_STATE( |
| 1334 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1335 state.DidSwapBuffers(); |
| 1336 state.DidSwapBuffersComplete(); |
| 1337 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1338 |
| 1339 // Cause a lost context while the BeginMainFrame is in flight. |
| 1340 state.DidLoseOutputSurface(); |
| 1341 |
| 1342 // Ask for another draw. Expect nothing happens. |
| 1343 state.SetNeedsRedraw(true); |
| 1344 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1345 |
| 1346 // Finish the frame, and commit. |
| 1347 state.NotifyBeginMainFrameStarted(); |
| 1348 state.NotifyReadyToCommit(); |
| 1349 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1350 |
| 1351 // We will abort the draw when the output surface is lost if we are |
| 1352 // waiting for the first draw to unblock the main thread. |
| 1353 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 1354 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 1355 |
| 1356 // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE |
| 1357 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
| 1358 EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1359 |
| 1360 state.OnBeginImplFrame(); |
| 1361 EXPECT_IMPL_FRAME_STATE( |
| 1362 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING); |
| 1363 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1364 |
| 1365 state.OnBeginImplFrameDeadlinePending(); |
| 1366 EXPECT_IMPL_FRAME_STATE( |
| 1367 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
| 1368 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1369 |
| 1370 state.OnBeginImplFrameDeadline(); |
| 1371 EXPECT_IMPL_FRAME_STATE( |
| 1372 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
| 1373 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1374 } |
| 1375 |
| 1376 TEST(SchedulerStateMachineTest, |
| 1377 TestContextLostWhileCommitInProgressAndAnotherCommitRequested) { |
| 1378 SchedulerSettings scheduler_settings; |
| 1379 StateMachine state(scheduler_settings); |
| 1380 SET_UP_STATE(state) |
| 1381 |
| 1382 // Get a commit in flight. |
| 1383 state.SetNeedsCommit(); |
| 1384 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1385 |
| 1386 // Set damage and expect a draw. |
| 1387 state.SetNeedsRedraw(true); |
| 1388 state.OnBeginImplFrame(); |
| 1389 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1390 EXPECT_ACTION_UPDATE_STATE( |
| 1391 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1392 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1393 state.OnBeginImplFrameDeadline(); |
| 1394 EXPECT_ACTION_UPDATE_STATE( |
| 1395 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1396 state.DidSwapBuffers(); |
| 1397 state.DidSwapBuffersComplete(); |
| 1398 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1399 |
| 1400 // Cause a lost context while the BeginMainFrame is in flight. |
| 1401 state.DidLoseOutputSurface(); |
| 1402 |
| 1403 // Ask for another draw and also set needs commit. Expect nothing happens. |
| 1404 state.SetNeedsRedraw(true); |
| 1405 state.SetNeedsCommit(); |
| 1406 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1407 |
| 1408 // Finish the frame, and commit. |
| 1409 state.NotifyBeginMainFrameStarted(); |
| 1410 state.NotifyReadyToCommit(); |
| 1411 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1412 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 1413 |
| 1414 // Because the output surface is missing, we expect the draw to abort. |
| 1415 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 1416 |
| 1417 // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE |
| 1418 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
| 1419 EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1420 |
| 1421 state.OnBeginImplFrame(); |
| 1422 EXPECT_IMPL_FRAME_STATE( |
| 1423 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING); |
| 1424 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1425 |
| 1426 state.OnBeginImplFrameDeadlinePending(); |
| 1427 EXPECT_IMPL_FRAME_STATE( |
| 1428 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
| 1429 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1430 |
| 1431 state.OnBeginImplFrameDeadline(); |
| 1432 EXPECT_IMPL_FRAME_STATE( |
| 1433 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
| 1434 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1435 |
| 1436 state.OnBeginImplFrameIdle(); |
| 1437 EXPECT_ACTION_UPDATE_STATE( |
| 1438 SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1439 |
| 1440 // After we get a new output surface, the commit flow should start. |
| 1441 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 1442 state.OnBeginImplFrame(); |
| 1443 EXPECT_ACTION_UPDATE_STATE( |
| 1444 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1445 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1446 state.NotifyBeginMainFrameStarted(); |
| 1447 state.NotifyReadyToCommit(); |
| 1448 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1449 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1450 state.OnBeginImplFrameDeadline(); |
| 1451 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1452 EXPECT_ACTION_UPDATE_STATE( |
| 1453 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1454 state.DidSwapBuffers(); |
| 1455 state.DidSwapBuffersComplete(); |
| 1456 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1457 } |
| 1458 |
| 1459 TEST(SchedulerStateMachineTest, DontDrawBeforeCommitAfterLostOutputSurface) { |
| 1460 SchedulerSettings default_scheduler_settings; |
| 1461 StateMachine state(default_scheduler_settings); |
| 1462 SET_UP_STATE(state) |
| 1463 |
| 1464 state.SetNeedsRedraw(true); |
| 1465 |
| 1466 // Cause a lost output surface, and restore it. |
| 1467 state.DidLoseOutputSurface(); |
| 1468 EXPECT_ACTION(SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1469 state.UpdateState(state.NextAction()); |
| 1470 state.DidCreateAndInitializeOutputSurface(); |
| 1471 |
| 1472 EXPECT_FALSE(state.RedrawPending()); |
| 1473 state.OnBeginImplFrame(); |
| 1474 EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1475 } |
| 1476 |
| 1477 TEST(SchedulerStateMachineTest, |
| 1478 TestPendingActivationsShouldBeForcedAfterLostOutputSurface) { |
| 1479 SchedulerSettings settings; |
| 1480 settings.impl_side_painting = true; |
| 1481 StateMachine state(settings); |
| 1482 SET_UP_STATE(state) |
| 1483 |
| 1484 state.SetCommitState( |
| 1485 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 1486 |
| 1487 // Cause a lost context. |
| 1488 state.DidLoseOutputSurface(); |
| 1489 |
| 1490 state.NotifyBeginMainFrameStarted(); |
| 1491 state.NotifyReadyToCommit(); |
| 1492 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1493 |
| 1494 EXPECT_TRUE(state.PendingActivationsShouldBeForced()); |
| 1495 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
| 1496 |
| 1497 EXPECT_TRUE(state.PendingDrawsShouldBeAborted()); |
| 1498 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 1499 } |
| 1500 |
| 1501 TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) { |
| 1502 SchedulerSettings default_scheduler_settings; |
| 1503 StateMachine state(default_scheduler_settings); |
| 1504 state.SetCanStart(); |
| 1505 state.UpdateState(state.NextAction()); |
| 1506 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 1507 state.SetVisible(false); |
| 1508 state.SetNeedsCommit(); |
| 1509 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1510 } |
| 1511 |
| 1512 TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) { |
| 1513 SchedulerSettings default_scheduler_settings; |
| 1514 StateMachine state(default_scheduler_settings); |
| 1515 state.SetCanStart(); |
| 1516 state.UpdateState(state.NextAction()); |
| 1517 state.CreateAndInitializeOutputSurfaceWithActivatedCommit(); |
| 1518 state.SetVisible(false); |
| 1519 state.SetCommitState( |
| 1520 SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); |
| 1521 state.SetNeedsCommit(); |
| 1522 |
| 1523 state.NotifyBeginMainFrameStarted(); |
| 1524 state.NotifyReadyToCommit(); |
| 1525 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
| 1526 state.UpdateState(state.NextAction()); |
| 1527 |
| 1528 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
| 1529 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT); |
| 1530 } |
| 1531 |
| 1532 TEST(SchedulerStateMachineTest, TestInitialActionsWhenContextLost) { |
| 1533 SchedulerSettings default_scheduler_settings; |
| 1534 StateMachine state(default_scheduler_settings); |
| 1535 SET_UP_STATE(state) |
| 1536 state.SetNeedsCommit(); |
| 1537 state.DidLoseOutputSurface(); |
| 1538 |
| 1539 // When we are visible, we normally want to begin output surface creation |
| 1540 // as soon as possible. |
| 1541 EXPECT_ACTION_UPDATE_STATE( |
| 1542 SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); |
| 1543 |
| 1544 state.DidCreateAndInitializeOutputSurface(); |
| 1545 EXPECT_EQ(state.output_surface_state(), |
| 1546 SchedulerStateMachine::OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT); |
| 1547 |
| 1548 // We should not send a BeginMainFrame when we are invisible, even if we've |
| 1549 // lost the output surface and are trying to get the first commit, since the |
| 1550 // main thread will just abort anyway. |
| 1551 state.SetVisible(false); |
| 1552 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
| 1553 } |
| 1554 |
| 1555 TEST(SchedulerStateMachineTest, ReportIfNotDrawing) { |
| 1556 SchedulerSettings default_scheduler_settings; |
| 1557 StateMachine state(default_scheduler_settings); |
| 1558 SET_UP_STATE(state) |
| 1559 EXPECT_FALSE(state.PendingDrawsShouldBeAborted()); |
| 1560 |
| 1561 state.SetCanDraw(false); |
| 1562 state.SetVisible(true); |
| 1563 EXPECT_TRUE(state.PendingDrawsShouldBeAborted()); |
| 1564 |
| 1565 state.SetCanDraw(true); |
| 1566 state.SetVisible(false); |
| 1567 EXPECT_TRUE(state.PendingDrawsShouldBeAborted()); |
| 1568 |
| 1569 state.SetCanDraw(false); |
| 1570 state.SetVisible(false); |
| 1571 EXPECT_TRUE(state.PendingDrawsShouldBeAborted()); |
| 1572 |
| 1573 state.SetCanDraw(true); |
| 1574 state.SetVisible(true); |
| 1575 EXPECT_FALSE(state.PendingDrawsShouldBeAborted()); |
| 1576 } |
| 1577 |
| 1578 TEST(SchedulerStateMachineTest, |
| 1579 TestTriggerDeadlineImmediatelyAfterAbortedCommit) { |
| 1580 SchedulerSettings settings; |
| 1581 settings.impl_side_painting = true; |
| 1582 StateMachine state(settings); |
| 1583 SET_UP_STATE(state) |
| 1584 |
| 1585 // This test mirrors what happens during the first frame of a scroll gesture. |
| 1586 // First we get the input event and a BeginFrame. |
| 1587 state.OnBeginImplFrame(); |
| 1588 |
| 1589 // As a response the compositor requests a redraw and a commit to tell the |
| 1590 // main thread about the new scroll offset. |
| 1591 state.SetNeedsRedraw(true); |
| 1592 state.SetNeedsCommit(); |
| 1593 |
| 1594 // We should start the commit normally. |
| 1595 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1596 EXPECT_ACTION_UPDATE_STATE( |
| 1597 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1598 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1599 |
| 1600 // Since only the scroll offset changed, the main thread will abort the |
| 1601 // commit. |
| 1602 state.BeginMainFrameAborted(CommitEarlyOutReason::FINISHED_NO_UPDATES); |
| 1603 |
| 1604 // Since the commit was aborted, we should draw right away instead of waiting |
| 1605 // for the deadline. |
| 1606 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1607 } |
| 1608 |
| 1609 void FinishPreviousCommitAndDrawWithoutExitingDeadline( |
| 1610 StateMachine* state_ptr) { |
| 1611 // Gross, but allows us to use macros below. |
| 1612 StateMachine& state = *state_ptr; |
| 1613 |
| 1614 state.NotifyBeginMainFrameStarted(); |
| 1615 state.NotifyReadyToCommit(); |
| 1616 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1617 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1618 state.NotifyReadyToActivate(); |
| 1619 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
| 1620 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1621 |
| 1622 state.OnBeginImplFrame(); |
| 1623 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1624 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1625 |
| 1626 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1627 state.OnBeginImplFrameDeadline(); |
| 1628 EXPECT_ACTION_UPDATE_STATE( |
| 1629 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1630 state.DidSwapBuffers(); |
| 1631 } |
| 1632 |
| 1633 TEST(SchedulerStateMachineTest, TestImplLatencyTakesPriority) { |
| 1634 SchedulerSettings settings; |
| 1635 settings.impl_side_painting = true; |
| 1636 StateMachine state(settings); |
| 1637 SET_UP_STATE(state) |
| 1638 |
| 1639 // This test ensures that impl-draws are prioritized over main thread updates |
| 1640 // in prefer impl latency mode. |
| 1641 state.SetNeedsRedraw(true); |
| 1642 state.SetNeedsCommit(); |
| 1643 state.OnBeginImplFrame(); |
| 1644 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1645 EXPECT_ACTION_UPDATE_STATE( |
| 1646 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1647 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1648 |
| 1649 // Verify the deadline is not triggered early until we enter |
| 1650 // prefer impl latency mode. |
| 1651 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1652 state.SetImplLatencyTakesPriority(true); |
| 1653 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1654 |
| 1655 // Trigger the deadline. |
| 1656 state.OnBeginImplFrameDeadline(); |
| 1657 EXPECT_ACTION_UPDATE_STATE( |
| 1658 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1659 state.DidSwapBuffers(); |
| 1660 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1661 state.DidSwapBuffersComplete(); |
| 1662 |
| 1663 // Request a new commit and finish the previous one. |
| 1664 state.SetNeedsCommit(); |
| 1665 FinishPreviousCommitAndDrawWithoutExitingDeadline(&state); |
| 1666 EXPECT_ACTION_UPDATE_STATE( |
| 1667 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1668 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1669 state.DidSwapBuffersComplete(); |
| 1670 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1671 |
| 1672 // Finish the previous commit and draw it. |
| 1673 FinishPreviousCommitAndDrawWithoutExitingDeadline(&state); |
| 1674 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1675 |
| 1676 // Verify we do not send another BeginMainFrame if was are swap throttled |
| 1677 // and did not just swap. |
| 1678 state.SetNeedsCommit(); |
| 1679 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1680 state.OnBeginImplFrame(); |
| 1681 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1682 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1683 state.OnBeginImplFrameDeadline(); |
| 1684 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1685 } |
| 1686 |
| 1687 TEST(SchedulerStateMachineTest, |
| 1688 TestTriggerDeadlineImmediatelyOnLostOutputSurface) { |
| 1689 SchedulerSettings default_scheduler_settings; |
| 1690 StateMachine state(default_scheduler_settings); |
| 1691 SET_UP_STATE(state) |
| 1692 |
| 1693 state.SetNeedsCommit(); |
| 1694 |
| 1695 state.OnBeginImplFrame(); |
| 1696 EXPECT_ACTION_UPDATE_STATE( |
| 1697 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1698 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1699 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1700 |
| 1701 state.DidLoseOutputSurface(); |
| 1702 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1703 // The deadline should be triggered immediately when output surface is lost. |
| 1704 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
| 1705 } |
| 1706 |
| 1707 TEST(SchedulerStateMachineTest, TestSetNeedsAnimate) { |
| 1708 SchedulerSettings settings; |
| 1709 settings.impl_side_painting = true; |
| 1710 StateMachine state(settings); |
| 1711 SET_UP_STATE(state) |
| 1712 |
| 1713 // Test requesting an animation that, when run, causes us to draw. |
| 1714 state.SetNeedsAnimate(); |
| 1715 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 1716 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1717 |
| 1718 state.OnBeginImplFrame(); |
| 1719 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1720 |
| 1721 state.OnBeginImplFrameDeadlinePending(); |
| 1722 state.OnBeginImplFrameDeadline(); |
| 1723 EXPECT_ACTION_UPDATE_STATE( |
| 1724 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1725 } |
| 1726 |
| 1727 TEST(SchedulerStateMachineTest, TestAnimateBeforeCommit) { |
| 1728 SchedulerSettings settings; |
| 1729 settings.impl_side_painting = true; |
| 1730 StateMachine state(settings); |
| 1731 SET_UP_STATE(state) |
| 1732 |
| 1733 // Check that animations are updated before we start a commit. |
| 1734 state.SetNeedsAnimate(); |
| 1735 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1736 state.SetNeedsCommit(); |
| 1737 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1738 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 1739 |
| 1740 state.OnBeginImplFrame(); |
| 1741 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1742 EXPECT_ACTION_UPDATE_STATE( |
| 1743 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1744 |
| 1745 state.OnBeginImplFrameDeadlinePending(); |
| 1746 state.OnBeginImplFrameDeadline(); |
| 1747 EXPECT_ACTION_UPDATE_STATE( |
| 1748 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1749 } |
| 1750 |
| 1751 TEST(SchedulerStateMachineTest, TestAnimateAfterCommitBeforeDraw) { |
| 1752 SchedulerSettings settings; |
| 1753 settings.impl_side_painting = true; |
| 1754 StateMachine state(settings); |
| 1755 SET_UP_STATE(state) |
| 1756 |
| 1757 // Check that animations are updated before we start a commit. |
| 1758 state.SetNeedsAnimate(); |
| 1759 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1760 state.SetNeedsCommit(); |
| 1761 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1762 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 1763 |
| 1764 state.OnBeginImplFrame(); |
| 1765 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1766 EXPECT_ACTION_UPDATE_STATE( |
| 1767 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1768 |
| 1769 state.NotifyBeginMainFrameStarted(); |
| 1770 state.NotifyReadyToCommit(); |
| 1771 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
| 1772 |
| 1773 state.OnBeginImplFrameDeadlinePending(); |
| 1774 state.OnBeginImplFrameDeadline(); |
| 1775 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1776 EXPECT_ACTION_UPDATE_STATE( |
| 1777 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1778 } |
| 1779 |
| 1780 TEST(SchedulerStateMachineTest, TestSetNeedsAnimateAfterAnimate) { |
| 1781 SchedulerSettings settings; |
| 1782 settings.impl_side_painting = true; |
| 1783 StateMachine state(settings); |
| 1784 SET_UP_STATE(state) |
| 1785 |
| 1786 // Test requesting an animation after we have already animated during this |
| 1787 // frame. |
| 1788 state.SetNeedsRedraw(true); |
| 1789 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 1790 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1791 |
| 1792 state.OnBeginImplFrame(); |
| 1793 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE); |
| 1794 |
| 1795 state.SetNeedsAnimate(); |
| 1796 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1797 |
| 1798 state.OnBeginImplFrameDeadline(); |
| 1799 EXPECT_ACTION_UPDATE_STATE( |
| 1800 SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE); |
| 1801 } |
| 1802 |
| 1803 TEST(SchedulerStateMachineTest, TestForwardBeginFramesToChildren) { |
| 1804 SchedulerSettings settings; |
| 1805 StateMachine state(settings); |
| 1806 SET_UP_STATE(state) |
| 1807 |
| 1808 EXPECT_FALSE(state.BeginFrameNeeded()); |
| 1809 state.SetChildrenNeedBeginFrames(true); |
| 1810 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 1811 } |
| 1812 |
| 1813 TEST(SchedulerStateMachineTest, TestDeferCommit) { |
| 1814 SchedulerSettings settings; |
| 1815 StateMachine state(settings); |
| 1816 SET_UP_STATE(state) |
| 1817 |
| 1818 state.SetDeferCommits(true); |
| 1819 |
| 1820 state.SetNeedsCommit(); |
| 1821 EXPECT_TRUE(state.BeginFrameNeeded()); |
| 1822 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1823 |
| 1824 state.OnBeginImplFrame(); |
| 1825 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1826 |
| 1827 state.OnBeginImplFrameDeadline(); |
| 1828 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
| 1829 |
| 1830 state.SetDeferCommits(false); |
| 1831 state.OnBeginImplFrame(); |
| 1832 EXPECT_ACTION_UPDATE_STATE( |
| 1833 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
| 1834 } |
| 1835 |
| 1836 TEST(SchedulerStateMachineTest, EarlyOutCommitWantsProactiveBeginFrame) { |
| 1837 SchedulerSettings settings; |
| 1838 StateMachine state(settings); |
| 1839 SET_UP_STATE(state); |
| 1840 |
| 1841 EXPECT_FALSE(state.ProactiveBeginFrameWanted()); |
| 1842 bool commit_has_no_updates = true; |
| 1843 state.UpdateStateOnCommit(commit_has_no_updates); |
| 1844 EXPECT_TRUE(state.ProactiveBeginFrameWanted()); |
| 1845 state.OnBeginImplFrame(); |
| 1846 EXPECT_FALSE(state.ProactiveBeginFrameWanted()); |
| 1847 } |
| 1848 |
| 1849 } // namespace |
| 1850 } // namespace cc |
| OLD | NEW |
|---|
Chromium Code Reviews
