OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/task_queue_throttler.h" | 5 #include "platform/scheduler/renderer/task_queue_throttler.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 | 10 |
(...skipping 540 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
551 | 551 |
552 task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get()); | 552 task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get()); |
553 | 553 |
554 // Post an expensive task. Pool is now throttled. | 554 // Post an expensive task. Pool is now throttled. |
555 timer_queue_->PostDelayedTask( | 555 timer_queue_->PostDelayedTask( |
556 FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()), | 556 FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()), |
557 base::TimeDelta::FromMilliseconds(200)); | 557 base::TimeDelta::FromMilliseconds(200)); |
558 | 558 |
559 mock_task_runner_->RunUntilIdle(); | 559 mock_task_runner_->RunUntilIdle(); |
560 | 560 |
561 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 561 EXPECT_THAT( |
562 base::TimeDelta::FromMilliseconds(1000))); | 562 run_times, |
| 563 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000))); |
563 run_times.clear(); | 564 run_times.clear(); |
564 | 565 |
565 LazyNow lazy_now(clock_.get()); | 566 LazyNow lazy_now(clock_.get()); |
566 pool->DisableThrottling(&lazy_now); | 567 pool->DisableThrottling(&lazy_now); |
567 EXPECT_FALSE(pool->IsThrottlingEnabled()); | 568 EXPECT_FALSE(pool->IsThrottlingEnabled()); |
568 | 569 |
569 // Pool should not be throttled now. | 570 // Pool should not be throttled now. |
570 timer_queue_->PostDelayedTask( | 571 timer_queue_->PostDelayedTask( |
571 FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()), | 572 FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()), |
572 base::TimeDelta::FromMilliseconds(200)); | 573 base::TimeDelta::FromMilliseconds(200)); |
573 | 574 |
574 mock_task_runner_->RunUntilIdle(); | 575 mock_task_runner_->RunUntilIdle(); |
575 | 576 |
576 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 577 EXPECT_THAT( |
577 base::TimeDelta::FromMilliseconds(2000))); | 578 run_times, |
| 579 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000))); |
578 run_times.clear(); | 580 run_times.clear(); |
579 | 581 |
580 lazy_now = LazyNow(clock_.get()); | 582 lazy_now = LazyNow(clock_.get()); |
581 pool->EnableThrottling(&lazy_now); | 583 pool->EnableThrottling(&lazy_now); |
582 EXPECT_TRUE(pool->IsThrottlingEnabled()); | 584 EXPECT_TRUE(pool->IsThrottlingEnabled()); |
583 | 585 |
584 // Because time pool was disabled, time budget level did not replenish | 586 // Because time pool was disabled, time budget level did not replenish |
585 // and queue is throttled. | 587 // and queue is throttled. |
586 timer_queue_->PostDelayedTask( | 588 timer_queue_->PostDelayedTask( |
587 FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()), | 589 FROM_HERE, base::Bind(&ExpensiveTestTask, &run_times, clock_.get()), |
588 base::TimeDelta::FromMilliseconds(200)); | 590 base::TimeDelta::FromMilliseconds(200)); |
589 | 591 |
590 mock_task_runner_->RunUntilIdle(); | 592 mock_task_runner_->RunUntilIdle(); |
591 | 593 |
592 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 594 EXPECT_THAT( |
593 base::TimeDelta::FromMilliseconds(4000))); | 595 run_times, |
| 596 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4000))); |
594 run_times.clear(); | 597 run_times.clear(); |
595 | 598 |
596 task_queue_throttler_->DecreaseThrottleRefCount(timer_queue_.get()); | 599 task_queue_throttler_->DecreaseThrottleRefCount(timer_queue_.get()); |
597 | 600 |
598 pool->RemoveQueue(clock_->NowTicks(), timer_queue_.get()); | 601 pool->RemoveQueue(clock_->NowTicks(), timer_queue_.get()); |
599 pool->Close(); | 602 pool->Close(); |
600 } | 603 } |
601 | 604 |
602 TEST_F(TaskQueueThrottlerTest, ImmediateTasksTimeBudgetThrottling) { | 605 TEST_F(TaskQueueThrottlerTest, ImmediateTasksTimeBudgetThrottling) { |
603 std::vector<base::TimeTicks> run_times; | 606 std::vector<base::TimeTicks> run_times; |
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
780 | 783 |
781 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 784 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
782 base::TimeDelta::FromMilliseconds(300)); | 785 base::TimeDelta::FromMilliseconds(300)); |
783 | 786 |
784 // Disable throttling - task should run immediately. | 787 // Disable throttling - task should run immediately. |
785 task_queue_throttler_->DisableThrottling(); | 788 task_queue_throttler_->DisableThrottling(); |
786 | 789 |
787 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 790 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
788 base::TimeDelta::FromMilliseconds(500)); | 791 base::TimeDelta::FromMilliseconds(500)); |
789 | 792 |
790 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 793 EXPECT_THAT( |
791 base::TimeDelta::FromMilliseconds(300))); | 794 run_times, |
| 795 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(300))); |
792 run_times.clear(); | 796 run_times.clear(); |
793 | 797 |
794 // Schedule a task at 900ms. It should proceed as normal. | 798 // Schedule a task at 900ms. It should proceed as normal. |
795 timer_queue_->PostDelayedTask(FROM_HERE, | 799 timer_queue_->PostDelayedTask(FROM_HERE, |
796 base::Bind(&TestTask, &run_times, clock_.get()), | 800 base::Bind(&TestTask, &run_times, clock_.get()), |
797 base::TimeDelta::FromMilliseconds(400)); | 801 base::TimeDelta::FromMilliseconds(400)); |
798 | 802 |
799 // Schedule a task at 1200ms. It should proceed as normal. | 803 // Schedule a task at 1200ms. It should proceed as normal. |
800 // PumpThrottledTasks was scheduled at 1000ms, so it needs to be checked | 804 // PumpThrottledTasks was scheduled at 1000ms, so it needs to be checked |
801 // that it was cancelled and it does not interfere with tasks posted before | 805 // that it was cancelled and it does not interfere with tasks posted before |
(...skipping 18 matching lines...) Expand all Loading... |
820 base::TimeDelta::FromMilliseconds(200)); | 824 base::TimeDelta::FromMilliseconds(200)); |
821 | 825 |
822 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 826 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
823 base::TimeDelta::FromMilliseconds(1400)); | 827 base::TimeDelta::FromMilliseconds(1400)); |
824 | 828 |
825 // Throttling is enabled and new task should be aligned. | 829 // Throttling is enabled and new task should be aligned. |
826 task_queue_throttler_->EnableThrottling(); | 830 task_queue_throttler_->EnableThrottling(); |
827 | 831 |
828 mock_task_runner_->RunUntilIdle(); | 832 mock_task_runner_->RunUntilIdle(); |
829 | 833 |
830 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 834 EXPECT_THAT( |
831 base::TimeDelta::FromMilliseconds(2000))); | 835 run_times, |
| 836 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000))); |
832 } | 837 } |
833 | 838 |
834 namespace { | 839 namespace { |
835 | 840 |
836 void RecordThrottling(std::vector<base::TimeDelta>* reported_throttling_times, | 841 void RecordThrottling(std::vector<base::TimeDelta>* reported_throttling_times, |
837 base::TimeDelta throttling_duration) { | 842 base::TimeDelta throttling_duration) { |
838 reported_throttling_times->push_back(throttling_duration); | 843 reported_throttling_times->push_back(throttling_duration); |
839 } | 844 } |
840 | 845 |
841 } // namespace | 846 } // namespace |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
941 | 946 |
942 lazy_now = LazyNow(clock_.get()); | 947 lazy_now = LazyNow(clock_.get()); |
943 pool->EnableThrottling(&lazy_now); | 948 pool->EnableThrottling(&lazy_now); |
944 | 949 |
945 timer_queue_->PostDelayedTask(FROM_HERE, | 950 timer_queue_->PostDelayedTask(FROM_HERE, |
946 base::Bind(&TestTask, &run_times, clock_.get()), | 951 base::Bind(&TestTask, &run_times, clock_.get()), |
947 base::TimeDelta::FromMilliseconds(200)); | 952 base::TimeDelta::FromMilliseconds(200)); |
948 | 953 |
949 mock_task_runner_->RunUntilIdle(); | 954 mock_task_runner_->RunUntilIdle(); |
950 | 955 |
951 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 956 EXPECT_THAT( |
952 base::TimeDelta::FromMilliseconds(300))); | 957 run_times, |
| 958 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(300))); |
953 } | 959 } |
954 | 960 |
955 TEST_F(TaskQueueThrottlerTest, AddQueueToBudgetPoolWhenThrottlingDisabled) { | 961 TEST_F(TaskQueueThrottlerTest, AddQueueToBudgetPoolWhenThrottlingDisabled) { |
956 // This test checks that a task queue is added to time budget pool | 962 // This test checks that a task queue is added to time budget pool |
957 // when throttling is disabled, is does not throttle queue. | 963 // when throttling is disabled, is does not throttle queue. |
958 std::vector<base::TimeTicks> run_times; | 964 std::vector<base::TimeTicks> run_times; |
959 | 965 |
960 task_queue_throttler_->DisableThrottling(); | 966 task_queue_throttler_->DisableThrottling(); |
961 | 967 |
962 TaskQueueThrottler::TimeBudgetPool* pool = | 968 TaskQueueThrottler::TimeBudgetPool* pool = |
963 task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt, | 969 task_queue_throttler_->CreateTimeBudgetPool("test", base::nullopt, |
964 base::nullopt); | 970 base::nullopt); |
965 task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get()); | 971 task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get()); |
966 | 972 |
967 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 973 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
968 base::TimeDelta::FromMilliseconds(100)); | 974 base::TimeDelta::FromMilliseconds(100)); |
969 | 975 |
970 timer_queue_->PostDelayedTask(FROM_HERE, | 976 timer_queue_->PostDelayedTask(FROM_HERE, |
971 base::Bind(&TestTask, &run_times, clock_.get()), | 977 base::Bind(&TestTask, &run_times, clock_.get()), |
972 base::TimeDelta::FromMilliseconds(200)); | 978 base::TimeDelta::FromMilliseconds(200)); |
973 | 979 |
974 pool->AddQueue(base::TimeTicks(), timer_queue_.get()); | 980 pool->AddQueue(base::TimeTicks(), timer_queue_.get()); |
975 | 981 |
976 mock_task_runner_->RunUntilIdle(); | 982 mock_task_runner_->RunUntilIdle(); |
977 | 983 |
978 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 984 EXPECT_THAT( |
979 base::TimeDelta::FromMilliseconds(300))); | 985 run_times, |
| 986 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(300))); |
980 } | 987 } |
981 | 988 |
982 TEST_F(TaskQueueThrottlerTest, DisabledQueueThenEnabledQueue) { | 989 TEST_F(TaskQueueThrottlerTest, DisabledQueueThenEnabledQueue) { |
983 std::vector<base::TimeTicks> run_times; | 990 std::vector<base::TimeTicks> run_times; |
984 | 991 |
985 scoped_refptr<TaskQueue> second_queue = | 992 scoped_refptr<TaskQueue> second_queue = |
986 scheduler_->NewTimerTaskRunner(TaskQueue::QueueType::TEST); | 993 scheduler_->NewTimerTaskRunner(TaskQueue::QueueType::TEST); |
987 | 994 |
988 task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get()); | 995 task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get()); |
989 task_queue_throttler_->IncreaseThrottleRefCount(second_queue.get()); | 996 task_queue_throttler_->IncreaseThrottleRefCount(second_queue.get()); |
990 | 997 |
991 timer_queue_->PostDelayedTask(FROM_HERE, | 998 timer_queue_->PostDelayedTask(FROM_HERE, |
992 base::Bind(&TestTask, &run_times, clock_.get()), | 999 base::Bind(&TestTask, &run_times, clock_.get()), |
993 base::TimeDelta::FromMilliseconds(100)); | 1000 base::TimeDelta::FromMilliseconds(100)); |
994 second_queue->PostDelayedTask(FROM_HERE, | 1001 second_queue->PostDelayedTask(FROM_HERE, |
995 base::Bind(&TestTask, &run_times, clock_.get()), | 1002 base::Bind(&TestTask, &run_times, clock_.get()), |
996 base::TimeDelta::FromMilliseconds(200)); | 1003 base::TimeDelta::FromMilliseconds(200)); |
997 | 1004 |
998 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = | 1005 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter = |
999 timer_queue_->CreateQueueEnabledVoter(); | 1006 timer_queue_->CreateQueueEnabledVoter(); |
1000 voter->SetQueueEnabled(false); | 1007 voter->SetQueueEnabled(false); |
1001 | 1008 |
1002 clock_->Advance(base::TimeDelta::FromMilliseconds(250)); | 1009 clock_->Advance(base::TimeDelta::FromMilliseconds(250)); |
1003 | 1010 |
1004 mock_task_runner_->RunUntilIdle(); | 1011 mock_task_runner_->RunUntilIdle(); |
1005 | 1012 |
1006 EXPECT_THAT(run_times, ElementsAre(base::TimeTicks() + | 1013 EXPECT_THAT( |
1007 base::TimeDelta::FromMilliseconds(1000))); | 1014 run_times, |
| 1015 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000))); |
1008 | 1016 |
1009 voter->SetQueueEnabled(true); | 1017 voter->SetQueueEnabled(true); |
1010 mock_task_runner_->RunUntilIdle(); | 1018 mock_task_runner_->RunUntilIdle(); |
1011 | 1019 |
1012 EXPECT_THAT( | 1020 EXPECT_THAT( |
1013 run_times, | 1021 run_times, |
1014 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000), | 1022 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(1000), |
1015 base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000))); | 1023 base::TimeTicks() + base::TimeDelta::FromMilliseconds(2000))); |
1016 } | 1024 } |
1017 | 1025 |
1018 } // namespace scheduler | 1026 } // namespace scheduler |
1019 } // namespace blink | 1027 } // namespace blink |
OLD | NEW |