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 817 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
828 EXPECT_EQ(1, run_count); // We should still be in the new idle period. | 828 EXPECT_EQ(1, run_count); // We should still be in the new idle period. |
829 } | 829 } |
830 | 830 |
831 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) { | 831 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) { |
832 std::vector<std::string> run_order; | 832 std::vector<std::string> run_order; |
833 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); | 833 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); |
834 | 834 |
835 EnableIdleTasks(); | 835 EnableIdleTasks(); |
836 RunUntilIdle(); | 836 RunUntilIdle(); |
837 EXPECT_THAT(run_order, | 837 EXPECT_THAT(run_order, |
838 testing::ElementsAre(std::string("L1"), std::string("D1"), | 838 testing::ElementsAre(std::string("C1"), std::string("C2"), |
839 std::string("C1"), std::string("D2"), | 839 std::string("L1"), std::string("D1"), |
840 std::string("C2"), std::string("I1"))); | 840 std::string("D2"), std::string("I1"))); |
841 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 841 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
842 } | 842 } |
843 | 843 |
844 TEST_F(RendererSchedulerImplTest, | 844 TEST_F(RendererSchedulerImplTest, |
845 TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler) { | 845 TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler) { |
846 std::vector<std::string> run_order; | 846 std::vector<std::string> run_order; |
847 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); | 847 PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2"); |
848 | 848 |
849 scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true); | 849 scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true); |
850 EnableIdleTasks(); | 850 EnableIdleTasks(); |
(...skipping 406 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1257 TEST_F(RendererSchedulerImplTest, | 1257 TEST_F(RendererSchedulerImplTest, |
1258 EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) { | 1258 EventConsumedOnCompositorThread_IgnoresMouseMove_WhenMouseUp) { |
1259 std::vector<std::string> run_order; | 1259 std::vector<std::string> run_order; |
1260 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1260 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1261 | 1261 |
1262 EnableIdleTasks(); | 1262 EnableIdleTasks(); |
1263 scheduler_->DidHandleInputEventOnCompositorThread( | 1263 scheduler_->DidHandleInputEventOnCompositorThread( |
1264 FakeInputEvent(blink::WebInputEvent::kMouseMove), | 1264 FakeInputEvent(blink::WebInputEvent::kMouseMove), |
1265 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); | 1265 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); |
1266 RunUntilIdle(); | 1266 RunUntilIdle(); |
1267 // Note compositor tasks are not prioritized. | 1267 // Note compositor tasks are not prioritized. |
Sami
2017/05/04 00:33:38
This test is a little useless now, so let's change
Dan Elphick
2017/05/04 16:47:15
Added a new RunSlowCompositorTask method to Render
| |
1268 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1268 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1269 EXPECT_THAT(run_order, | 1269 EXPECT_THAT(run_order, |
1270 testing::ElementsAre(std::string("D1"), std::string("C1"), | 1270 testing::ElementsAre(std::string("C1"), std::string("C2"), |
1271 std::string("D2"), std::string("C2"), | 1271 std::string("D1"), std::string("D2"), |
1272 std::string("I1"))); | 1272 std::string("I1"))); |
1273 } | 1273 } |
1274 | 1274 |
1275 TEST_F(RendererSchedulerImplTest, | 1275 TEST_F(RendererSchedulerImplTest, |
1276 EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) { | 1276 EventForwardedToMainThread_IgnoresMouseMove_WhenMouseUp) { |
1277 std::vector<std::string> run_order; | 1277 std::vector<std::string> run_order; |
1278 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1278 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1279 | 1279 |
1280 EnableIdleTasks(); | 1280 EnableIdleTasks(); |
1281 scheduler_->DidHandleInputEventOnCompositorThread( | 1281 scheduler_->DidHandleInputEventOnCompositorThread( |
1282 FakeInputEvent(blink::WebInputEvent::kMouseMove), | 1282 FakeInputEvent(blink::WebInputEvent::kMouseMove), |
1283 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); | 1283 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); |
1284 RunUntilIdle(); | 1284 RunUntilIdle(); |
1285 // Note compositor tasks are not prioritized. | 1285 // Note compositor tasks are not prioritized. |
1286 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1286 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1287 EXPECT_THAT(run_order, | 1287 EXPECT_THAT(run_order, |
1288 testing::ElementsAre(std::string("D1"), std::string("C1"), | 1288 testing::ElementsAre(std::string("C1"), std::string("C2"), |
1289 std::string("D2"), std::string("C2"), | 1289 std::string("D1"), std::string("D2"), |
1290 std::string("I1"))); | 1290 std::string("I1"))); |
1291 } | 1291 } |
1292 | 1292 |
1293 TEST_F(RendererSchedulerImplTest, | 1293 TEST_F(RendererSchedulerImplTest, |
1294 EventConsumedOnCompositorThread_MouseMove_WhenMouseDown) { | 1294 EventConsumedOnCompositorThread_MouseMove_WhenMouseDown) { |
1295 std::vector<std::string> run_order; | 1295 std::vector<std::string> run_order; |
1296 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1296 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1297 | 1297 |
1298 // Note that currently the compositor will never consume mouse move events, | 1298 // Note that currently the compositor will never consume mouse move events, |
1299 // but this test reflects what should happen if that was the case. | 1299 // but this test reflects what should happen if that was the case. |
(...skipping 197 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1497 std::vector<std::string> run_order; | 1497 std::vector<std::string> run_order; |
1498 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1498 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1499 | 1499 |
1500 EnableIdleTasks(); | 1500 EnableIdleTasks(); |
1501 scheduler_->DidHandleInputEventOnCompositorThread( | 1501 scheduler_->DidHandleInputEventOnCompositorThread( |
1502 FakeInputEvent(blink::WebInputEvent::kKeyDown), | 1502 FakeInputEvent(blink::WebInputEvent::kKeyDown), |
1503 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); | 1503 RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR); |
1504 RunUntilIdle(); | 1504 RunUntilIdle(); |
1505 // Note compositor tasks are not prioritized. | 1505 // Note compositor tasks are not prioritized. |
1506 EXPECT_THAT(run_order, | 1506 EXPECT_THAT(run_order, |
1507 testing::ElementsAre(std::string("D1"), std::string("C1"), | 1507 testing::ElementsAre(std::string("C1"), std::string("C2"), |
1508 std::string("D2"), std::string("C2"), | 1508 std::string("D1"), std::string("D2"), |
1509 std::string("I1"))); | 1509 std::string("I1"))); |
1510 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1510 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1511 } | 1511 } |
1512 | 1512 |
1513 TEST_F(RendererSchedulerImplTest, | 1513 TEST_F(RendererSchedulerImplTest, |
1514 EventForwardedToMainThread_IgnoresKeyboardEvents) { | 1514 EventForwardedToMainThread_IgnoresKeyboardEvents) { |
1515 std::vector<std::string> run_order; | 1515 std::vector<std::string> run_order; |
1516 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); | 1516 PostTestTasks(&run_order, "I1 D1 C1 D2 C2"); |
1517 | 1517 |
1518 EnableIdleTasks(); | 1518 EnableIdleTasks(); |
1519 scheduler_->DidHandleInputEventOnCompositorThread( | 1519 scheduler_->DidHandleInputEventOnCompositorThread( |
1520 FakeInputEvent(blink::WebInputEvent::kKeyDown), | 1520 FakeInputEvent(blink::WebInputEvent::kKeyDown), |
1521 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); | 1521 RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD); |
1522 RunUntilIdle(); | 1522 RunUntilIdle(); |
1523 // Note compositor tasks are not prioritized. | 1523 // Note compositor tasks are not prioritized. |
1524 EXPECT_THAT(run_order, | 1524 EXPECT_THAT(run_order, |
1525 testing::ElementsAre(std::string("D1"), std::string("C1"), | 1525 testing::ElementsAre(std::string("C1"), std::string("C2"), |
1526 std::string("D2"), std::string("C2"), | 1526 std::string("D1"), std::string("D2"), |
1527 std::string("I1"))); | 1527 std::string("I1"))); |
1528 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); | 1528 EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase()); |
1529 // Note compositor tasks are not prioritized. | 1529 // Note compositor tasks are not prioritized. |
1530 scheduler_->DidHandleInputEventOnMainThread( | 1530 scheduler_->DidHandleInputEventOnMainThread( |
1531 FakeInputEvent(blink::WebInputEvent::kKeyDown), | 1531 FakeInputEvent(blink::WebInputEvent::kKeyDown), |
1532 WebInputEventResult::kHandledSystem); | 1532 WebInputEventResult::kHandledSystem); |
1533 } | 1533 } |
1534 | 1534 |
1535 TEST_F(RendererSchedulerImplTest, | 1535 TEST_F(RendererSchedulerImplTest, |
1536 TestMainthreadScrollingUseCaseDoesNotStarveDefaultTasks) { | 1536 TestMainthreadScrollingUseCaseDoesNotStarveDefaultTasks) { |
(...skipping 815 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2352 // Assume that the renderer is backgrounded. | 2352 // Assume that the renderer is backgrounded. |
2353 scheduler_->OnRendererBackgrounded(); | 2353 scheduler_->OnRendererBackgrounded(); |
2354 | 2354 |
2355 // Tasks in some queues don't fire when the renderer is suspended. | 2355 // Tasks in some queues don't fire when the renderer is suspended. |
2356 std::vector<std::string> run_order; | 2356 std::vector<std::string> run_order; |
2357 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); | 2357 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); |
2358 scheduler_->SuspendRenderer(); | 2358 scheduler_->SuspendRenderer(); |
2359 EnableIdleTasks(); | 2359 EnableIdleTasks(); |
2360 RunUntilIdle(); | 2360 RunUntilIdle(); |
2361 EXPECT_THAT(run_order, | 2361 EXPECT_THAT(run_order, |
2362 testing::ElementsAre(std::string("D1"), std::string("C1"), | 2362 testing::ElementsAre(std::string("C1"), std::string("D1"), |
2363 std::string("I1"))); | 2363 std::string("I1"))); |
2364 | 2364 |
2365 // The rest queued tasks fire when the tab goes foregrounded. | 2365 // The rest queued tasks fire when the tab goes foregrounded. |
2366 run_order.clear(); | 2366 run_order.clear(); |
2367 scheduler_->OnRendererForegrounded(); | 2367 scheduler_->OnRendererForegrounded(); |
2368 RunUntilIdle(); | 2368 RunUntilIdle(); |
2369 EXPECT_THAT(run_order, | 2369 EXPECT_THAT(run_order, |
2370 testing::ElementsAre(std::string("L1"), std::string("T1"))); | 2370 testing::ElementsAre(std::string("L1"), std::string("T1"))); |
2371 | 2371 |
2372 run_order.clear(); | 2372 run_order.clear(); |
(...skipping 11 matching lines...) Expand all Loading... | |
2384 // Assume that the renderer is backgrounded. | 2384 // Assume that the renderer is backgrounded. |
2385 scheduler_->OnRendererBackgrounded(); | 2385 scheduler_->OnRendererBackgrounded(); |
2386 | 2386 |
2387 // Tasks in some queues don't fire when the renderer is suspended. | 2387 // Tasks in some queues don't fire when the renderer is suspended. |
2388 std::vector<std::string> run_order; | 2388 std::vector<std::string> run_order; |
2389 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); | 2389 PostTestTasks(&run_order, "D1 C1 L1 I1 T1"); |
2390 scheduler_->SuspendRenderer(); | 2390 scheduler_->SuspendRenderer(); |
2391 EnableIdleTasks(); | 2391 EnableIdleTasks(); |
2392 RunUntilIdle(); | 2392 RunUntilIdle(); |
2393 EXPECT_THAT(run_order, | 2393 EXPECT_THAT(run_order, |
2394 testing::ElementsAre(std::string("D1"), std::string("C1"), | 2394 testing::ElementsAre(std::string("C1"), std::string("D1"), |
2395 std::string("I1"))); | 2395 std::string("I1"))); |
2396 | 2396 |
2397 // The rest queued tasks fire when the renderer is resumed. | 2397 // The rest queued tasks fire when the renderer is resumed. |
2398 run_order.clear(); | 2398 run_order.clear(); |
2399 scheduler_->ResumeRenderer(); | 2399 scheduler_->ResumeRenderer(); |
2400 RunUntilIdle(); | 2400 RunUntilIdle(); |
2401 EXPECT_THAT(run_order, | 2401 EXPECT_THAT(run_order, |
2402 testing::ElementsAre(std::string("L1"), std::string("T1"))); | 2402 testing::ElementsAre(std::string("L1"), std::string("T1"))); |
2403 | 2403 |
2404 run_order.clear(); | 2404 run_order.clear(); |
2405 // No crash occurs when the renderer is suspended again, and | 2405 // No crash occurs when the renderer is suspended again, and |
2406 // tasks in some queues don't fire because of suspended. | 2406 // tasks in some queues don't fire because of suspended. |
2407 PostTestTasks(&run_order, "D2 C2 L2 I2 T2"); | 2407 PostTestTasks(&run_order, "D2 C2 L2 I2 T2"); |
2408 scheduler_->SuspendRenderer(); | 2408 scheduler_->SuspendRenderer(); |
2409 EnableIdleTasks(); | 2409 EnableIdleTasks(); |
2410 RunUntilIdle(); | 2410 RunUntilIdle(); |
2411 EXPECT_THAT(run_order, | 2411 EXPECT_THAT(run_order, |
2412 testing::ElementsAre(std::string("D2"), std::string("C2"), | 2412 testing::ElementsAre(std::string("C2"), std::string("D2"), |
2413 std::string("I2"))); | 2413 std::string("I2"))); |
2414 | 2414 |
2415 // The rest queued tasks fire when the renderer is resumed. | 2415 // The rest queued tasks fire when the renderer is resumed. |
2416 run_order.clear(); | 2416 run_order.clear(); |
2417 scheduler_->ResumeRenderer(); | 2417 scheduler_->ResumeRenderer(); |
2418 RunUntilIdle(); | 2418 RunUntilIdle(); |
2419 EXPECT_THAT(run_order, | 2419 EXPECT_THAT(run_order, |
2420 testing::ElementsAre(std::string("L2"), std::string("T2"))); | 2420 testing::ElementsAre(std::string("L2"), std::string("T2"))); |
2421 | 2421 |
2422 run_order.clear(); | 2422 run_order.clear(); |
(...skipping 1397 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3820 EXPECT_TRUE( | 3820 EXPECT_TRUE( |
3821 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); | 3821 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); |
3822 // Once we've dropped the lock, we realize the main thread is responsive. | 3822 // Once we've dropped the lock, we realize the main thread is responsive. |
3823 DropQueueingTimeEstimatorLock(); | 3823 DropQueueingTimeEstimatorLock(); |
3824 EXPECT_FALSE( | 3824 EXPECT_FALSE( |
3825 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); | 3825 scheduler_->MainThreadSeemsUnresponsive(responsiveness_threshold())); |
3826 } | 3826 } |
3827 | 3827 |
3828 } // namespace scheduler | 3828 } // namespace scheduler |
3829 } // namespace blink | 3829 } // namespace blink |
OLD | NEW |