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

Side by Side Diff: cc/scheduler/scheduler_unittest.cc

Issue 1229573004: cc: Simplify and rename MainThreadIsInHighLatency logic (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@ignoreFirstDraws4
Patch Set: Update naming and conventions Created 5 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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.h" 5 #include "cc/scheduler/scheduler.h"
6 6
7 #include <string> 7 #include <string>
8 #include <vector> 8 #include <vector>
9 9
10 #include "base/logging.h" 10 #include "base/logging.h"
(...skipping 1281 matching lines...) Expand 10 before | Expand all | Expand 10 after
1292 task_runner().RunPendingTasks(); // Run posted deadline. 1292 task_runner().RunPendingTasks(); // Run posted deadline.
1293 EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3); 1293 EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
1294 EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3); 1294 EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3);
1295 EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3); 1295 EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
1296 } 1296 }
1297 1297
1298 void SchedulerTest::CheckMainFrameSkippedAfterLateCommit( 1298 void SchedulerTest::CheckMainFrameSkippedAfterLateCommit(
1299 bool expect_send_begin_main_frame) { 1299 bool expect_send_begin_main_frame) {
1300 // Impl thread hits deadline before commit finishes. 1300 // Impl thread hits deadline before commit finishes.
1301 scheduler_->SetNeedsCommit(); 1301 scheduler_->SetNeedsCommit();
1302 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1302 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1303 EXPECT_SCOPED(AdvanceFrame()); 1303 EXPECT_SCOPED(AdvanceFrame());
1304 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1304 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1305 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1305 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1306 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1306 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1307 scheduler_->NotifyBeginMainFrameStarted(); 1307 scheduler_->NotifyBeginMainFrameStarted();
1308 scheduler_->NotifyReadyToCommit(); 1308 scheduler_->NotifyReadyToCommit();
1309 scheduler_->NotifyReadyToActivate(); 1309 scheduler_->NotifyReadyToActivate();
1310 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 5); 1310 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 5);
1311 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5); 1311 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5);
1312 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5); 1312 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5);
1313 EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5); 1313 EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5);
1314 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5); 1314 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5);
1315 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1315 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1316 1316
1317 client_->Reset(); 1317 client_->Reset();
1318 scheduler_->SetNeedsCommit(); 1318 scheduler_->SetNeedsCommit();
1319 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1319 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1320 EXPECT_SCOPED(AdvanceFrame()); 1320 EXPECT_SCOPED(AdvanceFrame());
1321 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1321 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1322 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1322 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1323 EXPECT_EQ(expect_send_begin_main_frame, 1323 EXPECT_EQ(expect_send_begin_main_frame,
1324 scheduler_->MainThreadIsInHighLatencyMode()); 1324 scheduler_->MainThreadMissedLastDeadline());
1325 EXPECT_EQ(expect_send_begin_main_frame, 1325 EXPECT_EQ(expect_send_begin_main_frame,
1326 client_->HasAction("ScheduledActionSendBeginMainFrame")); 1326 client_->HasAction("ScheduledActionSendBeginMainFrame"));
1327 } 1327 }
1328 1328
1329 TEST_F(SchedulerTest, MainFrameSkippedAfterLateCommit) { 1329 TEST_F(SchedulerTest, MainFrameSkippedAfterLateCommit) {
1330 scheduler_settings_.use_external_begin_frame_source = true; 1330 scheduler_settings_.use_external_begin_frame_source = true;
1331 SetUpScheduler(true); 1331 SetUpScheduler(true);
1332 1332
1333 auto fast_duration = base::TimeDelta::FromMilliseconds(1); 1333 auto fast_duration = base::TimeDelta::FromMilliseconds(1);
1334 fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration); 1334 fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after
1412 void SchedulerTest::ImplFrameSkippedAfterLateSwapAck_MainThreadMakesDeadline( 1412 void SchedulerTest::ImplFrameSkippedAfterLateSwapAck_MainThreadMakesDeadline(
1413 bool swap_ack_before_deadline) { 1413 bool swap_ack_before_deadline) {
1414 // To get into a high latency state, this test disables automatic swap acks. 1414 // To get into a high latency state, this test disables automatic swap acks.
1415 scheduler_->SetMaxSwapsPending(1); 1415 scheduler_->SetMaxSwapsPending(1);
1416 client_->SetAutomaticSwapAck(false); 1416 client_->SetAutomaticSwapAck(false);
1417 1417
1418 // Draw and swap for first BeginFrame 1418 // Draw and swap for first BeginFrame
1419 client_->Reset(); 1419 client_->Reset();
1420 scheduler_->SetNeedsCommit(); 1420 scheduler_->SetNeedsCommit();
1421 scheduler_->SetNeedsRedraw(); 1421 scheduler_->SetNeedsRedraw();
1422 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1422 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1423 SendNextBeginFrame(); 1423 SendNextBeginFrame();
1424 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 4); 1424 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 4);
1425 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 4); 1425 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 4);
1426 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4); 1426 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
1427 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 3, 4); 1427 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 3, 4);
1428 1428
1429 client_->Reset(); 1429 client_->Reset();
1430 scheduler_->NotifyBeginMainFrameStarted(); 1430 scheduler_->NotifyBeginMainFrameStarted();
1431 scheduler_->NotifyReadyToCommit(); 1431 scheduler_->NotifyReadyToCommit();
1432 scheduler_->NotifyReadyToActivate(); 1432 scheduler_->NotifyReadyToActivate();
1433 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1433 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1434 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1434 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1435 EXPECT_ACTION("ScheduledActionCommit", client_, 0, 4); 1435 EXPECT_ACTION("ScheduledActionCommit", client_, 0, 4);
1436 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4); 1436 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4);
1437 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4); 1437 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
1438 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4); 1438 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
1439 1439
1440 // Verify we skip every other frame if the swap ack consistently 1440 // Verify we skip every other frame if the swap ack consistently
1441 // comes back late. 1441 // comes back late.
1442 for (int i = 0; i < 10; i++) { 1442 for (int i = 0; i < 10; i++) {
1443 // Not calling scheduler_->DidSwapBuffersComplete() until after next 1443 // Not calling scheduler_->DidSwapBuffersComplete() until after next
1444 // BeginImplFrame puts the impl thread in high latency mode. 1444 // BeginImplFrame puts the impl thread in high latency mode.
1445 client_->Reset(); 1445 client_->Reset();
1446 scheduler_->SetNeedsCommit(); 1446 scheduler_->SetNeedsCommit();
1447 scheduler_->SetNeedsRedraw(); 1447 scheduler_->SetNeedsRedraw();
1448 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1448 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1449 SendNextBeginFrame(); 1449 SendNextBeginFrame();
1450 // Verify that we skip the BeginImplFrame 1450 // Verify that we skip the BeginImplFrame
1451 EXPECT_NO_ACTION(client_); 1451 EXPECT_NO_ACTION(client_);
1452 EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending()); 1452 EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
1453 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1453 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1454 1454
1455 // Verify that we do not perform any actions after we are no longer 1455 // Verify that we do not perform any actions after we are no longer
1456 // swap throttled. 1456 // swap throttled.
1457 client_->Reset(); 1457 client_->Reset();
1458 if (swap_ack_before_deadline) { 1458 if (swap_ack_before_deadline) {
1459 // It shouldn't matter if the swap ack comes back before the deadline... 1459 // It shouldn't matter if the swap ack comes back before the deadline...
1460 scheduler_->DidSwapBuffersComplete(); 1460 scheduler_->DidSwapBuffersComplete();
1461 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1461 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1462 } else { 1462 } else {
1463 // ... or after the deadline. 1463 // ... or after the deadline.
1464 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1464 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1465 scheduler_->DidSwapBuffersComplete(); 1465 scheduler_->DidSwapBuffersComplete();
1466 } 1466 }
1467 EXPECT_NO_ACTION(client_); 1467 EXPECT_NO_ACTION(client_);
1468 1468
1469 // Verify that we start the next BeginImplFrame and continue normally 1469 // Verify that we start the next BeginImplFrame and continue normally
1470 // after having just skipped a BeginImplFrame. 1470 // after having just skipped a BeginImplFrame.
1471 client_->Reset(); 1471 client_->Reset();
1472 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1472 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1473 SendNextBeginFrame(); 1473 SendNextBeginFrame();
1474 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3); 1474 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
1475 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 3); 1475 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 3);
1476 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3); 1476 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
1477 1477
1478 client_->Reset(); 1478 client_->Reset();
1479 scheduler_->NotifyBeginMainFrameStarted(); 1479 scheduler_->NotifyBeginMainFrameStarted();
1480 scheduler_->NotifyReadyToCommit(); 1480 scheduler_->NotifyReadyToCommit();
1481 scheduler_->NotifyReadyToActivate(); 1481 scheduler_->NotifyReadyToActivate();
1482 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1482 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
1546 // still expect to recover impl thread latency if there are no commits from 1546 // still expect to recover impl thread latency if there are no commits from
1547 // the main thread. 1547 // the main thread.
1548 auto slow_duration = base::TimeDelta::FromSeconds(1); 1548 auto slow_duration = base::TimeDelta::FromSeconds(1);
1549 fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration); 1549 fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
1550 auto fast_duration = base::TimeDelta::FromMilliseconds(1); 1550 auto fast_duration = base::TimeDelta::FromMilliseconds(1);
1551 fake_compositor_timing_history_->SetDrawDurationEstimate(fast_duration); 1551 fake_compositor_timing_history_->SetDrawDurationEstimate(fast_duration);
1552 1552
1553 // Draw and swap for first BeginFrame 1553 // Draw and swap for first BeginFrame
1554 client_->Reset(); 1554 client_->Reset();
1555 scheduler_->SetNeedsRedraw(); 1555 scheduler_->SetNeedsRedraw();
1556 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1556 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1557 SendNextBeginFrame(); 1557 SendNextBeginFrame();
1558 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3); 1558 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3);
1559 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3); 1559 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
1560 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 3); 1560 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 3);
1561 1561
1562 client_->Reset(); 1562 client_->Reset();
1563 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1563 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1564 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1564 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1565 EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_); 1565 EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
1566 1566
1567 // Verify we skip every other frame if the swap ack consistently 1567 // Verify we skip every other frame if the swap ack consistently
1568 // comes back late. 1568 // comes back late.
1569 for (int i = 0; i < 10; i++) { 1569 for (int i = 0; i < 10; i++) {
1570 // Not calling scheduler_->DidSwapBuffersComplete() until after next 1570 // Not calling scheduler_->DidSwapBuffersComplete() until after next
1571 // BeginImplFrame puts the impl thread in high latency mode. 1571 // BeginImplFrame puts the impl thread in high latency mode.
1572 client_->Reset(); 1572 client_->Reset();
1573 scheduler_->SetNeedsRedraw(); 1573 scheduler_->SetNeedsRedraw();
1574 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1574 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1575 SendNextBeginFrame(); 1575 SendNextBeginFrame();
1576 // Verify that we skip the BeginImplFrame 1576 // Verify that we skip the BeginImplFrame
1577 EXPECT_NO_ACTION(client_); 1577 EXPECT_NO_ACTION(client_);
1578 EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending()); 1578 EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
1579 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1579 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1580 1580
1581 // Verify that we do not perform any actions after we are no longer 1581 // Verify that we do not perform any actions after we are no longer
1582 // swap throttled. 1582 // swap throttled.
1583 client_->Reset(); 1583 client_->Reset();
1584 scheduler_->DidSwapBuffersComplete(); 1584 scheduler_->DidSwapBuffersComplete();
1585 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1585 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1586 EXPECT_NO_ACTION(client_); 1586 EXPECT_NO_ACTION(client_);
1587 1587
1588 // Verify that we start the next BeginImplFrame and continue normally 1588 // Verify that we start the next BeginImplFrame and continue normally
1589 // after having just skipped a BeginImplFrame. 1589 // after having just skipped a BeginImplFrame.
1590 client_->Reset(); 1590 client_->Reset();
1591 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1591 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1592 SendNextBeginFrame(); 1592 SendNextBeginFrame();
1593 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2); 1593 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
1594 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2); 1594 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
1595 1595
1596 client_->Reset(); 1596 client_->Reset();
1597 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1597 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1598 EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_); 1598 EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
1599 } 1599 }
1600 } 1600 }
1601 1601
1602 void SchedulerTest::ImplFrameIsNotSkippedAfterLateSwapAck() { 1602 void SchedulerTest::ImplFrameIsNotSkippedAfterLateSwapAck() {
1603 // To get into a high latency state, this test disables automatic swap acks. 1603 // To get into a high latency state, this test disables automatic swap acks.
1604 scheduler_->SetMaxSwapsPending(1); 1604 scheduler_->SetMaxSwapsPending(1);
1605 client_->SetAutomaticSwapAck(false); 1605 client_->SetAutomaticSwapAck(false);
1606 1606
1607 // Draw and swap for first BeginFrame 1607 // Draw and swap for first BeginFrame
1608 client_->Reset(); 1608 client_->Reset();
1609 scheduler_->SetNeedsCommit(); 1609 scheduler_->SetNeedsCommit();
1610 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1610 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1611 SendNextBeginFrame(); 1611 SendNextBeginFrame();
1612 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3); 1612 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3);
1613 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3); 1613 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
1614 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3); 1614 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
1615 1615
1616 client_->Reset(); 1616 client_->Reset();
1617 scheduler_->NotifyBeginMainFrameStarted(); 1617 scheduler_->NotifyBeginMainFrameStarted();
1618 scheduler_->NotifyReadyToCommit(); 1618 scheduler_->NotifyReadyToCommit();
1619 scheduler_->NotifyReadyToActivate(); 1619 scheduler_->NotifyReadyToActivate();
1620 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1620 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1621 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1621 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1622 EXPECT_ACTION("ScheduledActionCommit", client_, 0, 4); 1622 EXPECT_ACTION("ScheduledActionCommit", client_, 0, 4);
1623 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4); 1623 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4);
1624 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4); 1624 EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
1625 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4); 1625 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
1626 1626
1627 // Verify impl thread consistently operates in high latency mode 1627 // Verify impl thread consistently operates in high latency mode
1628 // without skipping any frames. 1628 // without skipping any frames.
1629 for (int i = 0; i < 10; i++) { 1629 for (int i = 0; i < 10; i++) {
1630 // Not calling scheduler_->DidSwapBuffersComplete() until after next frame 1630 // Not calling scheduler_->DidSwapBuffersComplete() until after next frame
1631 // puts the impl thread in high latency mode. 1631 // puts the impl thread in high latency mode.
1632 client_->Reset(); 1632 client_->Reset();
1633 scheduler_->SetNeedsCommit(); 1633 scheduler_->SetNeedsCommit();
1634 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1634 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1635 SendNextBeginFrame(); 1635 SendNextBeginFrame();
1636 EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_); 1636 EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
1637 EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending()); 1637 EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
1638 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1638 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1639 1639
1640 client_->Reset(); 1640 client_->Reset();
1641 scheduler_->DidSwapBuffersComplete(); 1641 scheduler_->DidSwapBuffersComplete();
1642 scheduler_->NotifyBeginMainFrameStarted(); 1642 scheduler_->NotifyBeginMainFrameStarted();
1643 scheduler_->NotifyReadyToCommit(); 1643 scheduler_->NotifyReadyToCommit();
1644 scheduler_->NotifyReadyToActivate(); 1644 scheduler_->NotifyReadyToActivate();
1645 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1645 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1646 1646
1647 // Verify that we don't skip the actions of the BeginImplFrame 1647 // Verify that we don't skip the actions of the BeginImplFrame
1648 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 0, 5); 1648 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 0, 5);
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
1709 SetUpScheduler(true); 1709 SetUpScheduler(true);
1710 1710
1711 auto slow_duration = base::TimeDelta::FromSeconds(1); 1711 auto slow_duration = base::TimeDelta::FromSeconds(1);
1712 fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration); 1712 fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
1713 1713
1714 // To get into a high latency state, this test disables automatic swap acks. 1714 // To get into a high latency state, this test disables automatic swap acks.
1715 scheduler_->SetMaxSwapsPending(1); 1715 scheduler_->SetMaxSwapsPending(1);
1716 client_->SetAutomaticSwapAck(false); 1716 client_->SetAutomaticSwapAck(false);
1717 1717
1718 // Impl thread hits deadline before commit finishes to make 1718 // Impl thread hits deadline before commit finishes to make
1719 // MainThreadIsInHighLatencyMode true 1719 // MainThreadMissedLastDeadline true
1720 client_->Reset(); 1720 client_->Reset();
1721 scheduler_->SetNeedsCommit(); 1721 scheduler_->SetNeedsCommit();
1722 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1722 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1723 EXPECT_SCOPED(AdvanceFrame()); 1723 EXPECT_SCOPED(AdvanceFrame());
1724 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1724 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1725 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1725 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1726 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1726 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1727 scheduler_->NotifyBeginMainFrameStarted(); 1727 scheduler_->NotifyBeginMainFrameStarted();
1728 scheduler_->NotifyReadyToCommit(); 1728 scheduler_->NotifyReadyToCommit();
1729 scheduler_->NotifyReadyToActivate(); 1729 scheduler_->NotifyReadyToActivate();
1730 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1730 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1731 1731
1732 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 5); 1732 EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 5);
1733 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5); 1733 EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5);
1734 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5); 1734 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5);
1735 EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5); 1735 EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5);
1736 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5); 1736 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5);
1737 1737
1738 // Draw and swap for first commit, start second commit. 1738 // Draw and swap for first commit, start second commit.
1739 client_->Reset(); 1739 client_->Reset();
1740 scheduler_->SetNeedsCommit(); 1740 scheduler_->SetNeedsCommit();
1741 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1741 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1742 EXPECT_SCOPED(AdvanceFrame()); 1742 EXPECT_SCOPED(AdvanceFrame());
1743 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1743 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1744 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1744 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1745 scheduler_->NotifyBeginMainFrameStarted(); 1745 scheduler_->NotifyBeginMainFrameStarted();
1746 scheduler_->NotifyReadyToCommit(); 1746 scheduler_->NotifyReadyToCommit();
1747 scheduler_->NotifyReadyToActivate(); 1747 scheduler_->NotifyReadyToActivate();
1748 1748
1749 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 6); 1749 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 6);
1750 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 6); 1750 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 6);
1751 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 6); 1751 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 6);
1752 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 6); 1752 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 6);
1753 EXPECT_ACTION("ScheduledActionCommit", client_, 4, 6); 1753 EXPECT_ACTION("ScheduledActionCommit", client_, 4, 6);
1754 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 5, 6); 1754 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 5, 6);
1755 1755
1756 // Don't call scheduler_->DidSwapBuffersComplete() until after next frame 1756 // Don't call scheduler_->DidSwapBuffersComplete() until after next frame
1757 // to put the impl thread in a high latency mode. 1757 // to put the impl thread in a high latency mode.
1758 client_->Reset(); 1758 client_->Reset();
1759 scheduler_->SetNeedsCommit(); 1759 scheduler_->SetNeedsCommit();
1760 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1760 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1761 EXPECT_SCOPED(AdvanceFrame()); 1761 EXPECT_SCOPED(AdvanceFrame());
1762 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1762 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1763 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1763 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1764 1764
1765 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2); 1765 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
1766 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2); 1766 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
1767 // Note: BeginMainFrame and swap are skipped here because of 1767 // Note: BeginMainFrame and swap are skipped here because of
1768 // swap ack backpressure, not because of latency recovery. 1768 // swap ack backpressure, not because of latency recovery.
1769 EXPECT_FALSE(client_->HasAction("ScheduledActionSendBeginMainFrame")); 1769 EXPECT_FALSE(client_->HasAction("ScheduledActionSendBeginMainFrame"));
1770 EXPECT_FALSE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible")); 1770 EXPECT_FALSE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
1771 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1771 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1772 EXPECT_TRUE(scheduler_->WasSwapThrottledAtLastBeginFrame()); 1772 EXPECT_TRUE(scheduler_->WasSwapThrottledAtLastBeginFrame());
1773 1773
1774 // Lower estimates so that the scheduler will attempt latency recovery. 1774 // Lower estimates so that the scheduler will attempt latency recovery.
1775 auto fast_duration = base::TimeDelta::FromMilliseconds(1); 1775 auto fast_duration = base::TimeDelta::FromMilliseconds(1);
1776 fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration); 1776 fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
1777 1777
1778 // Now that both threads are in a high latency mode, make sure we 1778 // Now that both threads are in a high latency mode, make sure we
1779 // skip the BeginMainFrame, then the BeginImplFrame, but not both 1779 // skip the BeginMainFrame, then the BeginImplFrame, but not both
1780 // at the same time. 1780 // at the same time.
1781 1781
1782 // Verify we skip BeginMainFrame first. 1782 // Verify we skip BeginMainFrame first.
1783 client_->Reset(); 1783 client_->Reset();
1784 // Previous commit request is still outstanding. 1784 // Previous commit request is still outstanding.
1785 EXPECT_TRUE(scheduler_->NeedsCommit()); 1785 EXPECT_TRUE(scheduler_->NeedsCommit());
1786 SendNextBeginFrame(); 1786 SendNextBeginFrame();
1787 EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode()); 1787 EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
1788 EXPECT_TRUE(scheduler_->WasSwapThrottledAtLastBeginFrame()); 1788 EXPECT_TRUE(scheduler_->WasSwapThrottledAtLastBeginFrame());
1789 scheduler_->DidSwapBuffersComplete(); 1789 scheduler_->DidSwapBuffersComplete();
1790 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1790 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1791 1791
1792 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1792 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1793 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3); 1793 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
1794 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 3); 1794 EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 3);
1795 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3); 1795 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
1796 1796
1797 // Verify we skip the BeginImplFrame second. 1797 // Verify we skip the BeginImplFrame second.
1798 client_->Reset(); 1798 client_->Reset();
1799 // Previous commit request is still outstanding. 1799 // Previous commit request is still outstanding.
1800 EXPECT_TRUE(scheduler_->NeedsCommit()); 1800 EXPECT_TRUE(scheduler_->NeedsCommit());
1801 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1801 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1802 SendNextBeginFrame(); 1802 SendNextBeginFrame();
1803 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1803 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1804 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1804 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1805 scheduler_->DidSwapBuffersComplete(); 1805 scheduler_->DidSwapBuffersComplete();
1806 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1806 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1807 1807
1808 EXPECT_NO_ACTION(client_); 1808 EXPECT_NO_ACTION(client_);
1809 1809
1810 // Then verify we operate in a low latency mode. 1810 // Then verify we operate in a low latency mode.
1811 client_->Reset(); 1811 client_->Reset();
1812 // Previous commit request is still outstanding. 1812 // Previous commit request is still outstanding.
1813 EXPECT_TRUE(scheduler_->NeedsCommit()); 1813 EXPECT_TRUE(scheduler_->NeedsCommit());
1814 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1814 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1815 SendNextBeginFrame(); 1815 SendNextBeginFrame();
1816 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1816 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1817 scheduler_->NotifyBeginMainFrameStarted(); 1817 scheduler_->NotifyBeginMainFrameStarted();
1818 scheduler_->NotifyReadyToCommit(); 1818 scheduler_->NotifyReadyToCommit();
1819 scheduler_->NotifyReadyToActivate(); 1819 scheduler_->NotifyReadyToActivate();
1820 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)); 1820 task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
1821 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1821 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1822 scheduler_->DidSwapBuffersComplete(); 1822 scheduler_->DidSwapBuffersComplete();
1823 EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode()); 1823 EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
1824 1824
1825 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 6); 1825 EXPECT_ACTION("WillBeginImplFrame", client_, 0, 6);
1826 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 6); 1826 EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 6);
1827 EXPECT_ACTION("ScheduledActionCommit", client_, 2, 6); 1827 EXPECT_ACTION("ScheduledActionCommit", client_, 2, 6);
1828 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 3, 6); 1828 EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 3, 6);
1829 EXPECT_ACTION("ScheduledActionAnimate", client_, 4, 6); 1829 EXPECT_ACTION("ScheduledActionAnimate", client_, 4, 6);
1830 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 5, 6); 1830 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 5, 6);
1831 } 1831 }
1832 1832
1833 TEST_F( 1833 TEST_F(
(...skipping 1568 matching lines...) Expand 10 before | Expand all | Expand 10 after
3402 scheduler_->SetImplLatencyTakesPriority(true); 3402 scheduler_->SetImplLatencyTakesPriority(true);
3403 scheduler_->SetChildrenNeedBeginFrames(true); 3403 scheduler_->SetChildrenNeedBeginFrames(true);
3404 3404
3405 EXPECT_SCOPED(AdvanceFrame()); 3405 EXPECT_SCOPED(AdvanceFrame());
3406 EXPECT_TRUE(client_->begin_frame_is_sent_to_children()); 3406 EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
3407 EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path); 3407 EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path);
3408 } 3408 }
3409 3409
3410 } // namespace 3410 } // namespace
3411 } // namespace cc 3411 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698