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

Side by Side Diff: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc

Issue 2810423003: Schedule bitmap animation timers on the compositor task runner. (Closed)
Patch Set: remove TODO comments from tests Created 3 years, 7 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 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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698