OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "platform/scheduler/renderer/renderer_scheduler_impl.h" | 5 #include "platform/scheduler/renderer/renderer_scheduler_impl.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 550 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
561 } | 561 } |
562 | 562 |
563 void GetQueueingTimeEstimatorLock() { | 563 void GetQueueingTimeEstimatorLock() { |
564 scheduler_->seqlock_queueing_time_estimator_.seqlock.WriteBegin(); | 564 scheduler_->seqlock_queueing_time_estimator_.seqlock.WriteBegin(); |
565 } | 565 } |
566 | 566 |
567 void DropQueueingTimeEstimatorLock() { | 567 void DropQueueingTimeEstimatorLock() { |
568 scheduler_->seqlock_queueing_time_estimator_.seqlock.WriteEnd(); | 568 scheduler_->seqlock_queueing_time_estimator_.seqlock.WriteEnd(); |
569 } | 569 } |
570 | 570 |
| 571 void RunSlowCompositorTask() { |
| 572 // Run a long compositor task so that compositor tasks appear to be running |
| 573 // slow and thus compositor tasks will not be prioritized. |
| 574 compositor_task_runner_->PostTask( |
| 575 FROM_HERE, |
| 576 base::Bind(&RendererSchedulerImplTest::SimulateMainThreadCompositorTask, |
| 577 base::Unretained(this), |
| 578 base::TimeDelta::FromMilliseconds(1000))); |
| 579 RunUntilIdle(); |
| 580 } |
| 581 |
571 // Helper for posting several tasks of specific types. |task_descriptor| is a | 582 // Helper for posting several tasks of specific types. |task_descriptor| is a |
572 // string with space delimited task identifiers. The first letter of each | 583 // string with space delimited task identifiers. The first letter of each |
573 // task identifier specifies the task type: | 584 // task identifier specifies the task type: |
574 // - 'D': Default task | 585 // - 'D': Default task |
575 // - 'C': Compositor task | 586 // - 'C': Compositor task |
576 // - 'L': Loading task | 587 // - 'L': Loading task |
577 // - 'I': Idle task | 588 // - 'I': Idle task |
578 // - 'T': Timer task | 589 // - 'T': Timer task |
579 void PostTestTasks(std::vector<std::string>* run_order, | 590 void PostTestTasks(std::vector<std::string>* run_order, |
580 const std::string& task_descriptor) { | 591 const std::string& task_descriptor) { |
(...skipping 248 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
829 EXPECT_EQ(1, run_count); // We should still be in the new idle period. | 840 EXPECT_EQ(1, run_count); // We should still be in the new idle period. |
830 } | 841 } |
831 | 842 |
832 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) { | 843 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) { |
833 std::vector<std::string> run_order; | 844 std::vector<std::string> run_order; |
834 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); | 845 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); |
835 | 846 |
836 EnableIdleTasks(); | 847 EnableIdleTasks(); |
837 RunUntilIdle(); | 848 RunUntilIdle(); |
838 EXPECT_THAT(run_order, | 849 EXPECT_THAT(run_order, |
| 850 testing::ElementsAre(std::string("C1"), std::string("C2"), |
| 851 std::string("L1"), std::string("D1"), |
| 852 std::string("D2"), std::string("I1"))); |
| 853 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
| 854 } |
| 855 |
| 856 TEST_F(RendererSchedulerImplTest, TestDefaultPolicyWithSlowCompositor) { |
| 857 RunSlowCompositorTask(); |
| 858 |
| 859 std::vector<std::string> run_order; |
| 860 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); |
| 861 |
| 862 EnableIdleTasks(); |
| 863 RunUntilIdle(); |
| 864 EXPECT_THAT(run_order, |
839 testing::ElementsAre(std::string("L1"), std::string("D1"), | 865 testing::ElementsAre(std::string("L1"), std::string("D1"), |
840 std::string("C1"), std::string("D2"), | 866 std::string("C1"), std::string("D2"), |
841 std::string("C2"), std::string("I1"))); | 867 std::string("C2"), std::string("I1"))); |
842 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 868 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
843 } | 869 } |
844 | 870 |
845 TEST_F(RendererSchedulerImplTest, | 871 TEST_F(RendererSchedulerImplTest, |
846 TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler) { | 872 TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler) { |
847 std::vector<std::string> run_order; | 873 std::vector<std::string> run_order; |
848 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); | 874 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); |
(...skipping 401 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1250 std::string default_order_expected[] = { | 1276 std::string default_order_expected[] = { |
1251 std::string("D1"), std::string("C1"), std::string("T1"), | 1277 std::string("D1"), std::string("C1"), std::string("T1"), |
1252 std::string("L1"), std::string("D2"), std::string("C2"), | 1278 std::string("L1"), std::string("D2"), std::string("C2"), |
1253 std::string("T2"), std::string("L2"), std::string("I1")}; | 1279 std::string("T2"), std::string("L2"), std::string("I1")}; |
1254 EXPECT_THAT(run_order, testing::ElementsAreArray(default_order_expected)); | 1280 EXPECT_THAT(run_order, testing::ElementsAreArray(default_order_expected)); |
1255 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1281 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1256 } | 1282 } |
1257 | 1283 |
1258 TEST_F(RendererSchedulerImplTest, | 1284 TEST_F(RendererSchedulerImplTest, |
1259 EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) { | 1285 EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) { |
| 1286 RunSlowCompositorTask(); |
| 1287 |
1260 std::vector<std::string> run_order; | 1288 std::vector<std::string> run_order; |
1261 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1289 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1262 | 1290 |
1263 EnableIdleTasks(); | 1291 EnableIdleTasks(); |
1264 scheduler_->DidHandleInputEventOnCompositorThread( | 1292 scheduler_->DidHandleInputEventOnCompositorThread( |
1265 FakeInputEvent(blink::WebInputEvent::kMouseMove), | 1293 FakeInputEvent(blink::WebInputEvent::kMouseMove), |
1266 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); | 1294 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); |
1267 RunUntilIdle(); | 1295 RunUntilIdle(); |
1268 // Note compositor tasks are not prioritized. | 1296 // Note compositor tasks are not prioritized. |
1269 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1297 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1270 EXPECT_THAT(run_order, | 1298 EXPECT_THAT(run_order, |
1271 testing::ElementsAre(std::string("D1"), std::string("C1"), | 1299 testing::ElementsAre(std::string("D1"), std::string("C1"), |
1272 std::string("D2"), std::string("C2"), | 1300 std::string("D2"), std::string("C2"), |
1273 std::string("I1"))); | 1301 std::string("I1"))); |
1274 } | 1302 } |
1275 | 1303 |
1276 TEST_F(RendererSchedulerImplTest, | 1304 TEST_F(RendererSchedulerImplTest, |
1277 EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) { | 1305 EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) { |
| 1306 RunSlowCompositorTask(); |
| 1307 |
1278 std::vector<std::string> run_order; | 1308 std::vector<std::string> run_order; |
1279 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1309 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1280 | 1310 |
1281 EnableIdleTasks(); | 1311 EnableIdleTasks(); |
1282 scheduler_->DidHandleInputEventOnCompositorThread( | 1312 scheduler_->DidHandleInputEventOnCompositorThread( |
1283 FakeInputEvent(blink::WebInputEvent::kMouseMove), | 1313 FakeInputEvent(blink::WebInputEvent::kMouseMove), |
1284 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); | 1314 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); |
1285 RunUntilIdle(); | 1315 RunUntilIdle(); |
1286 // Note compositor tasks are not prioritized. | 1316 // Note compositor tasks are not prioritized. |
1287 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1317 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1488 EXPECT_THAT(run_order, | 1518 EXPECT_THAT(run_order, |
1489 testing::ElementsAre(std::string("D1"), std::string("D2"), | 1519 testing::ElementsAre(std::string("D1"), std::string("D2"), |
1490 std::string("I1"), std::string("C1"), | 1520 std::string("I1"), std::string("C1"), |
1491 std::string("C2"))); | 1521 std::string("C2"))); |
1492 EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE, | 1522 EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE, |
1493 CurrentUseCase()); | 1523 CurrentUseCase()); |
1494 } | 1524 } |
1495 | 1525 |
1496 TEST_F(RendererSchedulerImplTest, | 1526 TEST_F(RendererSchedulerImplTest, |
1497 EventConsumedOnCompositorThread_IgnoresKeyboardEvents) { | 1527 EventConsumedOnCompositorThread_IgnoresKeyboardEvents) { |
| 1528 RunSlowCompositorTask(); |
| 1529 |
1498 std::vector<std::string> run_order; | 1530 std::vector<std::string> run_order; |
1499 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1531 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1500 | 1532 |
1501 EnableIdleTasks(); | 1533 EnableIdleTasks(); |
1502 scheduler_->DidHandleInputEventOnCompositorThread( | 1534 scheduler_->DidHandleInputEventOnCompositorThread( |
1503 FakeInputEvent(blink::WebInputEvent::kKeyDown), | 1535 FakeInputEvent(blink::WebInputEvent::kKeyDown), |
1504 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); | 1536 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); |
1505 RunUntilIdle(); | 1537 RunUntilIdle(); |
1506 // Note compositor tasks are not prioritized. | 1538 // Note compositor tasks are not prioritized. |
1507 EXPECT_THAT(run_order, | 1539 EXPECT_THAT(run_order, |
1508 testing::ElementsAre(std::string("D1"), std::string("C1"), | 1540 testing::ElementsAre(std::string("D1"), std::string("C1"), |
1509 std::string("D2"), std::string("C2"), | 1541 std::string("D2"), std::string("C2"), |
1510 std::string("I1"))); | 1542 std::string("I1"))); |
1511 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1543 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1512 } | 1544 } |
1513 | 1545 |
1514 TEST_F(RendererSchedulerImplTest, | 1546 TEST_F(RendererSchedulerImplTest, |
1515 EventForwardedToMainThread_IgnoresKeyboardEvents) { | 1547 EventForwardedToMainThread_IgnoresKeyboardEvents) { |
| 1548 RunSlowCompositorTask(); |
| 1549 |
1516 std::vector<std::string> run_order; | 1550 std::vector<std::string> run_order; |
1517 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1551 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1518 | 1552 |
1519 EnableIdleTasks(); | 1553 EnableIdleTasks(); |
1520 scheduler_->DidHandleInputEventOnCompositorThread( | 1554 scheduler_->DidHandleInputEventOnCompositorThread( |
1521 FakeInputEvent(blink::WebInputEvent::kKeyDown), | 1555 FakeInputEvent(blink::WebInputEvent::kKeyDown), |
1522 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); | 1556 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); |
1523 RunUntilIdle(); | 1557 RunUntilIdle(); |
1524 // Note compositor tasks are not prioritized. | 1558 // Note compositor tasks are not prioritized. |
1525 EXPECT_THAT(run_order, | 1559 EXPECT_THAT(run_order, |
(...skipping 849 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2375 // Assume that the renderer is backgrounded. | 2409 // Assume that the renderer is backgrounded. |
2376 scheduler_->OnRendererBackgrounded(); | 2410 scheduler_->OnRendererBackgrounded(); |
2377 | 2411 |
2378 // Tasks in some queues don't fire when the renderer is suspended. | 2412 // Tasks in some queues don't fire when the renderer is suspended. |
2379 std::vector<std::string> run_order; | 2413 std::vector<std::string> run_order; |
2380 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); | 2414 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); |
2381 scheduler_->SuspendRenderer(); | 2415 scheduler_->SuspendRenderer(); |
2382 EnableIdleTasks(); | 2416 EnableIdleTasks(); |
2383 RunUntilIdle(); | 2417 RunUntilIdle(); |
2384 EXPECT_THAT(run_order, | 2418 EXPECT_THAT(run_order, |
2385 testing::ElementsAre(std::string("D1"), std::string("C1"), | 2419 testing::ElementsAre(std::string("C1"), std::string("D1"), |
2386 std::string("I1"))); | 2420 std::string("I1"))); |
2387 | 2421 |
2388 // The rest queued tasks fire when the tab goes foregrounded. | 2422 // The rest queued tasks fire when the tab goes foregrounded. |
2389 run_order.clear(); | 2423 run_order.clear(); |
2390 scheduler_->OnRendererForegrounded(); | 2424 scheduler_->OnRendererForegrounded(); |
2391 RunUntilIdle(); | 2425 RunUntilIdle(); |
2392 EXPECT_THAT(run_order, | 2426 EXPECT_THAT(run_order, |
2393 testing::ElementsAre(std::string("L1"), std::string("T1"))); | 2427 testing::ElementsAre(std::string("L1"), std::string("T1"))); |
2394 | 2428 |
2395 run_order.clear(); | 2429 run_order.clear(); |
(...skipping 11 matching lines...) Expand all Loading... |
2407 // Assume that the renderer is backgrounded. | 2441 // Assume that the renderer is backgrounded. |
2408 scheduler_->OnRendererBackgrounded(); | 2442 scheduler_->OnRendererBackgrounded(); |
2409 | 2443 |
2410 // Tasks in some queues don't fire when the renderer is suspended. | 2444 // Tasks in some queues don't fire when the renderer is suspended. |
2411 std::vector<std::string> run_order; | 2445 std::vector<std::string> run_order; |
2412 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); | 2446 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); |
2413 scheduler_->SuspendRenderer(); | 2447 scheduler_->SuspendRenderer(); |
2414 EnableIdleTasks(); | 2448 EnableIdleTasks(); |
2415 RunUntilIdle(); | 2449 RunUntilIdle(); |
2416 EXPECT_THAT(run_order, | 2450 EXPECT_THAT(run_order, |
2417 testing::ElementsAre(std::string("D1"), std::string("C1"), | 2451 testing::ElementsAre(std::string("C1"), std::string("D1"), |
2418 std::string("I1"))); | 2452 std::string("I1"))); |
2419 | 2453 |
2420 // The rest queued tasks fire when the renderer is resumed. | 2454 // The rest queued tasks fire when the renderer is resumed. |
2421 run_order.clear(); | 2455 run_order.clear(); |
2422 scheduler_->ResumeRenderer(); | 2456 scheduler_->ResumeRenderer(); |
2423 RunUntilIdle(); | 2457 RunUntilIdle(); |
2424 EXPECT_THAT(run_order, | 2458 EXPECT_THAT(run_order, |
2425 testing::ElementsAre(std::string("L1"), std::string("T1"))); | 2459 testing::ElementsAre(std::string("L1"), std::string("T1"))); |
2426 | 2460 |
2427 run_order.clear(); | 2461 run_order.clear(); |
2428 // No crash occurs when the renderer is suspended again, and | 2462 // No crash occurs when the renderer is suspended again, and |
2429 // tasks in some queues don't fire because of suspended. | 2463 // tasks in some queues don't fire because of suspended. |
2430 PostTestTasks(&run_order, "D2 C2 L2 I2 T2"); | 2464 PostTestTasks(&run_order, "D2 C2 L2 I2 T2"); |
2431 scheduler_->SuspendRenderer(); | 2465 scheduler_->SuspendRenderer(); |
2432 EnableIdleTasks(); | 2466 EnableIdleTasks(); |
2433 RunUntilIdle(); | 2467 RunUntilIdle(); |
2434 EXPECT_THAT(run_order, | 2468 EXPECT_THAT(run_order, |
2435 testing::ElementsAre(std::string("D2"), std::string("C2"), | 2469 testing::ElementsAre(std::string("C2"), std::string("D2"), |
2436 std::string("I2"))); | 2470 std::string("I2"))); |
2437 | 2471 |
2438 // The rest queued tasks fire when the renderer is resumed. | 2472 // The rest queued tasks fire when the renderer is resumed. |
2439 run_order.clear(); | 2473 run_order.clear(); |
2440 scheduler_->ResumeRenderer(); | 2474 scheduler_->ResumeRenderer(); |
2441 RunUntilIdle(); | 2475 RunUntilIdle(); |
2442 EXPECT_THAT(run_order, | 2476 EXPECT_THAT(run_order, |
2443 testing::ElementsAre(std::string("L2"), std::string("T2"))); | 2477 testing::ElementsAre(std::string("L2"), std::string("T2"))); |
2444 | 2478 |
2445 run_order.clear(); | 2479 run_order.clear(); |
(...skipping 1434 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3880 EXPECT_TRUE( | 3914 EXPECT_TRUE( |
3881 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); | 3915 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); |
3882 // Once we've dropped the lock, we realize the main thread is responsive. | 3916 // Once we've dropped the lock, we realize the main thread is responsive. |
3883 DropQueueingTimeEstimatorLock(); | 3917 DropQueueingTimeEstimatorLock(); |
3884 EXPECT_FALSE( | 3918 EXPECT_FALSE( |
3885 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); | 3919 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); |
3886 } | 3920 } |
3887 | 3921 |
3888 } // namespace scheduler | 3922 } // namespace scheduler |
3889 } // namespace blink | 3923 } // namespace blink |
OLD | NEW |