OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/scheduler/scheduler_state_machine.h" | 5 #include "cc/scheduler/scheduler_state_machine.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include "base/trace_event/trace_event.h" | 9 #include "base/trace_event/trace_event.h" |
10 #include "cc/scheduler/scheduler.h" | 10 #include "cc/scheduler/scheduler.h" |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
196 case SchedulerStateMachine::ACTION_PREPARE_TILES: | 196 case SchedulerStateMachine::ACTION_PREPARE_TILES: |
197 sm->WillPrepareTiles(); | 197 sm->WillPrepareTiles(); |
198 return; | 198 return; |
199 | 199 |
200 case SchedulerStateMachine::ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK: | 200 case SchedulerStateMachine::ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK: |
201 sm->WillInvalidateCompositorFrameSink(); | 201 sm->WillInvalidateCompositorFrameSink(); |
202 return; | 202 return; |
203 } | 203 } |
204 } | 204 } |
205 | 205 |
| 206 // TODO(eseckler): Add tests for frame numbers / |
| 207 // last_frame_number_compositor_frame_was_fresh_. |
| 208 |
206 TEST(SchedulerStateMachineTest, BeginFrameNeeded) { | 209 TEST(SchedulerStateMachineTest, BeginFrameNeeded) { |
207 SchedulerSettings default_scheduler_settings; | 210 SchedulerSettings default_scheduler_settings; |
208 StateMachine state(default_scheduler_settings); | 211 StateMachine state(default_scheduler_settings); |
209 state.SetVisible(true); | 212 state.SetVisible(true); |
210 EXPECT_ACTION_UPDATE_STATE( | 213 EXPECT_ACTION_UPDATE_STATE( |
211 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 214 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
212 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 215 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
213 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 216 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
214 state.SetBeginMainFrameState( | 217 state.SetBeginMainFrameState( |
215 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 218 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
264 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 267 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
265 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 268 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
266 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 269 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
267 state.SetBeginMainFrameState( | 270 state.SetBeginMainFrameState( |
268 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 271 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
269 state.SetNeedsRedraw(false); | 272 state.SetNeedsRedraw(false); |
270 | 273 |
271 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 274 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
272 EXPECT_FALSE(state.NeedsCommit()); | 275 EXPECT_FALSE(state.NeedsCommit()); |
273 | 276 |
274 state.OnBeginImplFrame(); | 277 state.OnBeginImplFrame(0, 1); |
275 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 278 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
276 | 279 |
277 state.OnBeginImplFrameDeadline(); | 280 state.OnBeginImplFrameDeadline(); |
278 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 281 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
279 EXPECT_FALSE(state.NeedsCommit()); | 282 EXPECT_FALSE(state.NeedsCommit()); |
280 } | 283 } |
281 | 284 |
282 // If commit requested but not visible yet, do nothing. | 285 // If commit requested but not visible yet, do nothing. |
283 { | 286 { |
284 StateMachine state(default_scheduler_settings); | 287 StateMachine state(default_scheduler_settings); |
285 state.SetBeginMainFrameState( | 288 state.SetBeginMainFrameState( |
286 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 289 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
287 state.SetNeedsRedraw(false); | 290 state.SetNeedsRedraw(false); |
288 state.SetNeedsBeginMainFrame(); | 291 state.SetNeedsBeginMainFrame(); |
289 | 292 |
290 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 293 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
291 EXPECT_TRUE(state.NeedsCommit()); | 294 EXPECT_TRUE(state.NeedsCommit()); |
292 | 295 |
293 state.OnBeginImplFrame(); | 296 state.OnBeginImplFrame(0, 2); |
294 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 297 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
295 | 298 |
296 state.OnBeginImplFrameDeadline(); | 299 state.OnBeginImplFrameDeadline(); |
297 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 300 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
298 EXPECT_TRUE(state.NeedsCommit()); | 301 EXPECT_TRUE(state.NeedsCommit()); |
299 } | 302 } |
300 | 303 |
301 // If commit requested, begin a main frame. | 304 // If commit requested, begin a main frame. |
302 { | 305 { |
303 StateMachine state(default_scheduler_settings); | 306 StateMachine state(default_scheduler_settings); |
304 state.SetBeginMainFrameState( | 307 state.SetBeginMainFrameState( |
305 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 308 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
306 state.SetVisible(true); | 309 state.SetVisible(true); |
307 EXPECT_ACTION_UPDATE_STATE( | 310 EXPECT_ACTION_UPDATE_STATE( |
308 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 311 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
309 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 312 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
310 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 313 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
311 state.SetNeedsRedraw(false); | 314 state.SetNeedsRedraw(false); |
312 state.SetNeedsBeginMainFrame(); | 315 state.SetNeedsBeginMainFrame(); |
313 | 316 |
314 // Expect nothing to happen until after OnBeginImplFrame. | 317 // Expect nothing to happen until after OnBeginImplFrame. |
315 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 318 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
316 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 319 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
317 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); | 320 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
318 EXPECT_TRUE(state.NeedsCommit()); | 321 EXPECT_TRUE(state.NeedsCommit()); |
319 EXPECT_TRUE(state.BeginFrameNeeded()); | 322 EXPECT_TRUE(state.BeginFrameNeeded()); |
320 | 323 |
321 state.OnBeginImplFrame(); | 324 state.OnBeginImplFrame(0, 3); |
322 EXPECT_ACTION_UPDATE_STATE( | 325 EXPECT_ACTION_UPDATE_STATE( |
323 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 326 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
324 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 327 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
325 EXPECT_FALSE(state.NeedsCommit()); | 328 EXPECT_FALSE(state.NeedsCommit()); |
326 } | 329 } |
327 | 330 |
328 // If commit requested and can't draw, still begin a main frame. | 331 // If commit requested and can't draw, still begin a main frame. |
329 { | 332 { |
330 StateMachine state(default_scheduler_settings); | 333 StateMachine state(default_scheduler_settings); |
331 state.SetBeginMainFrameState( | 334 state.SetBeginMainFrameState( |
332 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 335 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
333 state.SetVisible(true); | 336 state.SetVisible(true); |
334 EXPECT_ACTION_UPDATE_STATE( | 337 EXPECT_ACTION_UPDATE_STATE( |
335 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 338 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
336 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 339 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
337 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 340 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
338 state.SetNeedsRedraw(false); | 341 state.SetNeedsRedraw(false); |
339 state.SetNeedsBeginMainFrame(); | 342 state.SetNeedsBeginMainFrame(); |
340 state.SetCanDraw(false); | 343 state.SetCanDraw(false); |
341 | 344 |
342 // Expect nothing to happen until after OnBeginImplFrame. | 345 // Expect nothing to happen until after OnBeginImplFrame. |
343 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 346 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
344 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 347 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
345 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); | 348 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
346 EXPECT_TRUE(state.BeginFrameNeeded()); | 349 EXPECT_TRUE(state.BeginFrameNeeded()); |
347 | 350 |
348 state.OnBeginImplFrame(); | 351 state.OnBeginImplFrame(0, 4); |
349 EXPECT_ACTION_UPDATE_STATE( | 352 EXPECT_ACTION_UPDATE_STATE( |
350 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 353 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
351 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 354 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
352 EXPECT_FALSE(state.NeedsCommit()); | 355 EXPECT_FALSE(state.NeedsCommit()); |
353 } | 356 } |
354 } | 357 } |
355 | 358 |
356 // Explicitly test main_frame_before_activation_enabled = true | 359 // Explicitly test main_frame_before_activation_enabled = true |
357 TEST(SchedulerStateMachineTest, MainFrameBeforeActivationEnabled) { | 360 TEST(SchedulerStateMachineTest, MainFrameBeforeActivationEnabled) { |
358 SchedulerSettings scheduler_settings; | 361 SchedulerSettings scheduler_settings; |
359 scheduler_settings.main_frame_before_activation_enabled = true; | 362 scheduler_settings.main_frame_before_activation_enabled = true; |
360 StateMachine state(scheduler_settings); | 363 StateMachine state(scheduler_settings); |
361 state.SetBeginMainFrameState( | 364 state.SetBeginMainFrameState( |
362 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 365 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
363 SET_UP_STATE(state) | 366 SET_UP_STATE(state) |
364 state.SetNeedsRedraw(false); | 367 state.SetNeedsRedraw(false); |
365 state.SetNeedsBeginMainFrame(); | 368 state.SetNeedsBeginMainFrame(); |
366 | 369 |
367 EXPECT_TRUE(state.BeginFrameNeeded()); | 370 EXPECT_TRUE(state.BeginFrameNeeded()); |
368 | 371 |
369 // Commit to the pending tree. | 372 // Commit to the pending tree. |
370 state.OnBeginImplFrame(); | 373 state.OnBeginImplFrame(0, 1); |
371 EXPECT_ACTION_UPDATE_STATE( | 374 EXPECT_ACTION_UPDATE_STATE( |
372 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 375 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
373 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 376 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
374 | 377 |
375 state.NotifyBeginMainFrameStarted(); | 378 state.NotifyBeginMainFrameStarted(); |
376 state.NotifyReadyToCommit(); | 379 state.NotifyReadyToCommit(); |
377 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 380 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
378 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 381 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
379 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 382 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
380 | 383 |
381 state.OnBeginImplFrameDeadline(); | 384 state.OnBeginImplFrameDeadline(); |
382 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 385 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
383 | 386 |
384 // Verify that the next commit starts while there is still a pending tree. | 387 // Verify that the next commit starts while there is still a pending tree. |
385 state.SetNeedsBeginMainFrame(); | 388 state.SetNeedsBeginMainFrame(); |
386 state.OnBeginImplFrame(); | 389 state.OnBeginImplFrame(0, 2); |
387 EXPECT_ACTION_UPDATE_STATE( | 390 EXPECT_ACTION_UPDATE_STATE( |
388 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 391 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
389 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 392 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
390 | 393 |
391 // Verify the pending commit doesn't overwrite the pending | 394 // Verify the pending commit doesn't overwrite the pending |
392 // tree until the pending tree has been activated. | 395 // tree until the pending tree has been activated. |
393 state.NotifyBeginMainFrameStarted(); | 396 state.NotifyBeginMainFrameStarted(); |
394 state.NotifyReadyToCommit(); | 397 state.NotifyReadyToCommit(); |
395 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 398 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
396 | 399 |
(...skipping 16 matching lines...) Expand all Loading... |
413 TEST(SchedulerStateMachineTest, | 416 TEST(SchedulerStateMachineTest, |
414 FailedDrawForAnimationCheckerboardSetsNeedsCommitAndRetriesDraw) { | 417 FailedDrawForAnimationCheckerboardSetsNeedsCommitAndRetriesDraw) { |
415 SchedulerSettings default_scheduler_settings; | 418 SchedulerSettings default_scheduler_settings; |
416 StateMachine state(default_scheduler_settings); | 419 StateMachine state(default_scheduler_settings); |
417 SET_UP_STATE(state) | 420 SET_UP_STATE(state) |
418 state.SetNeedsRedraw(true); | 421 state.SetNeedsRedraw(true); |
419 EXPECT_TRUE(state.RedrawPending()); | 422 EXPECT_TRUE(state.RedrawPending()); |
420 EXPECT_TRUE(state.BeginFrameNeeded()); | 423 EXPECT_TRUE(state.BeginFrameNeeded()); |
421 | 424 |
422 // Start a frame. | 425 // Start a frame. |
423 state.OnBeginImplFrame(); | 426 state.OnBeginImplFrame(0, 1); |
424 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 427 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
425 EXPECT_FALSE(state.CommitPending()); | 428 EXPECT_FALSE(state.CommitPending()); |
426 | 429 |
427 // Failing a draw triggers request for a new BeginMainFrame. | 430 // Failing a draw triggers request for a new BeginMainFrame. |
428 state.OnBeginImplFrameDeadline(); | 431 state.OnBeginImplFrameDeadline(); |
429 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); | 432 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
430 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 433 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
431 EXPECT_ACTION_UPDATE_STATE( | 434 EXPECT_ACTION_UPDATE_STATE( |
432 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 435 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
433 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 436 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
434 state.OnBeginImplFrameIdle(); | 437 state.OnBeginImplFrameIdle(); |
435 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 438 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
436 | 439 |
437 // It's okay to attempt more draws just in case additional raster | 440 // It's okay to attempt more draws just in case additional raster |
438 // finishes and the requested commit wasn't actually necessary. | 441 // finishes and the requested commit wasn't actually necessary. |
439 EXPECT_TRUE(state.CommitPending()); | 442 EXPECT_TRUE(state.CommitPending()); |
440 EXPECT_TRUE(state.RedrawPending()); | 443 EXPECT_TRUE(state.RedrawPending()); |
441 state.OnBeginImplFrame(); | 444 state.OnBeginImplFrame(0, 2); |
442 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 445 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
443 state.OnBeginImplFrameDeadline(); | 446 state.OnBeginImplFrameDeadline(); |
444 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); | 447 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
445 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 448 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
446 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 449 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
447 state.OnBeginImplFrameIdle(); | 450 state.OnBeginImplFrameIdle(); |
448 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 451 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
449 } | 452 } |
450 | 453 |
451 TEST(SchedulerStateMachineTest, FailedDrawForMissingHighResNeedsCommit) { | 454 TEST(SchedulerStateMachineTest, FailedDrawForMissingHighResNeedsCommit) { |
452 SchedulerSettings default_scheduler_settings; | 455 SchedulerSettings default_scheduler_settings; |
453 StateMachine state(default_scheduler_settings); | 456 StateMachine state(default_scheduler_settings); |
454 SET_UP_STATE(state) | 457 SET_UP_STATE(state) |
455 state.SetNeedsRedraw(true); | 458 state.SetNeedsRedraw(true); |
456 EXPECT_TRUE(state.RedrawPending()); | 459 EXPECT_TRUE(state.RedrawPending()); |
457 EXPECT_TRUE(state.BeginFrameNeeded()); | 460 EXPECT_TRUE(state.BeginFrameNeeded()); |
458 | 461 |
459 // Start a frame. | 462 // Start a frame. |
460 state.OnBeginImplFrame(); | 463 state.OnBeginImplFrame(0, 1); |
461 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 464 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
462 EXPECT_FALSE(state.CommitPending()); | 465 EXPECT_FALSE(state.CommitPending()); |
463 | 466 |
464 // Failing a draw triggers because of high res tiles missing | 467 // Failing a draw triggers because of high res tiles missing |
465 // request for a new BeginMainFrame. | 468 // request for a new BeginMainFrame. |
466 state.OnBeginImplFrameDeadline(); | 469 state.OnBeginImplFrameDeadline(); |
467 state.SetDrawResultForTest(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT); | 470 state.SetDrawResultForTest(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT); |
468 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 471 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
469 EXPECT_ACTION_UPDATE_STATE( | 472 EXPECT_ACTION_UPDATE_STATE( |
470 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 473 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
471 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 474 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
472 state.OnBeginImplFrameIdle(); | 475 state.OnBeginImplFrameIdle(); |
473 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 476 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
474 | 477 |
475 // It doesn't request a draw until we get a new commit though. | 478 // It doesn't request a draw until we get a new commit though. |
476 EXPECT_TRUE(state.CommitPending()); | 479 EXPECT_TRUE(state.CommitPending()); |
477 EXPECT_FALSE(state.RedrawPending()); | 480 EXPECT_FALSE(state.RedrawPending()); |
478 state.OnBeginImplFrame(); | 481 state.OnBeginImplFrame(0, 2); |
479 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 482 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
480 state.OnBeginImplFrameDeadline(); | 483 state.OnBeginImplFrameDeadline(); |
481 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 484 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
482 state.OnBeginImplFrameIdle(); | 485 state.OnBeginImplFrameIdle(); |
483 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 486 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
484 | 487 |
485 // Finish the commit and activation. | 488 // Finish the commit and activation. |
486 state.NotifyBeginMainFrameStarted(); | 489 state.NotifyBeginMainFrameStarted(); |
487 state.NotifyReadyToCommit(); | 490 state.NotifyReadyToCommit(); |
488 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 491 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
489 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 492 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
490 state.NotifyReadyToActivate(); | 493 state.NotifyReadyToActivate(); |
491 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 494 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
492 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 495 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
493 EXPECT_TRUE(state.RedrawPending()); | 496 EXPECT_TRUE(state.RedrawPending()); |
494 | 497 |
495 // Verify we draw with the new frame. | 498 // Verify we draw with the new frame. |
496 state.OnBeginImplFrame(); | 499 state.OnBeginImplFrame(0, 3); |
497 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 500 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
498 state.OnBeginImplFrameDeadline(); | 501 state.OnBeginImplFrameDeadline(); |
499 state.SetDrawResultForTest(DRAW_SUCCESS); | 502 state.SetDrawResultForTest(DRAW_SUCCESS); |
500 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 503 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
501 state.DidSubmitCompositorFrame(); | 504 state.DidSubmitCompositorFrame(); |
502 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 505 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
503 state.OnBeginImplFrameIdle(); | 506 state.OnBeginImplFrameIdle(); |
504 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 507 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
505 } | 508 } |
506 | 509 |
507 TEST(SchedulerStateMachineTest, | 510 TEST(SchedulerStateMachineTest, |
508 TestFailedDrawsEventuallyForceDrawAfterNextCommit) { | 511 TestFailedDrawsEventuallyForceDrawAfterNextCommit) { |
509 SchedulerSettings scheduler_settings; | 512 SchedulerSettings scheduler_settings; |
510 scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced = 1; | 513 scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced = 1; |
511 StateMachine state(scheduler_settings); | 514 StateMachine state(scheduler_settings); |
512 SET_UP_STATE(state) | 515 SET_UP_STATE(state) |
513 | 516 |
514 // Start a commit. | 517 // Start a commit. |
515 state.SetNeedsBeginMainFrame(); | 518 state.SetNeedsBeginMainFrame(); |
516 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 519 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
517 state.OnBeginImplFrame(); | 520 state.OnBeginImplFrame(0, 1); |
518 EXPECT_ACTION_UPDATE_STATE( | 521 EXPECT_ACTION_UPDATE_STATE( |
519 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 522 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
520 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 523 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
521 EXPECT_TRUE(state.CommitPending()); | 524 EXPECT_TRUE(state.CommitPending()); |
522 | 525 |
523 // Then initiate a draw that fails. | 526 // Then initiate a draw that fails. |
524 state.SetNeedsRedraw(true); | 527 state.SetNeedsRedraw(true); |
525 state.OnBeginImplFrameDeadline(); | 528 state.OnBeginImplFrameDeadline(); |
526 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); | 529 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
527 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 530 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
(...skipping 10 matching lines...) Expand all Loading... |
538 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 541 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
539 EXPECT_TRUE(state.RedrawPending()); | 542 EXPECT_TRUE(state.RedrawPending()); |
540 | 543 |
541 // Activate so we're ready for a new main frame. | 544 // Activate so we're ready for a new main frame. |
542 state.NotifyReadyToActivate(); | 545 state.NotifyReadyToActivate(); |
543 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 546 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
544 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 547 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
545 EXPECT_TRUE(state.RedrawPending()); | 548 EXPECT_TRUE(state.RedrawPending()); |
546 | 549 |
547 // The redraw should be forced at the end of the next BeginImplFrame. | 550 // The redraw should be forced at the end of the next BeginImplFrame. |
548 state.OnBeginImplFrame(); | 551 state.OnBeginImplFrame(0, 2); |
549 EXPECT_ACTION_UPDATE_STATE( | 552 EXPECT_ACTION_UPDATE_STATE( |
550 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 553 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
551 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 554 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
552 state.OnBeginImplFrameDeadline(); | 555 state.OnBeginImplFrameDeadline(); |
553 state.SetDrawResultForTest(DRAW_SUCCESS); | 556 state.SetDrawResultForTest(DRAW_SUCCESS); |
554 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_FORCED); | 557 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_FORCED); |
555 state.DidSubmitCompositorFrame(); | 558 state.DidSubmitCompositorFrame(); |
556 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 559 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
557 state.DidReceiveCompositorFrameAck(); | 560 state.DidReceiveCompositorFrameAck(); |
558 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 561 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
559 } | 562 } |
560 | 563 |
561 TEST(SchedulerStateMachineTest, TestFailedDrawsDoNotRestartForcedDraw) { | 564 TEST(SchedulerStateMachineTest, TestFailedDrawsDoNotRestartForcedDraw) { |
562 SchedulerSettings scheduler_settings; | 565 SchedulerSettings scheduler_settings; |
563 int draw_limit = 2; | 566 int draw_limit = 2; |
564 scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced = | 567 scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced = |
565 draw_limit; | 568 draw_limit; |
566 StateMachine state(scheduler_settings); | 569 StateMachine state(scheduler_settings); |
567 SET_UP_STATE(state) | 570 SET_UP_STATE(state) |
568 | 571 |
569 // Start a commit. | 572 // Start a commit. |
570 state.SetNeedsBeginMainFrame(); | 573 state.SetNeedsBeginMainFrame(); |
571 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 574 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
572 state.OnBeginImplFrame(); | 575 state.OnBeginImplFrame(0, 1); |
573 EXPECT_ACTION_UPDATE_STATE( | 576 EXPECT_ACTION_UPDATE_STATE( |
574 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 577 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
575 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 578 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
576 EXPECT_TRUE(state.CommitPending()); | 579 EXPECT_TRUE(state.CommitPending()); |
577 | 580 |
578 // Then initiate a draw. | 581 // Then initiate a draw. |
579 state.SetNeedsRedraw(true); | 582 state.SetNeedsRedraw(true); |
580 state.OnBeginImplFrameDeadline(); | 583 state.OnBeginImplFrameDeadline(); |
581 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 584 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
582 | 585 |
583 // Fail the draw enough times to force a redraw. | 586 // Fail the draw enough times to force a redraw. |
584 for (int i = 0; i < draw_limit; ++i) { | 587 for (int i = 0; i < draw_limit; ++i) { |
585 state.SetNeedsRedraw(true); | 588 state.SetNeedsRedraw(true); |
586 state.OnBeginImplFrame(); | 589 state.OnBeginImplFrame(0, i + 2); |
587 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 590 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
588 state.OnBeginImplFrameDeadline(); | 591 state.OnBeginImplFrameDeadline(); |
589 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); | 592 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
590 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 593 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
591 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 594 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
592 state.OnBeginImplFrameIdle(); | 595 state.OnBeginImplFrameIdle(); |
593 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 596 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
594 } | 597 } |
595 | 598 |
596 EXPECT_TRUE(state.BeginFrameNeeded()); | 599 EXPECT_TRUE(state.BeginFrameNeeded()); |
597 EXPECT_TRUE(state.RedrawPending()); | 600 EXPECT_TRUE(state.RedrawPending()); |
598 // But the commit is ongoing. | 601 // But the commit is ongoing. |
599 EXPECT_TRUE(state.CommitPending()); | 602 EXPECT_TRUE(state.CommitPending()); |
600 EXPECT_TRUE(state.ForcedRedrawState() == | 603 EXPECT_TRUE(state.ForcedRedrawState() == |
601 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_COMMIT); | 604 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_COMMIT); |
602 | 605 |
603 // After failing additional draws, we should still be in a forced | 606 // After failing additional draws, we should still be in a forced |
604 // redraw, but not back in IDLE. | 607 // redraw, but not back in IDLE. |
605 for (int i = 0; i < draw_limit; ++i) { | 608 for (int i = 0; i < draw_limit; ++i) { |
606 state.SetNeedsRedraw(true); | 609 state.SetNeedsRedraw(true); |
607 state.OnBeginImplFrame(); | 610 state.OnBeginImplFrame(0, draw_limit + i + 2); |
608 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 611 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
609 state.OnBeginImplFrameDeadline(); | 612 state.OnBeginImplFrameDeadline(); |
610 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); | 613 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
611 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 614 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
612 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 615 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
613 state.OnBeginImplFrameIdle(); | 616 state.OnBeginImplFrameIdle(); |
614 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 617 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
615 } | 618 } |
616 EXPECT_TRUE(state.RedrawPending()); | 619 EXPECT_TRUE(state.RedrawPending()); |
617 EXPECT_TRUE(state.ForcedRedrawState() == | 620 EXPECT_TRUE(state.ForcedRedrawState() == |
618 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_COMMIT); | 621 SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_COMMIT); |
619 } | 622 } |
620 | 623 |
621 TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) { | 624 TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) { |
622 SchedulerSettings default_scheduler_settings; | 625 SchedulerSettings default_scheduler_settings; |
623 StateMachine state(default_scheduler_settings); | 626 StateMachine state(default_scheduler_settings); |
624 SET_UP_STATE(state) | 627 SET_UP_STATE(state) |
625 | 628 |
626 // Start a draw. | 629 // Start a draw. |
627 state.SetNeedsRedraw(true); | 630 state.SetNeedsRedraw(true); |
628 EXPECT_TRUE(state.BeginFrameNeeded()); | 631 EXPECT_TRUE(state.BeginFrameNeeded()); |
629 state.OnBeginImplFrame(); | 632 state.OnBeginImplFrame(0, 1); |
630 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 633 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
631 state.OnBeginImplFrameDeadline(); | 634 state.OnBeginImplFrameDeadline(); |
632 EXPECT_TRUE(state.RedrawPending()); | 635 EXPECT_TRUE(state.RedrawPending()); |
633 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); | 636 state.SetDrawResultForTest(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS); |
634 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 637 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
635 | 638 |
636 // Failing the draw for animation checkerboards makes us require a commit. | 639 // Failing the draw for animation checkerboards makes us require a commit. |
637 EXPECT_ACTION_UPDATE_STATE( | 640 EXPECT_ACTION_UPDATE_STATE( |
638 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 641 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
639 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 642 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
640 EXPECT_TRUE(state.RedrawPending()); | 643 EXPECT_TRUE(state.RedrawPending()); |
641 | 644 |
642 // We should not be trying to draw again now, but we have a commit pending. | 645 // We should not be trying to draw again now, but we have a commit pending. |
643 EXPECT_TRUE(state.BeginFrameNeeded()); | 646 EXPECT_TRUE(state.BeginFrameNeeded()); |
644 state.OnBeginImplFrame(); | 647 state.OnBeginImplFrame(0, 2); |
645 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 648 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
646 | 649 |
647 // We should try to draw again at the end of the next BeginImplFrame on | 650 // We should try to draw again at the end of the next BeginImplFrame on |
648 // the impl thread. | 651 // the impl thread. |
649 state.OnBeginImplFrameDeadline(); | 652 state.OnBeginImplFrameDeadline(); |
650 state.SetDrawResultForTest(DRAW_SUCCESS); | 653 state.SetDrawResultForTest(DRAW_SUCCESS); |
651 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 654 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
652 state.DidSubmitCompositorFrame(); | 655 state.DidSubmitCompositorFrame(); |
653 state.DidReceiveCompositorFrameAck(); | 656 state.DidReceiveCompositorFrameAck(); |
654 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 657 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
655 } | 658 } |
656 | 659 |
657 TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) { | 660 TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) { |
658 SchedulerSettings default_scheduler_settings; | 661 SchedulerSettings default_scheduler_settings; |
659 StateMachine state(default_scheduler_settings); | 662 StateMachine state(default_scheduler_settings); |
660 SET_UP_STATE(state) | 663 SET_UP_STATE(state) |
661 state.SetNeedsRedraw(true); | 664 state.SetNeedsRedraw(true); |
662 | 665 |
663 // Draw the first frame. | 666 // Draw the first frame. |
664 EXPECT_TRUE(state.BeginFrameNeeded()); | 667 EXPECT_TRUE(state.BeginFrameNeeded()); |
665 state.OnBeginImplFrame(); | 668 state.OnBeginImplFrame(0, 1); |
666 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 669 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
667 | 670 |
668 state.OnBeginImplFrameDeadline(); | 671 state.OnBeginImplFrameDeadline(); |
669 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 672 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
670 state.DidSubmitCompositorFrame(); | 673 state.DidSubmitCompositorFrame(); |
671 state.DidReceiveCompositorFrameAck(); | 674 state.DidReceiveCompositorFrameAck(); |
672 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 675 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
673 | 676 |
674 // Before the next BeginImplFrame, set needs redraw again. | 677 // Before the next BeginImplFrame, set needs redraw again. |
675 // This should not redraw until the next BeginImplFrame. | 678 // This should not redraw until the next BeginImplFrame. |
676 state.SetNeedsRedraw(true); | 679 state.SetNeedsRedraw(true); |
677 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 680 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
678 | 681 |
679 // Move to another frame. This should now draw. | 682 // Move to another frame. This should now draw. |
680 EXPECT_TRUE(state.BeginFrameNeeded()); | 683 EXPECT_TRUE(state.BeginFrameNeeded()); |
681 state.OnBeginImplFrame(); | 684 state.OnBeginImplFrame(0, 2); |
682 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 685 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
683 state.OnBeginImplFrameDeadline(); | 686 state.OnBeginImplFrameDeadline(); |
684 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 687 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
685 state.DidSubmitCompositorFrame(); | 688 state.DidSubmitCompositorFrame(); |
686 state.DidReceiveCompositorFrameAck(); | 689 state.DidReceiveCompositorFrameAck(); |
687 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 690 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
688 | 691 |
689 // We just submitted, so we should proactively request another BeginImplFrame. | 692 // We just submitted, so we should proactively request another BeginImplFrame. |
690 EXPECT_TRUE(state.BeginFrameNeeded()); | 693 EXPECT_TRUE(state.BeginFrameNeeded()); |
691 } | 694 } |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
809 StateMachine state(default_scheduler_settings); | 812 StateMachine state(default_scheduler_settings); |
810 state.SetVisible(true); | 813 state.SetVisible(true); |
811 EXPECT_ACTION_UPDATE_STATE( | 814 EXPECT_ACTION_UPDATE_STATE( |
812 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 815 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
813 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 816 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
814 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 817 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
815 state.SetBeginMainFrameState(begin_main_frame_states[i]); | 818 state.SetBeginMainFrameState(begin_main_frame_states[i]); |
816 state.SetVisible(false); | 819 state.SetVisible(false); |
817 state.SetNeedsRedraw(true); | 820 state.SetNeedsRedraw(true); |
818 if (j == 1) | 821 if (j == 1) |
819 state.OnBeginImplFrame(); | 822 state.OnBeginImplFrame(0, i + 1); |
820 | 823 |
821 state.SetCanDraw(false); | 824 state.SetCanDraw(false); |
822 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, | 825 EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, |
823 state.NextAction()); | 826 state.NextAction()); |
824 } | 827 } |
825 } | 828 } |
826 } | 829 } |
827 | 830 |
828 TEST(SchedulerStateMachineTest, | 831 TEST(SchedulerStateMachineTest, |
829 TestCanRedrawWithWaitingForFirstDrawMakesProgress) { | 832 TestCanRedrawWithWaitingForFirstDrawMakesProgress) { |
830 SchedulerSettings default_scheduler_settings; | 833 SchedulerSettings default_scheduler_settings; |
831 StateMachine state(default_scheduler_settings); | 834 StateMachine state(default_scheduler_settings); |
832 state.SetVisible(true); | 835 state.SetVisible(true); |
833 EXPECT_ACTION_UPDATE_STATE( | 836 EXPECT_ACTION_UPDATE_STATE( |
834 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 837 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
835 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 838 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
836 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 839 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
837 | 840 |
838 state.SetActiveTreeNeedsFirstDraw(true); | 841 state.SetActiveTreeNeedsFirstDraw(true); |
839 state.SetNeedsBeginMainFrame(); | 842 state.SetNeedsBeginMainFrame(); |
840 state.SetNeedsRedraw(true); | 843 state.SetNeedsRedraw(true); |
841 state.SetCanDraw(false); | 844 state.SetCanDraw(false); |
842 state.OnBeginImplFrame(); | 845 state.OnBeginImplFrame(0, 1); |
843 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); | 846 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); |
844 EXPECT_ACTION_UPDATE_STATE( | 847 EXPECT_ACTION_UPDATE_STATE( |
845 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 848 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
846 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 849 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
847 state.NotifyBeginMainFrameStarted(); | 850 state.NotifyBeginMainFrameStarted(); |
848 state.NotifyReadyToCommit(); | 851 state.NotifyReadyToCommit(); |
849 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 852 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
850 state.NotifyReadyToActivate(); | 853 state.NotifyReadyToActivate(); |
851 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 854 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
852 state.OnBeginImplFrameDeadline(); | 855 state.OnBeginImplFrameDeadline(); |
853 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); | 856 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); |
854 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 857 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
855 } | 858 } |
856 | 859 |
857 TEST(SchedulerStateMachineTest, TestSetNeedsBeginMainFrameIsNotLost) { | 860 TEST(SchedulerStateMachineTest, TestSetNeedsBeginMainFrameIsNotLost) { |
858 SchedulerSettings scheduler_settings; | 861 SchedulerSettings scheduler_settings; |
859 StateMachine state(scheduler_settings); | 862 StateMachine state(scheduler_settings); |
860 SET_UP_STATE(state) | 863 SET_UP_STATE(state) |
861 state.SetNeedsBeginMainFrame(); | 864 state.SetNeedsBeginMainFrame(); |
862 | 865 |
863 EXPECT_TRUE(state.BeginFrameNeeded()); | 866 EXPECT_TRUE(state.BeginFrameNeeded()); |
864 | 867 |
865 // Begin the frame. | 868 // Begin the frame. |
866 state.OnBeginImplFrame(); | 869 state.OnBeginImplFrame(0, 1); |
867 EXPECT_ACTION_UPDATE_STATE( | 870 EXPECT_ACTION_UPDATE_STATE( |
868 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 871 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
869 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 872 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
870 | 873 |
871 // Now, while the frame is in progress, set another commit. | 874 // Now, while the frame is in progress, set another commit. |
872 state.SetNeedsBeginMainFrame(); | 875 state.SetNeedsBeginMainFrame(); |
873 EXPECT_TRUE(state.NeedsCommit()); | 876 EXPECT_TRUE(state.NeedsCommit()); |
874 | 877 |
875 // Let the frame finish. | 878 // Let the frame finish. |
876 state.NotifyBeginMainFrameStarted(); | 879 state.NotifyBeginMainFrameStarted(); |
877 state.NotifyReadyToCommit(); | 880 state.NotifyReadyToCommit(); |
878 EXPECT_MAIN_FRAME_STATE( | 881 EXPECT_MAIN_FRAME_STATE( |
879 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT); | 882 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT); |
880 | 883 |
881 // Expect to commit regardless of BeginImplFrame state. | 884 // Expect to commit regardless of BeginImplFrame state. |
882 EXPECT_IMPL_FRAME_STATE( | 885 EXPECT_IMPL_FRAME_STATE( |
883 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); | 886 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
884 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); | 887 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
885 | 888 |
886 state.OnBeginImplFrameDeadline(); | 889 state.OnBeginImplFrameDeadline(); |
887 EXPECT_IMPL_FRAME_STATE( | 890 EXPECT_IMPL_FRAME_STATE( |
888 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); | 891 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
889 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); | 892 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
890 | 893 |
891 state.OnBeginImplFrameIdle(); | 894 state.OnBeginImplFrameIdle(); |
892 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); | 895 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
893 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); | 896 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
894 | 897 |
895 state.OnBeginImplFrame(); | 898 state.OnBeginImplFrame(0, 2); |
896 EXPECT_IMPL_FRAME_STATE( | 899 EXPECT_IMPL_FRAME_STATE( |
897 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); | 900 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
898 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); | 901 EXPECT_ACTION(SchedulerStateMachine::ACTION_COMMIT); |
899 | 902 |
900 // Finish the commit and activate, then make sure we start the next commit | 903 // Finish the commit and activate, then make sure we start the next commit |
901 // immediately and draw on the next BeginImplFrame. | 904 // immediately and draw on the next BeginImplFrame. |
902 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 905 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
903 state.NotifyReadyToActivate(); | 906 state.NotifyReadyToActivate(); |
904 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 907 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
905 EXPECT_ACTION_UPDATE_STATE( | 908 EXPECT_ACTION_UPDATE_STATE( |
(...skipping 11 matching lines...) Expand all Loading... |
917 | 920 |
918 TEST(SchedulerStateMachineTest, TestFullCycle) { | 921 TEST(SchedulerStateMachineTest, TestFullCycle) { |
919 SchedulerSettings default_scheduler_settings; | 922 SchedulerSettings default_scheduler_settings; |
920 StateMachine state(default_scheduler_settings); | 923 StateMachine state(default_scheduler_settings); |
921 SET_UP_STATE(state) | 924 SET_UP_STATE(state) |
922 | 925 |
923 // Start clean and set commit. | 926 // Start clean and set commit. |
924 state.SetNeedsBeginMainFrame(); | 927 state.SetNeedsBeginMainFrame(); |
925 | 928 |
926 // Begin the frame. | 929 // Begin the frame. |
927 state.OnBeginImplFrame(); | 930 state.OnBeginImplFrame(0, 1); |
928 EXPECT_ACTION_UPDATE_STATE( | 931 EXPECT_ACTION_UPDATE_STATE( |
929 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 932 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
930 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 933 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
931 EXPECT_FALSE(state.NeedsCommit()); | 934 EXPECT_FALSE(state.NeedsCommit()); |
932 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 935 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
933 | 936 |
934 // Tell the scheduler the frame finished. | 937 // Tell the scheduler the frame finished. |
935 state.NotifyBeginMainFrameStarted(); | 938 state.NotifyBeginMainFrameStarted(); |
936 state.NotifyReadyToCommit(); | 939 state.NotifyReadyToCommit(); |
937 EXPECT_MAIN_FRAME_STATE( | 940 EXPECT_MAIN_FRAME_STATE( |
(...skipping 25 matching lines...) Expand all Loading... |
963 | 966 |
964 TEST(SchedulerStateMachineTest, CommitWithoutDrawWithPendingTree) { | 967 TEST(SchedulerStateMachineTest, CommitWithoutDrawWithPendingTree) { |
965 SchedulerSettings default_scheduler_settings; | 968 SchedulerSettings default_scheduler_settings; |
966 StateMachine state(default_scheduler_settings); | 969 StateMachine state(default_scheduler_settings); |
967 SET_UP_STATE(state) | 970 SET_UP_STATE(state) |
968 | 971 |
969 // Start clean and set commit. | 972 // Start clean and set commit. |
970 state.SetNeedsBeginMainFrame(); | 973 state.SetNeedsBeginMainFrame(); |
971 | 974 |
972 // Make a main frame, commit and activate it. But don't draw it. | 975 // Make a main frame, commit and activate it. But don't draw it. |
973 state.OnBeginImplFrame(); | 976 state.OnBeginImplFrame(0, 1); |
974 EXPECT_ACTION_UPDATE_STATE( | 977 EXPECT_ACTION_UPDATE_STATE( |
975 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 978 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
976 state.NotifyBeginMainFrameStarted(); | 979 state.NotifyBeginMainFrameStarted(); |
977 state.NotifyReadyToCommit(); | 980 state.NotifyReadyToCommit(); |
978 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 981 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
979 state.NotifyReadyToActivate(); | 982 state.NotifyReadyToActivate(); |
980 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 983 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
981 | 984 |
982 // Try to make a new main frame before drawing. Since we will commit it to a | 985 // Try to make a new main frame before drawing. Since we will commit it to a |
983 // pending tree and not clobber the active tree, we're able to start a new | 986 // pending tree and not clobber the active tree, we're able to start a new |
984 // begin frame and commit it. | 987 // begin frame and commit it. |
985 state.SetNeedsBeginMainFrame(); | 988 state.SetNeedsBeginMainFrame(); |
986 state.OnBeginImplFrame(); | 989 state.OnBeginImplFrame(0, 2); |
987 EXPECT_ACTION_UPDATE_STATE( | 990 EXPECT_ACTION_UPDATE_STATE( |
988 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 991 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
989 state.NotifyBeginMainFrameStarted(); | 992 state.NotifyBeginMainFrameStarted(); |
990 state.NotifyReadyToCommit(); | 993 state.NotifyReadyToCommit(); |
991 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 994 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
992 } | 995 } |
993 | 996 |
994 TEST(SchedulerStateMachineTest, DontCommitWithoutDrawWithoutPendingTree) { | 997 TEST(SchedulerStateMachineTest, DontCommitWithoutDrawWithoutPendingTree) { |
995 SchedulerSettings scheduler_settings; | 998 SchedulerSettings scheduler_settings; |
996 scheduler_settings.commit_to_active_tree = true; | 999 scheduler_settings.commit_to_active_tree = true; |
997 scheduler_settings.main_frame_before_activation_enabled = false; | 1000 scheduler_settings.main_frame_before_activation_enabled = false; |
998 StateMachine state(scheduler_settings); | 1001 StateMachine state(scheduler_settings); |
999 SET_UP_STATE(state) | 1002 SET_UP_STATE(state) |
1000 | 1003 |
1001 // Start clean and set commit. | 1004 // Start clean and set commit. |
1002 state.SetNeedsBeginMainFrame(); | 1005 state.SetNeedsBeginMainFrame(); |
1003 | 1006 |
1004 // Make a main frame, commit and activate it. But don't draw it. | 1007 // Make a main frame, commit and activate it. But don't draw it. |
1005 state.OnBeginImplFrame(); | 1008 state.OnBeginImplFrame(0, 1); |
1006 EXPECT_ACTION_UPDATE_STATE( | 1009 EXPECT_ACTION_UPDATE_STATE( |
1007 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1010 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1008 state.NotifyBeginMainFrameStarted(); | 1011 state.NotifyBeginMainFrameStarted(); |
1009 state.NotifyReadyToCommit(); | 1012 state.NotifyReadyToCommit(); |
1010 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1013 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1011 state.NotifyReadyToActivate(); | 1014 state.NotifyReadyToActivate(); |
1012 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1015 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1013 | 1016 |
1014 // Try to make a new main frame before drawing, but since we would clobber the | 1017 // Try to make a new main frame before drawing, but since we would clobber the |
1015 // active tree, we will not do so. | 1018 // active tree, we will not do so. |
1016 state.SetNeedsBeginMainFrame(); | 1019 state.SetNeedsBeginMainFrame(); |
1017 state.OnBeginImplFrame(); | 1020 state.OnBeginImplFrame(0, 2); |
1018 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1021 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1019 } | 1022 } |
1020 | 1023 |
1021 TEST(SchedulerStateMachineTest, AbortedMainFrameDoesNotResetPendingTree) { | 1024 TEST(SchedulerStateMachineTest, AbortedMainFrameDoesNotResetPendingTree) { |
1022 SchedulerSettings scheduler_settings; | 1025 SchedulerSettings scheduler_settings; |
1023 scheduler_settings.main_frame_before_activation_enabled = true; | 1026 scheduler_settings.main_frame_before_activation_enabled = true; |
1024 StateMachine state(scheduler_settings); | 1027 StateMachine state(scheduler_settings); |
1025 SET_UP_STATE(state); | 1028 SET_UP_STATE(state); |
1026 | 1029 |
1027 // Perform a commit so that we have an active tree. | 1030 // Perform a commit so that we have an active tree. |
1028 state.SetNeedsBeginMainFrame(); | 1031 state.SetNeedsBeginMainFrame(); |
1029 state.OnBeginImplFrame(); | 1032 state.OnBeginImplFrame(0, 1); |
1030 EXPECT_ACTION_UPDATE_STATE( | 1033 EXPECT_ACTION_UPDATE_STATE( |
1031 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1034 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1032 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1035 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1033 state.NotifyBeginMainFrameStarted(); | 1036 state.NotifyBeginMainFrameStarted(); |
1034 state.NotifyReadyToCommit(); | 1037 state.NotifyReadyToCommit(); |
1035 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1038 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1036 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1039 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1037 EXPECT_TRUE(state.has_pending_tree()); | 1040 EXPECT_TRUE(state.has_pending_tree()); |
1038 state.OnBeginImplFrameDeadline(); | 1041 state.OnBeginImplFrameDeadline(); |
1039 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1042 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1040 | 1043 |
1041 // Ask for another commit but abort it. Verify that we didn't reset pending | 1044 // Ask for another commit but abort it. Verify that we didn't reset pending |
1042 // tree state. | 1045 // tree state. |
1043 state.SetNeedsBeginMainFrame(); | 1046 state.SetNeedsBeginMainFrame(); |
1044 state.OnBeginImplFrame(); | 1047 state.OnBeginImplFrame(0, 2); |
1045 EXPECT_ACTION_UPDATE_STATE( | 1048 EXPECT_ACTION_UPDATE_STATE( |
1046 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1049 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1047 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1050 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1048 EXPECT_TRUE(state.has_pending_tree()); | 1051 EXPECT_TRUE(state.has_pending_tree()); |
1049 state.NotifyBeginMainFrameStarted(); | 1052 state.NotifyBeginMainFrameStarted(); |
1050 state.BeginMainFrameAborted(CommitEarlyOutReason::FINISHED_NO_UPDATES); | 1053 state.BeginMainFrameAborted(CommitEarlyOutReason::FINISHED_NO_UPDATES); |
1051 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1054 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1052 EXPECT_TRUE(state.has_pending_tree()); | 1055 EXPECT_TRUE(state.has_pending_tree()); |
1053 state.OnBeginImplFrameDeadline(); | 1056 state.OnBeginImplFrameDeadline(); |
1054 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1057 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1055 | 1058 |
1056 // Ask for another commit that doesn't abort. | 1059 // Ask for another commit that doesn't abort. |
1057 state.SetNeedsBeginMainFrame(); | 1060 state.SetNeedsBeginMainFrame(); |
1058 state.OnBeginImplFrame(); | 1061 state.OnBeginImplFrame(0, 3); |
1059 EXPECT_ACTION_UPDATE_STATE( | 1062 EXPECT_ACTION_UPDATE_STATE( |
1060 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1063 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1061 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1064 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1062 state.NotifyBeginMainFrameStarted(); | 1065 state.NotifyBeginMainFrameStarted(); |
1063 state.NotifyReadyToCommit(); | 1066 state.NotifyReadyToCommit(); |
1064 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1067 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1065 EXPECT_TRUE(state.has_pending_tree()); | 1068 EXPECT_TRUE(state.has_pending_tree()); |
1066 | 1069 |
1067 // Verify that commit is delayed until the pending tree is activated. | 1070 // Verify that commit is delayed until the pending tree is activated. |
1068 state.NotifyReadyToActivate(); | 1071 state.NotifyReadyToActivate(); |
1069 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1072 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1070 EXPECT_FALSE(state.has_pending_tree()); | 1073 EXPECT_FALSE(state.has_pending_tree()); |
1071 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1074 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1072 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1075 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1073 EXPECT_TRUE(state.has_pending_tree()); | 1076 EXPECT_TRUE(state.has_pending_tree()); |
1074 } | 1077 } |
1075 | 1078 |
1076 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitToActive) { | 1079 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitToActive) { |
1077 SchedulerSettings scheduler_settings; | 1080 SchedulerSettings scheduler_settings; |
1078 scheduler_settings.commit_to_active_tree = true; | 1081 scheduler_settings.commit_to_active_tree = true; |
1079 scheduler_settings.main_frame_before_activation_enabled = false; | 1082 scheduler_settings.main_frame_before_activation_enabled = false; |
1080 StateMachine state(scheduler_settings); | 1083 StateMachine state(scheduler_settings); |
1081 SET_UP_STATE(state) | 1084 SET_UP_STATE(state) |
1082 | 1085 |
1083 // Start clean and set commit. | 1086 // Start clean and set commit. |
1084 state.SetNeedsBeginMainFrame(); | 1087 state.SetNeedsBeginMainFrame(); |
1085 | 1088 |
1086 // Begin the frame. | 1089 // Begin the frame. |
1087 state.OnBeginImplFrame(); | 1090 state.OnBeginImplFrame(0, 1); |
1088 EXPECT_ACTION_UPDATE_STATE( | 1091 EXPECT_ACTION_UPDATE_STATE( |
1089 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1092 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1090 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 1093 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
1091 EXPECT_FALSE(state.NeedsCommit()); | 1094 EXPECT_FALSE(state.NeedsCommit()); |
1092 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1095 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1093 | 1096 |
1094 // Tell the scheduler the frame finished. | 1097 // Tell the scheduler the frame finished. |
1095 state.NotifyBeginMainFrameStarted(); | 1098 state.NotifyBeginMainFrameStarted(); |
1096 state.NotifyReadyToCommit(); | 1099 state.NotifyReadyToCommit(); |
1097 EXPECT_MAIN_FRAME_STATE( | 1100 EXPECT_MAIN_FRAME_STATE( |
1098 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT); | 1101 SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT); |
1099 // Commit. | 1102 // Commit. |
1100 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1103 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1101 // Commit always calls NotifyReadyToActivate in this mode. | 1104 // Commit always calls NotifyReadyToActivate in this mode. |
1102 state.NotifyReadyToActivate(); | 1105 state.NotifyReadyToActivate(); |
1103 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1106 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1104 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1107 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1105 | 1108 |
1106 // No draw because we haven't received NotifyReadyToDraw yet. | 1109 // No draw because we haven't received NotifyReadyToDraw yet. |
1107 state.OnBeginImplFrameDeadline(); | 1110 state.OnBeginImplFrameDeadline(); |
1108 EXPECT_TRUE(state.active_tree_needs_first_draw()); | 1111 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
1109 EXPECT_TRUE(state.needs_redraw()); | 1112 EXPECT_TRUE(state.needs_redraw()); |
1110 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1113 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1111 | 1114 |
1112 // Can't BeginMainFrame yet since last commit hasn't been drawn yet. | 1115 // Can't BeginMainFrame yet since last commit hasn't been drawn yet. |
1113 state.SetNeedsBeginMainFrame(); | 1116 state.SetNeedsBeginMainFrame(); |
1114 state.OnBeginImplFrame(); | 1117 state.OnBeginImplFrame(0, 2); |
1115 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1118 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1116 | 1119 |
1117 // Now call ready to draw which will allow the draw to happen and | 1120 // Now call ready to draw which will allow the draw to happen and |
1118 // BeginMainFrame to be sent. | 1121 // BeginMainFrame to be sent. |
1119 state.NotifyReadyToDraw(); | 1122 state.NotifyReadyToDraw(); |
1120 state.OnBeginImplFrameDeadline(); | 1123 state.OnBeginImplFrameDeadline(); |
1121 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1124 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1122 // Submit throttled from this point. | 1125 // Submit throttled from this point. |
1123 state.DidSubmitCompositorFrame(); | 1126 state.DidSubmitCompositorFrame(); |
1124 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1127 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1125 | 1128 |
1126 // Can't BeginMainFrame yet since we're submit-frame throttled. | 1129 // Can't BeginMainFrame yet since we're submit-frame throttled. |
1127 state.OnBeginImplFrame(); | 1130 state.OnBeginImplFrame(0, 3); |
1128 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1131 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1129 | 1132 |
1130 // CompositorFrameAck unblocks BeginMainFrame. | 1133 // CompositorFrameAck unblocks BeginMainFrame. |
1131 state.DidReceiveCompositorFrameAck(); | 1134 state.DidReceiveCompositorFrameAck(); |
1132 EXPECT_ACTION_UPDATE_STATE( | 1135 EXPECT_ACTION_UPDATE_STATE( |
1133 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1136 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1134 state.NotifyBeginMainFrameStarted(); | 1137 state.NotifyBeginMainFrameStarted(); |
1135 state.NotifyReadyToCommit(); | 1138 state.NotifyReadyToCommit(); |
1136 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1139 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1137 state.NotifyReadyToActivate(); | 1140 state.NotifyReadyToActivate(); |
1138 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1141 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1139 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1142 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1140 | 1143 |
1141 // Draw the newly activated tree. | 1144 // Draw the newly activated tree. |
1142 state.NotifyReadyToDraw(); | 1145 state.NotifyReadyToDraw(); |
1143 state.OnBeginImplFrameDeadline(); | 1146 state.OnBeginImplFrameDeadline(); |
1144 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1147 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1145 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1148 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1146 } | 1149 } |
1147 | 1150 |
1148 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) { | 1151 TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) { |
1149 SchedulerSettings default_scheduler_settings; | 1152 SchedulerSettings default_scheduler_settings; |
1150 StateMachine state(default_scheduler_settings); | 1153 StateMachine state(default_scheduler_settings); |
1151 SET_UP_STATE(state) | 1154 SET_UP_STATE(state) |
1152 | 1155 |
1153 // Start clean and set commit. | 1156 // Start clean and set commit. |
1154 state.SetNeedsBeginMainFrame(); | 1157 state.SetNeedsBeginMainFrame(); |
1155 | 1158 |
1156 // Begin the frame. | 1159 // Begin the frame. |
1157 state.OnBeginImplFrame(); | 1160 state.OnBeginImplFrame(0, 1); |
1158 EXPECT_ACTION_UPDATE_STATE( | 1161 EXPECT_ACTION_UPDATE_STATE( |
1159 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1162 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1160 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 1163 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
1161 EXPECT_FALSE(state.NeedsCommit()); | 1164 EXPECT_FALSE(state.NeedsCommit()); |
1162 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1165 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1163 | 1166 |
1164 // Request another commit while the commit is in flight. | 1167 // Request another commit while the commit is in flight. |
1165 state.SetNeedsBeginMainFrame(); | 1168 state.SetNeedsBeginMainFrame(); |
1166 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1169 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1167 | 1170 |
(...skipping 18 matching lines...) Expand all Loading... |
1186 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1189 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1187 state.DidSubmitCompositorFrame(); | 1190 state.DidSubmitCompositorFrame(); |
1188 state.DidReceiveCompositorFrameAck(); | 1191 state.DidReceiveCompositorFrameAck(); |
1189 | 1192 |
1190 // Should be synchronized, no draw needed, no action needed. | 1193 // Should be synchronized, no draw needed, no action needed. |
1191 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1194 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1192 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 1195 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
1193 EXPECT_FALSE(state.needs_redraw()); | 1196 EXPECT_FALSE(state.needs_redraw()); |
1194 | 1197 |
1195 // Next BeginImplFrame should initiate second commit. | 1198 // Next BeginImplFrame should initiate second commit. |
1196 state.OnBeginImplFrame(); | 1199 state.OnBeginImplFrame(0, 2); |
1197 EXPECT_ACTION_UPDATE_STATE( | 1200 EXPECT_ACTION_UPDATE_STATE( |
1198 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1201 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1199 } | 1202 } |
1200 | 1203 |
1201 TEST(SchedulerStateMachineTest, TestNoRequestCommitWhenInvisible) { | 1204 TEST(SchedulerStateMachineTest, TestNoRequestCommitWhenInvisible) { |
1202 SchedulerSettings default_scheduler_settings; | 1205 SchedulerSettings default_scheduler_settings; |
1203 StateMachine state(default_scheduler_settings); | 1206 StateMachine state(default_scheduler_settings); |
1204 state.SetVisible(true); | 1207 state.SetVisible(true); |
1205 EXPECT_ACTION_UPDATE_STATE( | 1208 EXPECT_ACTION_UPDATE_STATE( |
1206 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1209 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1249 // "EarlyOut_CompositorFrameSinkLost" cases. | 1252 // "EarlyOut_CompositorFrameSinkLost" cases. |
1250 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) { | 1253 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) { |
1251 SchedulerSettings default_scheduler_settings; | 1254 SchedulerSettings default_scheduler_settings; |
1252 StateMachine state(default_scheduler_settings); | 1255 StateMachine state(default_scheduler_settings); |
1253 SET_UP_STATE(state) | 1256 SET_UP_STATE(state) |
1254 | 1257 |
1255 // Start clean and set commit. | 1258 // Start clean and set commit. |
1256 state.SetNeedsBeginMainFrame(); | 1259 state.SetNeedsBeginMainFrame(); |
1257 | 1260 |
1258 // Begin the frame while visible. | 1261 // Begin the frame while visible. |
1259 state.OnBeginImplFrame(); | 1262 state.OnBeginImplFrame(0, 1); |
1260 EXPECT_ACTION_UPDATE_STATE( | 1263 EXPECT_ACTION_UPDATE_STATE( |
1261 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1264 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1262 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 1265 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
1263 EXPECT_FALSE(state.NeedsCommit()); | 1266 EXPECT_FALSE(state.NeedsCommit()); |
1264 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1267 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1265 | 1268 |
1266 // Become invisible and abort BeginMainFrame. | 1269 // Become invisible and abort BeginMainFrame. |
1267 state.SetVisible(false); | 1270 state.SetVisible(false); |
1268 state.NotifyBeginMainFrameStarted(); | 1271 state.NotifyBeginMainFrameStarted(); |
1269 state.BeginMainFrameAborted(CommitEarlyOutReason::ABORTED_NOT_VISIBLE); | 1272 state.BeginMainFrameAborted(CommitEarlyOutReason::ABORTED_NOT_VISIBLE); |
(...skipping 13 matching lines...) Expand all Loading... |
1283 // Become visible again. | 1286 // Become visible again. |
1284 state.SetVisible(true); | 1287 state.SetVisible(true); |
1285 | 1288 |
1286 // Although we have aborted on this frame and haven't cancelled the commit | 1289 // Although we have aborted on this frame and haven't cancelled the commit |
1287 // (i.e. need another), don't send another BeginMainFrame yet. | 1290 // (i.e. need another), don't send another BeginMainFrame yet. |
1288 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 1291 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
1289 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1292 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1290 EXPECT_TRUE(state.NeedsCommit()); | 1293 EXPECT_TRUE(state.NeedsCommit()); |
1291 | 1294 |
1292 // Start a new frame. | 1295 // Start a new frame. |
1293 state.OnBeginImplFrame(); | 1296 state.OnBeginImplFrame(0, 2); |
1294 EXPECT_ACTION_UPDATE_STATE( | 1297 EXPECT_ACTION_UPDATE_STATE( |
1295 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1298 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1296 | 1299 |
1297 // We should be starting the commit now. | 1300 // We should be starting the commit now. |
1298 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 1301 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
1299 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1302 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1300 } | 1303 } |
1301 | 1304 |
1302 // See ProxyMain::BeginMainFrame "EarlyOut_NoUpdates" case. | 1305 // See ProxyMain::BeginMainFrame "EarlyOut_NoUpdates" case. |
1303 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) { | 1306 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) { |
1304 SchedulerSettings default_scheduler_settings; | 1307 SchedulerSettings default_scheduler_settings; |
1305 StateMachine state(default_scheduler_settings); | 1308 StateMachine state(default_scheduler_settings); |
1306 state.SetVisible(true); | 1309 state.SetVisible(true); |
1307 EXPECT_ACTION_UPDATE_STATE( | 1310 EXPECT_ACTION_UPDATE_STATE( |
1308 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1311 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1309 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1312 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1310 state.DidCreateAndInitializeCompositorFrameSink(); | 1313 state.DidCreateAndInitializeCompositorFrameSink(); |
1311 state.SetCanDraw(true); | 1314 state.SetCanDraw(true); |
1312 | 1315 |
1313 // Get into a begin frame / commit state. | 1316 // Get into a begin frame / commit state. |
1314 state.SetNeedsBeginMainFrame(); | 1317 state.SetNeedsBeginMainFrame(); |
1315 state.OnBeginImplFrame(); | 1318 state.OnBeginImplFrame(0, 1); |
1316 EXPECT_ACTION_UPDATE_STATE( | 1319 EXPECT_ACTION_UPDATE_STATE( |
1317 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1320 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1318 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 1321 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
1319 EXPECT_FALSE(state.NeedsCommit()); | 1322 EXPECT_FALSE(state.NeedsCommit()); |
1320 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1323 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1321 | 1324 |
1322 // Abort the commit, true means that the BeginMainFrame was sent but there | 1325 // Abort the commit, true means that the BeginMainFrame was sent but there |
1323 // was no work to do on the main thread. | 1326 // was no work to do on the main thread. |
1324 state.NotifyBeginMainFrameStarted(); | 1327 state.NotifyBeginMainFrameStarted(); |
1325 state.BeginMainFrameAborted(CommitEarlyOutReason::FINISHED_NO_UPDATES); | 1328 state.BeginMainFrameAborted(CommitEarlyOutReason::FINISHED_NO_UPDATES); |
1326 | 1329 |
1327 // NeedsCommit should now be false because the commit was actually handled. | 1330 // NeedsCommit should now be false because the commit was actually handled. |
1328 EXPECT_FALSE(state.NeedsCommit()); | 1331 EXPECT_FALSE(state.NeedsCommit()); |
1329 | 1332 |
1330 // Since the commit was aborted, we don't need to try and draw. | 1333 // Since the commit was aborted, we don't need to try and draw. |
1331 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1334 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1332 state.OnBeginImplFrameDeadline(); | 1335 state.OnBeginImplFrameDeadline(); |
1333 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1336 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1334 | 1337 |
1335 // Verify another commit doesn't start on another frame either. | 1338 // Verify another commit doesn't start on another frame either. |
1336 EXPECT_FALSE(state.NeedsCommit()); | 1339 EXPECT_FALSE(state.NeedsCommit()); |
1337 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 1340 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
1338 | 1341 |
1339 state.OnBeginImplFrame(); | 1342 state.OnBeginImplFrame(0, 2); |
1340 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1343 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1341 state.OnBeginImplFrameDeadline(); | 1344 state.OnBeginImplFrameDeadline(); |
1342 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1345 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1343 | 1346 |
1344 // Verify another commit can start if requested, though. | 1347 // Verify another commit can start if requested, though. |
1345 state.SetNeedsBeginMainFrame(); | 1348 state.SetNeedsBeginMainFrame(); |
1346 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); | 1349 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE); |
1347 state.OnBeginImplFrame(); | 1350 state.OnBeginImplFrame(0, 3); |
1348 EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1351 EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1349 } | 1352 } |
1350 | 1353 |
1351 TEST(SchedulerStateMachineTest, TestFirstContextCreation) { | 1354 TEST(SchedulerStateMachineTest, TestFirstContextCreation) { |
1352 SchedulerSettings default_scheduler_settings; | 1355 SchedulerSettings default_scheduler_settings; |
1353 StateMachine state(default_scheduler_settings); | 1356 StateMachine state(default_scheduler_settings); |
1354 state.SetVisible(true); | 1357 state.SetVisible(true); |
1355 state.SetCanDraw(true); | 1358 state.SetCanDraw(true); |
1356 | 1359 |
1357 EXPECT_ACTION_UPDATE_STATE( | 1360 EXPECT_ACTION_UPDATE_STATE( |
1358 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1361 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1359 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 1362 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
1360 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1363 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1361 | 1364 |
1362 // Check that the first init does not SetNeedsBeginMainFrame. | 1365 // Check that the first init does not SetNeedsBeginMainFrame. |
1363 state.OnBeginImplFrame(); | 1366 state.OnBeginImplFrame(0, 1); |
1364 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1367 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1365 state.OnBeginImplFrameDeadline(); | 1368 state.OnBeginImplFrameDeadline(); |
1366 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1369 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1367 | 1370 |
1368 // Check that a needs commit initiates a BeginMainFrame. | 1371 // Check that a needs commit initiates a BeginMainFrame. |
1369 state.SetNeedsBeginMainFrame(); | 1372 state.SetNeedsBeginMainFrame(); |
1370 state.OnBeginImplFrame(); | 1373 state.OnBeginImplFrame(0, 2); |
1371 EXPECT_ACTION_UPDATE_STATE( | 1374 EXPECT_ACTION_UPDATE_STATE( |
1372 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1375 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1373 } | 1376 } |
1374 | 1377 |
1375 TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) { | 1378 TEST(SchedulerStateMachineTest, TestContextLostWhenCompletelyIdle) { |
1376 SchedulerSettings default_scheduler_settings; | 1379 SchedulerSettings default_scheduler_settings; |
1377 StateMachine state(default_scheduler_settings); | 1380 StateMachine state(default_scheduler_settings); |
1378 SET_UP_STATE(state) | 1381 SET_UP_STATE(state) |
1379 | 1382 |
1380 EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION, | 1383 EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION, |
1381 state.NextAction()); | 1384 state.NextAction()); |
1382 state.DidLoseCompositorFrameSink(); | 1385 state.DidLoseCompositorFrameSink(); |
1383 | 1386 |
1384 EXPECT_ACTION_UPDATE_STATE( | 1387 EXPECT_ACTION_UPDATE_STATE( |
1385 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1388 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1386 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1389 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1387 | 1390 |
1388 // Once context recreation begins, nothing should happen. | 1391 // Once context recreation begins, nothing should happen. |
1389 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1392 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1390 | 1393 |
1391 // Recreate the context. | 1394 // Recreate the context. |
1392 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 1395 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
1393 | 1396 |
1394 // When the context is recreated, we should begin a commit. | 1397 // When the context is recreated, we should begin a commit. |
1395 state.OnBeginImplFrame(); | 1398 state.OnBeginImplFrame(0, 1); |
1396 EXPECT_ACTION_UPDATE_STATE( | 1399 EXPECT_ACTION_UPDATE_STATE( |
1397 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1400 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1398 } | 1401 } |
1399 | 1402 |
1400 TEST(SchedulerStateMachineTest, | 1403 TEST(SchedulerStateMachineTest, |
1401 TestContextLostWhenIdleAndCommitRequestedWhileRecreating) { | 1404 TestContextLostWhenIdleAndCommitRequestedWhileRecreating) { |
1402 SchedulerSettings default_scheduler_settings; | 1405 SchedulerSettings default_scheduler_settings; |
1403 StateMachine state(default_scheduler_settings); | 1406 StateMachine state(default_scheduler_settings); |
1404 SET_UP_STATE(state) | 1407 SET_UP_STATE(state) |
1405 | 1408 |
1406 EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION, | 1409 EXPECT_NE(SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION, |
1407 state.NextAction()); | 1410 state.NextAction()); |
1408 state.DidLoseCompositorFrameSink(); | 1411 state.DidLoseCompositorFrameSink(); |
1409 EXPECT_EQ(state.compositor_frame_sink_state(), | 1412 EXPECT_EQ(state.compositor_frame_sink_state(), |
1410 SchedulerStateMachine::COMPOSITOR_FRAME_SINK_NONE); | 1413 SchedulerStateMachine::COMPOSITOR_FRAME_SINK_NONE); |
1411 | 1414 |
1412 EXPECT_ACTION_UPDATE_STATE( | 1415 EXPECT_ACTION_UPDATE_STATE( |
1413 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1416 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1414 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1417 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1415 | 1418 |
1416 // Once context recreation begins, nothing should happen. | 1419 // Once context recreation begins, nothing should happen. |
1417 state.OnBeginImplFrame(); | 1420 state.OnBeginImplFrame(0, 1); |
1418 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1421 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1419 state.OnBeginImplFrameDeadline(); | 1422 state.OnBeginImplFrameDeadline(); |
1420 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1423 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1421 | 1424 |
1422 // While context is recreating, commits shouldn't begin. | 1425 // While context is recreating, commits shouldn't begin. |
1423 state.SetNeedsBeginMainFrame(); | 1426 state.SetNeedsBeginMainFrame(); |
1424 state.OnBeginImplFrame(); | 1427 state.OnBeginImplFrame(0, 2); |
1425 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1428 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1426 state.OnBeginImplFrameDeadline(); | 1429 state.OnBeginImplFrameDeadline(); |
1427 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1430 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1428 | 1431 |
1429 // Recreate the context | 1432 // Recreate the context |
1430 state.DidCreateAndInitializeCompositorFrameSink(); | 1433 state.DidCreateAndInitializeCompositorFrameSink(); |
1431 EXPECT_EQ( | 1434 EXPECT_EQ( |
1432 state.compositor_frame_sink_state(), | 1435 state.compositor_frame_sink_state(), |
1433 SchedulerStateMachine::COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT); | 1436 SchedulerStateMachine::COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT); |
1434 EXPECT_FALSE(state.RedrawPending()); | 1437 EXPECT_FALSE(state.RedrawPending()); |
1435 | 1438 |
1436 // When the context is recreated, we wait until the next BeginImplFrame | 1439 // When the context is recreated, we wait until the next BeginImplFrame |
1437 // before starting. | 1440 // before starting. |
1438 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1441 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1439 | 1442 |
1440 // When the BeginFrame comes in we should begin a commit | 1443 // When the BeginFrame comes in we should begin a commit |
1441 state.OnBeginImplFrame(); | 1444 state.OnBeginImplFrame(0, 3); |
1442 EXPECT_ACTION_UPDATE_STATE( | 1445 EXPECT_ACTION_UPDATE_STATE( |
1443 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1446 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1444 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1447 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1445 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); | 1448 EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT); |
1446 | 1449 |
1447 // Until that commit finishes, we shouldn't be drawing. | 1450 // Until that commit finishes, we shouldn't be drawing. |
1448 state.OnBeginImplFrameDeadline(); | 1451 state.OnBeginImplFrameDeadline(); |
1449 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1452 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1450 | 1453 |
1451 // Finish the commit, which should make the surface active. | 1454 // Finish the commit, which should make the surface active. |
1452 state.NotifyBeginMainFrameStarted(); | 1455 state.NotifyBeginMainFrameStarted(); |
1453 state.NotifyReadyToCommit(); | 1456 state.NotifyReadyToCommit(); |
1454 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1457 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1455 EXPECT_EQ(state.compositor_frame_sink_state(), | 1458 EXPECT_EQ(state.compositor_frame_sink_state(), |
1456 SchedulerStateMachine:: | 1459 SchedulerStateMachine:: |
1457 COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION); | 1460 COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION); |
1458 state.NotifyReadyToActivate(); | 1461 state.NotifyReadyToActivate(); |
1459 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1462 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1460 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1463 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1461 EXPECT_EQ(state.compositor_frame_sink_state(), | 1464 EXPECT_EQ(state.compositor_frame_sink_state(), |
1462 SchedulerStateMachine::COMPOSITOR_FRAME_SINK_ACTIVE); | 1465 SchedulerStateMachine::COMPOSITOR_FRAME_SINK_ACTIVE); |
1463 | 1466 |
1464 // Finishing the first commit after initializing an CompositorFrameSink should | 1467 // Finishing the first commit after initializing an CompositorFrameSink should |
1465 // automatically cause a redraw. | 1468 // automatically cause a redraw. |
1466 EXPECT_TRUE(state.RedrawPending()); | 1469 EXPECT_TRUE(state.RedrawPending()); |
1467 state.OnBeginImplFrame(); | 1470 state.OnBeginImplFrame(0, 4); |
1468 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1471 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1469 state.OnBeginImplFrameDeadline(); | 1472 state.OnBeginImplFrameDeadline(); |
1470 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1473 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1471 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1474 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1472 EXPECT_FALSE(state.RedrawPending()); | 1475 EXPECT_FALSE(state.RedrawPending()); |
1473 | 1476 |
1474 // Next frame as no work to do. | 1477 // Next frame as no work to do. |
1475 state.OnBeginImplFrame(); | 1478 state.OnBeginImplFrame(0, 5); |
1476 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1479 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1477 state.OnBeginImplFrameDeadline(); | 1480 state.OnBeginImplFrameDeadline(); |
1478 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1481 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1479 | 1482 |
1480 // Once the context is recreated, whether we draw should be based on | 1483 // Once the context is recreated, whether we draw should be based on |
1481 // SetCanDraw if waiting on first draw after activate. | 1484 // SetCanDraw if waiting on first draw after activate. |
1482 state.SetNeedsRedraw(true); | 1485 state.SetNeedsRedraw(true); |
1483 state.OnBeginImplFrame(); | 1486 state.OnBeginImplFrame(0, 6); |
1484 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1487 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1485 state.OnBeginImplFrameDeadline(); | 1488 state.OnBeginImplFrameDeadline(); |
1486 EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1489 EXPECT_ACTION(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1487 state.SetCanDraw(false); | 1490 state.SetCanDraw(false); |
1488 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1491 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1489 state.SetCanDraw(true); | 1492 state.SetCanDraw(true); |
1490 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1493 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1491 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1494 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1492 | 1495 |
1493 // Once the context is recreated, whether we draw should be based on | 1496 // Once the context is recreated, whether we draw should be based on |
1494 // SetCanDraw if waiting on first draw after activate. | 1497 // SetCanDraw if waiting on first draw after activate. |
1495 state.SetNeedsRedraw(true); | 1498 state.SetNeedsRedraw(true); |
1496 state.SetNeedsBeginMainFrame(); | 1499 state.SetNeedsBeginMainFrame(); |
1497 state.OnBeginImplFrame(); | 1500 state.OnBeginImplFrame(0, 7); |
1498 EXPECT_ACTION_UPDATE_STATE( | 1501 EXPECT_ACTION_UPDATE_STATE( |
1499 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1502 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1500 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1503 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1501 // Activate so we need the first draw | 1504 // Activate so we need the first draw |
1502 state.NotifyBeginMainFrameStarted(); | 1505 state.NotifyBeginMainFrameStarted(); |
1503 state.NotifyReadyToCommit(); | 1506 state.NotifyReadyToCommit(); |
1504 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1507 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1505 state.NotifyReadyToActivate(); | 1508 state.NotifyReadyToActivate(); |
1506 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1509 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1507 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1510 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
(...skipping 11 matching lines...) Expand all Loading... |
1519 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) { | 1522 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) { |
1520 SchedulerSettings scheduler_settings; | 1523 SchedulerSettings scheduler_settings; |
1521 StateMachine state(scheduler_settings); | 1524 StateMachine state(scheduler_settings); |
1522 SET_UP_STATE(state) | 1525 SET_UP_STATE(state) |
1523 | 1526 |
1524 // Get a commit in flight. | 1527 // Get a commit in flight. |
1525 state.SetNeedsBeginMainFrame(); | 1528 state.SetNeedsBeginMainFrame(); |
1526 | 1529 |
1527 // Set damage and expect a draw. | 1530 // Set damage and expect a draw. |
1528 state.SetNeedsRedraw(true); | 1531 state.SetNeedsRedraw(true); |
1529 state.OnBeginImplFrame(); | 1532 state.OnBeginImplFrame(0, 1); |
1530 EXPECT_ACTION_UPDATE_STATE( | 1533 EXPECT_ACTION_UPDATE_STATE( |
1531 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1534 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1532 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1535 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1533 state.OnBeginImplFrameDeadline(); | 1536 state.OnBeginImplFrameDeadline(); |
1534 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1537 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1535 state.DidSubmitCompositorFrame(); | 1538 state.DidSubmitCompositorFrame(); |
1536 state.DidReceiveCompositorFrameAck(); | 1539 state.DidReceiveCompositorFrameAck(); |
1537 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1540 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1538 | 1541 |
1539 // Cause a lost context while the BeginMainFrame is in flight. | 1542 // Cause a lost context while the BeginMainFrame is in flight. |
(...skipping 13 matching lines...) Expand all Loading... |
1553 // We will abort the draw when the CompositorFrameSink is lost if we are | 1556 // We will abort the draw when the CompositorFrameSink is lost if we are |
1554 // waiting for the first draw to unblock the main thread. | 1557 // waiting for the first draw to unblock the main thread. |
1555 EXPECT_TRUE(state.active_tree_needs_first_draw()); | 1558 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
1556 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); | 1559 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); |
1557 | 1560 |
1558 // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE | 1561 // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE |
1559 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); | 1562 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
1560 EXPECT_ACTION( | 1563 EXPECT_ACTION( |
1561 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1564 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1562 | 1565 |
1563 state.OnBeginImplFrame(); | 1566 state.OnBeginImplFrame(0, 2); |
1564 EXPECT_IMPL_FRAME_STATE( | 1567 EXPECT_IMPL_FRAME_STATE( |
1565 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); | 1568 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
1566 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1569 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1567 | 1570 |
1568 state.OnBeginImplFrameDeadline(); | 1571 state.OnBeginImplFrameDeadline(); |
1569 EXPECT_IMPL_FRAME_STATE( | 1572 EXPECT_IMPL_FRAME_STATE( |
1570 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); | 1573 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
1571 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1574 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1572 } | 1575 } |
1573 | 1576 |
1574 TEST(SchedulerStateMachineTest, | 1577 TEST(SchedulerStateMachineTest, |
1575 TestContextLostWhileCommitInProgressAndAnotherCommitRequested) { | 1578 TestContextLostWhileCommitInProgressAndAnotherCommitRequested) { |
1576 SchedulerSettings scheduler_settings; | 1579 SchedulerSettings scheduler_settings; |
1577 StateMachine state(scheduler_settings); | 1580 StateMachine state(scheduler_settings); |
1578 SET_UP_STATE(state) | 1581 SET_UP_STATE(state) |
1579 | 1582 |
1580 // Get a commit in flight. | 1583 // Get a commit in flight. |
1581 state.SetNeedsBeginMainFrame(); | 1584 state.SetNeedsBeginMainFrame(); |
1582 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1585 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1583 | 1586 |
1584 // Set damage and expect a draw. | 1587 // Set damage and expect a draw. |
1585 state.SetNeedsRedraw(true); | 1588 state.SetNeedsRedraw(true); |
1586 state.OnBeginImplFrame(); | 1589 state.OnBeginImplFrame(0, 1); |
1587 EXPECT_ACTION_UPDATE_STATE( | 1590 EXPECT_ACTION_UPDATE_STATE( |
1588 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1591 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1589 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1592 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1590 state.OnBeginImplFrameDeadline(); | 1593 state.OnBeginImplFrameDeadline(); |
1591 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1594 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1592 state.DidSubmitCompositorFrame(); | 1595 state.DidSubmitCompositorFrame(); |
1593 state.DidReceiveCompositorFrameAck(); | 1596 state.DidReceiveCompositorFrameAck(); |
1594 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1597 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1595 | 1598 |
1596 // Cause a lost context while the BeginMainFrame is in flight. | 1599 // Cause a lost context while the BeginMainFrame is in flight. |
(...skipping 13 matching lines...) Expand all Loading... |
1610 EXPECT_TRUE(state.active_tree_needs_first_draw()); | 1613 EXPECT_TRUE(state.active_tree_needs_first_draw()); |
1611 | 1614 |
1612 // Because the CompositorFrameSink is missing, we expect the draw to abort. | 1615 // Because the CompositorFrameSink is missing, we expect the draw to abort. |
1613 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); | 1616 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_ABORT); |
1614 | 1617 |
1615 // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE | 1618 // Expect to begin context recreation only in BEGIN_IMPL_FRAME_STATE_IDLE |
1616 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); | 1619 EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE); |
1617 EXPECT_ACTION( | 1620 EXPECT_ACTION( |
1618 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1621 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1619 | 1622 |
1620 state.OnBeginImplFrame(); | 1623 state.OnBeginImplFrame(0, 2); |
1621 EXPECT_IMPL_FRAME_STATE( | 1624 EXPECT_IMPL_FRAME_STATE( |
1622 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); | 1625 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME); |
1623 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1626 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1624 | 1627 |
1625 state.OnBeginImplFrameDeadline(); | 1628 state.OnBeginImplFrameDeadline(); |
1626 EXPECT_IMPL_FRAME_STATE( | 1629 EXPECT_IMPL_FRAME_STATE( |
1627 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); | 1630 SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE); |
1628 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1631 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1629 | 1632 |
1630 state.OnBeginImplFrameIdle(); | 1633 state.OnBeginImplFrameIdle(); |
1631 EXPECT_ACTION_UPDATE_STATE( | 1634 EXPECT_ACTION_UPDATE_STATE( |
1632 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1635 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1633 | 1636 |
1634 // After we get a new CompositorFrameSink, the commit flow should start. | 1637 // After we get a new CompositorFrameSink, the commit flow should start. |
1635 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 1638 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
1636 state.OnBeginImplFrame(); | 1639 state.OnBeginImplFrame(0, 3); |
1637 EXPECT_ACTION_UPDATE_STATE( | 1640 EXPECT_ACTION_UPDATE_STATE( |
1638 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1641 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1639 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1642 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1640 state.NotifyBeginMainFrameStarted(); | 1643 state.NotifyBeginMainFrameStarted(); |
1641 state.NotifyReadyToCommit(); | 1644 state.NotifyReadyToCommit(); |
1642 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1645 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1643 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1646 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1644 state.NotifyReadyToActivate(); | 1647 state.NotifyReadyToActivate(); |
1645 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1648 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1646 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1649 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
(...skipping 13 matching lines...) Expand all Loading... |
1660 state.SetNeedsRedraw(true); | 1663 state.SetNeedsRedraw(true); |
1661 | 1664 |
1662 // Cause a lost CompositorFrameSink, and restore it. | 1665 // Cause a lost CompositorFrameSink, and restore it. |
1663 state.DidLoseCompositorFrameSink(); | 1666 state.DidLoseCompositorFrameSink(); |
1664 EXPECT_ACTION_UPDATE_STATE( | 1667 EXPECT_ACTION_UPDATE_STATE( |
1665 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1668 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
1666 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1669 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1667 state.DidCreateAndInitializeCompositorFrameSink(); | 1670 state.DidCreateAndInitializeCompositorFrameSink(); |
1668 | 1671 |
1669 EXPECT_FALSE(state.RedrawPending()); | 1672 EXPECT_FALSE(state.RedrawPending()); |
1670 state.OnBeginImplFrame(); | 1673 state.OnBeginImplFrame(0, 1); |
1671 EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1674 EXPECT_ACTION(SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1672 } | 1675 } |
1673 | 1676 |
1674 TEST(SchedulerStateMachineTest, | 1677 TEST(SchedulerStateMachineTest, |
1675 TestPendingActivationsShouldBeForcedAfterLostCompositorFrameSink) { | 1678 TestPendingActivationsShouldBeForcedAfterLostCompositorFrameSink) { |
1676 SchedulerSettings default_scheduler_settings; | 1679 SchedulerSettings default_scheduler_settings; |
1677 StateMachine state(default_scheduler_settings); | 1680 StateMachine state(default_scheduler_settings); |
1678 SET_UP_STATE(state) | 1681 SET_UP_STATE(state) |
1679 | 1682 |
1680 state.SetBeginMainFrameState( | 1683 state.SetBeginMainFrameState( |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1723 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1726 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1724 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); | 1727 state.CreateAndInitializeCompositorFrameSinkWithActivatedCommit(); |
1725 state.SetVisible(false); | 1728 state.SetVisible(false); |
1726 state.SetNeedsBeginMainFrame(); | 1729 state.SetNeedsBeginMainFrame(); |
1727 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); | 1730 EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE); |
1728 EXPECT_FALSE(state.BeginFrameNeeded()); | 1731 EXPECT_FALSE(state.BeginFrameNeeded()); |
1729 | 1732 |
1730 // When become visible again, the needs commit should still be pending. | 1733 // When become visible again, the needs commit should still be pending. |
1731 state.SetVisible(true); | 1734 state.SetVisible(true); |
1732 EXPECT_TRUE(state.BeginFrameNeeded()); | 1735 EXPECT_TRUE(state.BeginFrameNeeded()); |
1733 state.OnBeginImplFrame(); | 1736 state.OnBeginImplFrame(0, 1); |
1734 EXPECT_ACTION_UPDATE_STATE( | 1737 EXPECT_ACTION_UPDATE_STATE( |
1735 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1738 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1736 } | 1739 } |
1737 | 1740 |
1738 TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) { | 1741 TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) { |
1739 SchedulerSettings default_scheduler_settings; | 1742 SchedulerSettings default_scheduler_settings; |
1740 StateMachine state(default_scheduler_settings); | 1743 StateMachine state(default_scheduler_settings); |
1741 state.SetVisible(true); | 1744 state.SetVisible(true); |
1742 EXPECT_ACTION_UPDATE_STATE( | 1745 EXPECT_ACTION_UPDATE_STATE( |
1743 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 1746 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1887 } | 1890 } |
1888 | 1891 |
1889 TEST(SchedulerStateMachineTest, | 1892 TEST(SchedulerStateMachineTest, |
1890 TestTriggerDeadlineImmediatelyAfterAbortedCommit) { | 1893 TestTriggerDeadlineImmediatelyAfterAbortedCommit) { |
1891 SchedulerSettings default_scheduler_settings; | 1894 SchedulerSettings default_scheduler_settings; |
1892 StateMachine state(default_scheduler_settings); | 1895 StateMachine state(default_scheduler_settings); |
1893 SET_UP_STATE(state) | 1896 SET_UP_STATE(state) |
1894 | 1897 |
1895 // This test mirrors what happens during the first frame of a scroll gesture. | 1898 // This test mirrors what happens during the first frame of a scroll gesture. |
1896 // First we get the input event and a BeginFrame. | 1899 // First we get the input event and a BeginFrame. |
1897 state.OnBeginImplFrame(); | 1900 state.OnBeginImplFrame(0, 1); |
1898 | 1901 |
1899 // As a response the compositor requests a redraw and a commit to tell the | 1902 // As a response the compositor requests a redraw and a commit to tell the |
1900 // main thread about the new scroll offset. | 1903 // main thread about the new scroll offset. |
1901 state.SetNeedsRedraw(true); | 1904 state.SetNeedsRedraw(true); |
1902 state.SetNeedsBeginMainFrame(); | 1905 state.SetNeedsBeginMainFrame(); |
1903 | 1906 |
1904 // We should start the commit normally. | 1907 // We should start the commit normally. |
1905 EXPECT_ACTION_UPDATE_STATE( | 1908 EXPECT_ACTION_UPDATE_STATE( |
1906 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1909 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1907 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1910 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
(...skipping 14 matching lines...) Expand all Loading... |
1922 StateMachine& state = *state_ptr; | 1925 StateMachine& state = *state_ptr; |
1923 | 1926 |
1924 state.NotifyBeginMainFrameStarted(); | 1927 state.NotifyBeginMainFrameStarted(); |
1925 state.NotifyReadyToCommit(); | 1928 state.NotifyReadyToCommit(); |
1926 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); | 1929 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT); |
1927 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1930 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1928 state.NotifyReadyToActivate(); | 1931 state.NotifyReadyToActivate(); |
1929 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); | 1932 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE); |
1930 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1933 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1931 | 1934 |
1932 state.OnBeginImplFrame(); | 1935 state.OnBeginImplFrame(0, 1); |
1933 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1936 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1934 | 1937 |
1935 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 1938 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
1936 state.OnBeginImplFrameDeadline(); | 1939 state.OnBeginImplFrameDeadline(); |
1937 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); | 1940 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE); |
1938 state.DidSubmitCompositorFrame(); | 1941 state.DidSubmitCompositorFrame(); |
1939 } | 1942 } |
1940 | 1943 |
1941 TEST(SchedulerStateMachineTest, TestImplLatencyTakesPriority) { | 1944 TEST(SchedulerStateMachineTest, TestImplLatencyTakesPriority) { |
1942 SchedulerSettings default_scheduler_settings; | 1945 SchedulerSettings default_scheduler_settings; |
1943 StateMachine state(default_scheduler_settings); | 1946 StateMachine state(default_scheduler_settings); |
1944 SET_UP_STATE(state) | 1947 SET_UP_STATE(state) |
1945 | 1948 |
1946 // This test ensures that impl-draws are prioritized over main thread updates | 1949 // This test ensures that impl-draws are prioritized over main thread updates |
1947 // in prefer impl latency mode. | 1950 // in prefer impl latency mode. |
1948 state.SetNeedsRedraw(true); | 1951 state.SetNeedsRedraw(true); |
1949 state.SetNeedsBeginMainFrame(); | 1952 state.SetNeedsBeginMainFrame(); |
1950 state.OnBeginImplFrame(); | 1953 state.OnBeginImplFrame(0, 1); |
1951 EXPECT_ACTION_UPDATE_STATE( | 1954 EXPECT_ACTION_UPDATE_STATE( |
1952 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 1955 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
1953 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1956 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1954 | 1957 |
1955 // Verify the deadline is not triggered early until we enter | 1958 // Verify the deadline is not triggered early until we enter |
1956 // prefer impl latency mode. | 1959 // prefer impl latency mode. |
1957 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 1960 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
1958 state.SetTreePrioritiesAndScrollState( | 1961 state.SetTreePrioritiesAndScrollState( |
1959 SMOOTHNESS_TAKES_PRIORITY, | 1962 SMOOTHNESS_TAKES_PRIORITY, |
1960 ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER); | 1963 ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER); |
(...skipping 16 matching lines...) Expand all Loading... |
1977 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1980 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1978 | 1981 |
1979 // Finish the previous commit and draw it. | 1982 // Finish the previous commit and draw it. |
1980 FinishPreviousCommitAndDrawWithoutExitingDeadline(&state); | 1983 FinishPreviousCommitAndDrawWithoutExitingDeadline(&state); |
1981 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1984 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1982 | 1985 |
1983 // Verify we do not send another BeginMainFrame if was are submit-frame | 1986 // Verify we do not send another BeginMainFrame if was are submit-frame |
1984 // throttled and did not just submit one. | 1987 // throttled and did not just submit one. |
1985 state.SetNeedsBeginMainFrame(); | 1988 state.SetNeedsBeginMainFrame(); |
1986 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1989 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1987 state.OnBeginImplFrame(); | 1990 state.OnBeginImplFrame(0, 2); |
1988 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1991 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1989 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 1992 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
1990 state.OnBeginImplFrameDeadline(); | 1993 state.OnBeginImplFrameDeadline(); |
1991 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 1994 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
1992 } | 1995 } |
1993 | 1996 |
1994 TEST(SchedulerStateMachineTest, | 1997 TEST(SchedulerStateMachineTest, |
1995 TestTriggerDeadlineImmediatelyOnLostCompositorFrameSink) { | 1998 TestTriggerDeadlineImmediatelyOnLostCompositorFrameSink) { |
1996 SchedulerSettings default_scheduler_settings; | 1999 SchedulerSettings default_scheduler_settings; |
1997 StateMachine state(default_scheduler_settings); | 2000 StateMachine state(default_scheduler_settings); |
1998 SET_UP_STATE(state) | 2001 SET_UP_STATE(state) |
1999 | 2002 |
2000 state.SetNeedsBeginMainFrame(); | 2003 state.SetNeedsBeginMainFrame(); |
2001 | 2004 |
2002 state.OnBeginImplFrame(); | 2005 state.OnBeginImplFrame(0, 1); |
2003 EXPECT_ACTION_UPDATE_STATE( | 2006 EXPECT_ACTION_UPDATE_STATE( |
2004 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 2007 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
2005 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2008 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2006 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 2009 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
2007 | 2010 |
2008 state.DidLoseCompositorFrameSink(); | 2011 state.DidLoseCompositorFrameSink(); |
2009 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2012 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2010 // The deadline should be triggered immediately when CompositorFrameSink is | 2013 // The deadline should be triggered immediately when CompositorFrameSink is |
2011 // lost. | 2014 // lost. |
2012 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 2015 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
2013 } | 2016 } |
2014 | 2017 |
2015 TEST(SchedulerStateMachineTest, TestTriggerDeadlineImmediatelyWhenInvisible) { | 2018 TEST(SchedulerStateMachineTest, TestTriggerDeadlineImmediatelyWhenInvisible) { |
2016 SchedulerSettings default_scheduler_settings; | 2019 SchedulerSettings default_scheduler_settings; |
2017 StateMachine state(default_scheduler_settings); | 2020 StateMachine state(default_scheduler_settings); |
2018 SET_UP_STATE(state) | 2021 SET_UP_STATE(state) |
2019 | 2022 |
2020 state.SetNeedsBeginMainFrame(); | 2023 state.SetNeedsBeginMainFrame(); |
2021 | 2024 |
2022 state.OnBeginImplFrame(); | 2025 state.OnBeginImplFrame(0, 1); |
2023 EXPECT_ACTION_UPDATE_STATE( | 2026 EXPECT_ACTION_UPDATE_STATE( |
2024 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 2027 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
2025 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2028 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2026 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 2029 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
2027 | 2030 |
2028 state.SetVisible(false); | 2031 state.SetVisible(false); |
2029 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2032 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2030 EXPECT_TRUE(state.PendingActivationsShouldBeForced()); | 2033 EXPECT_TRUE(state.PendingActivationsShouldBeForced()); |
2031 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 2034 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
2032 } | 2035 } |
2033 | 2036 |
2034 TEST(SchedulerStateMachineTest, | 2037 TEST(SchedulerStateMachineTest, |
2035 TestTriggerDeadlineImmediatelyWhenBeginFrameSourcePaused) { | 2038 TestTriggerDeadlineImmediatelyWhenBeginFrameSourcePaused) { |
2036 SchedulerSettings default_scheduler_settings; | 2039 SchedulerSettings default_scheduler_settings; |
2037 StateMachine state(default_scheduler_settings); | 2040 StateMachine state(default_scheduler_settings); |
2038 SET_UP_STATE(state) | 2041 SET_UP_STATE(state) |
2039 | 2042 |
2040 state.SetNeedsBeginMainFrame(); | 2043 state.SetNeedsBeginMainFrame(); |
2041 | 2044 |
2042 state.OnBeginImplFrame(); | 2045 state.OnBeginImplFrame(0, 1); |
2043 EXPECT_ACTION_UPDATE_STATE( | 2046 EXPECT_ACTION_UPDATE_STATE( |
2044 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 2047 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
2045 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2048 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2046 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 2049 EXPECT_FALSE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
2047 | 2050 |
2048 state.SetBeginFrameSourcePaused(true); | 2051 state.SetBeginFrameSourcePaused(true); |
2049 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2052 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2050 EXPECT_TRUE(state.PendingActivationsShouldBeForced()); | 2053 EXPECT_TRUE(state.PendingActivationsShouldBeForced()); |
2051 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); | 2054 EXPECT_TRUE(state.ShouldTriggerBeginImplFrameDeadlineImmediately()); |
2052 } | 2055 } |
2053 | 2056 |
2054 TEST(SchedulerStateMachineTest, TestDeferCommit) { | 2057 TEST(SchedulerStateMachineTest, TestDeferCommit) { |
2055 SchedulerSettings settings; | 2058 SchedulerSettings settings; |
2056 StateMachine state(settings); | 2059 StateMachine state(settings); |
2057 SET_UP_STATE(state) | 2060 SET_UP_STATE(state) |
2058 | 2061 |
2059 state.SetDeferCommits(true); | 2062 state.SetDeferCommits(true); |
2060 | 2063 |
2061 state.SetNeedsBeginMainFrame(); | 2064 state.SetNeedsBeginMainFrame(); |
2062 EXPECT_FALSE(state.BeginFrameNeeded()); | 2065 EXPECT_FALSE(state.BeginFrameNeeded()); |
2063 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2066 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2064 | 2067 |
2065 state.OnBeginImplFrame(); | 2068 state.OnBeginImplFrame(0, 1); |
2066 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2069 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2067 | 2070 |
2068 state.OnBeginImplFrameDeadline(); | 2071 state.OnBeginImplFrameDeadline(); |
2069 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2072 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2070 | 2073 |
2071 state.SetDeferCommits(false); | 2074 state.SetDeferCommits(false); |
2072 state.OnBeginImplFrame(); | 2075 state.OnBeginImplFrame(0, 2); |
2073 EXPECT_ACTION_UPDATE_STATE( | 2076 EXPECT_ACTION_UPDATE_STATE( |
2074 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 2077 SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
2075 } | 2078 } |
2076 | 2079 |
2077 TEST(SchedulerStateMachineTest, EarlyOutCommitWantsProactiveBeginFrame) { | 2080 TEST(SchedulerStateMachineTest, EarlyOutCommitWantsProactiveBeginFrame) { |
2078 SchedulerSettings settings; | 2081 SchedulerSettings settings; |
2079 StateMachine state(settings); | 2082 StateMachine state(settings); |
2080 SET_UP_STATE(state); | 2083 SET_UP_STATE(state); |
2081 | 2084 |
2082 EXPECT_FALSE(state.ProactiveBeginFrameWanted()); | 2085 EXPECT_FALSE(state.ProactiveBeginFrameWanted()); |
2083 bool commit_has_no_updates = true; | 2086 bool commit_has_no_updates = true; |
2084 state.WillCommit(commit_has_no_updates); | 2087 state.WillCommit(commit_has_no_updates); |
2085 EXPECT_TRUE(state.ProactiveBeginFrameWanted()); | 2088 EXPECT_TRUE(state.ProactiveBeginFrameWanted()); |
2086 state.OnBeginImplFrame(); | 2089 state.OnBeginImplFrame(0, 1); |
2087 EXPECT_FALSE(state.ProactiveBeginFrameWanted()); | 2090 EXPECT_FALSE(state.ProactiveBeginFrameWanted()); |
2088 } | 2091 } |
2089 | 2092 |
2090 TEST(SchedulerStateMachineTest, | 2093 TEST(SchedulerStateMachineTest, |
2091 NoCompositorFrameSinkCreationWhileCommitPending) { | 2094 NoCompositorFrameSinkCreationWhileCommitPending) { |
2092 SchedulerSettings settings; | 2095 SchedulerSettings settings; |
2093 StateMachine state(settings); | 2096 StateMachine state(settings); |
2094 SET_UP_STATE(state); | 2097 SET_UP_STATE(state); |
2095 | 2098 |
2096 // Set up the request for a commit and start a frame. | 2099 // Set up the request for a commit and start a frame. |
2097 state.SetNeedsBeginMainFrame(); | 2100 state.SetNeedsBeginMainFrame(); |
2098 state.OnBeginImplFrame(); | 2101 state.OnBeginImplFrame(0, 1); |
2099 PerformAction(&state, SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 2102 PerformAction(&state, SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
2100 | 2103 |
2101 // Lose the CompositorFrameSink. | 2104 // Lose the CompositorFrameSink. |
2102 state.DidLoseCompositorFrameSink(); | 2105 state.DidLoseCompositorFrameSink(); |
2103 | 2106 |
2104 // The scheduler shouldn't trigger the CompositorFrameSink creation till the | 2107 // The scheduler shouldn't trigger the CompositorFrameSink creation till the |
2105 // previous commit has been cleared. | 2108 // previous commit has been cleared. |
2106 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2109 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2107 | 2110 |
2108 // Trigger the deadline and ensure that the scheduler does not trigger any | 2111 // Trigger the deadline and ensure that the scheduler does not trigger any |
(...skipping 15 matching lines...) Expand all Loading... |
2124 } | 2127 } |
2125 | 2128 |
2126 TEST(SchedulerStateMachineTest, CompositorFrameSinkCreationWhileCommitPending) { | 2129 TEST(SchedulerStateMachineTest, CompositorFrameSinkCreationWhileCommitPending) { |
2127 SchedulerSettings settings; | 2130 SchedulerSettings settings; |
2128 settings.abort_commit_before_compositor_frame_sink_creation = false; | 2131 settings.abort_commit_before_compositor_frame_sink_creation = false; |
2129 StateMachine state(settings); | 2132 StateMachine state(settings); |
2130 SET_UP_STATE(state); | 2133 SET_UP_STATE(state); |
2131 | 2134 |
2132 // Set up the request for a commit and start a frame. | 2135 // Set up the request for a commit and start a frame. |
2133 state.SetNeedsBeginMainFrame(); | 2136 state.SetNeedsBeginMainFrame(); |
2134 state.OnBeginImplFrame(); | 2137 state.OnBeginImplFrame(0, 1); |
2135 PerformAction(&state, SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); | 2138 PerformAction(&state, SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME); |
2136 | 2139 |
2137 // Lose the CompositorFrameSink. | 2140 // Lose the CompositorFrameSink. |
2138 state.DidLoseCompositorFrameSink(); | 2141 state.DidLoseCompositorFrameSink(); |
2139 | 2142 |
2140 // The scheduler shouldn't trigger the CompositorFrameSink creation till the | 2143 // The scheduler shouldn't trigger the CompositorFrameSink creation till the |
2141 // previous begin impl frame state is cleared from the pipeline. | 2144 // previous begin impl frame state is cleared from the pipeline. |
2142 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); | 2145 EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE); |
2143 | 2146 |
2144 // Cycle through the frame stages to clear the scheduler state. | 2147 // Cycle through the frame stages to clear the scheduler state. |
2145 state.OnBeginImplFrameDeadline(); | 2148 state.OnBeginImplFrameDeadline(); |
2146 state.OnBeginImplFrameIdle(); | 2149 state.OnBeginImplFrameIdle(); |
2147 | 2150 |
2148 // The scheduler should begin the CompositorFrameSink creation now. | 2151 // The scheduler should begin the CompositorFrameSink creation now. |
2149 EXPECT_ACTION_UPDATE_STATE( | 2152 EXPECT_ACTION_UPDATE_STATE( |
2150 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); | 2153 SchedulerStateMachine::ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION); |
2151 } | 2154 } |
2152 | 2155 |
2153 } // namespace | 2156 } // namespace |
2154 } // namespace cc | 2157 } // namespace cc |
OLD | NEW |