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/web_view_scheduler_impl.h" | 5 #include "platform/scheduler/renderer/web_view_scheduler_impl.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
106 int run_count = 0; | 106 int run_count = 0; |
107 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 107 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
108 BLINK_FROM_HERE, | 108 BLINK_FROM_HERE, |
109 makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | 109 makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), |
110 1.0); | 110 1.0); |
111 | 111 |
112 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | 112 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
113 EXPECT_EQ(1000, run_count); | 113 EXPECT_EQ(1000, run_count); |
114 } | 114 } |
115 | 115 |
116 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInBackground) { | 116 TEST_F(WebViewSchedulerImplTest, |
| 117 RepeatingTimer_PageInBackgroundThenForeground) { |
117 web_view_scheduler_->setPageVisible(false); | 118 web_view_scheduler_->setPageVisible(false); |
118 | 119 |
119 int run_count = 0; | 120 int run_count = 0; |
120 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 121 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
121 BLINK_FROM_HERE, | 122 BLINK_FROM_HERE, |
122 makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | 123 makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), |
123 1.0); | 124 1.0); |
124 | 125 |
125 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | 126 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
| 127 EXPECT_EQ(1000, run_count); |
| 128 |
| 129 // The task queue isn't throttled at all until it's been in the background for |
| 130 // a 10 second grace period. |
| 131 clock_->Advance(base::TimeDelta::FromSeconds(10)); |
| 132 |
| 133 run_count = 0; |
| 134 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
126 EXPECT_EQ(1, run_count); | 135 EXPECT_EQ(1, run_count); |
| 136 |
| 137 // Make sure there's no delay in throttling being removed for pages that have |
| 138 // become visible. |
| 139 web_view_scheduler_->setPageVisible(true); |
| 140 |
| 141 run_count = 0; |
| 142 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
| 143 EXPECT_EQ(1001, run_count); // Note we end up running 1001 here because the |
| 144 // task was posted while throttled with a delay of 1ms so the first task was |
| 145 // due to run before the 1s period started. |
| 146 } |
| 147 |
| 148 TEST_F(WebViewSchedulerImplTest, GracePeriodAppliesToNewBackgroundFrames) { |
| 149 web_view_scheduler_->setPageVisible(false); |
| 150 |
| 151 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler = |
| 152 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); |
| 153 blink::WebTaskRunner* timer_task_runner = |
| 154 web_frame_scheduler->timerTaskRunner().get(); |
| 155 |
| 156 int run_count = 0; |
| 157 timer_task_runner->postDelayedTask( |
| 158 BLINK_FROM_HERE, |
| 159 makeRepeatingTask(web_frame_scheduler->timerTaskRunner(), &run_count), |
| 160 1.0); |
| 161 |
| 162 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
| 163 EXPECT_EQ(1000, run_count); |
| 164 |
| 165 // The task queue isn't throttled at all until it's been in the background for |
| 166 // a 10 second grace period. |
| 167 clock_->Advance(base::TimeDelta::FromSeconds(10)); |
| 168 |
| 169 run_count = 0; |
| 170 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
| 171 EXPECT_EQ(1, run_count); |
| 172 |
| 173 // Make sure there's no delay in throttling being removed for pages that have |
| 174 // become visible. |
| 175 web_view_scheduler_->setPageVisible(true); |
| 176 |
| 177 run_count = 0; |
| 178 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
| 179 EXPECT_EQ(1001, run_count); // Note we end up running 1001 here because the |
| 180 // task was posted while throttled with a delay of 1ms so the first task was |
| 181 // due to run before the 1s period started. |
127 } | 182 } |
128 | 183 |
129 TEST_F(WebViewSchedulerImplTest, RepeatingLoadingTask_PageInBackground) { | 184 TEST_F(WebViewSchedulerImplTest, RepeatingLoadingTask_PageInBackground) { |
130 web_view_scheduler_->setPageVisible(false); | 185 web_view_scheduler_->setPageVisible(false); |
131 | 186 |
132 int run_count = 0; | 187 int run_count = 0; |
133 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | 188 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( |
134 BLINK_FROM_HERE, | 189 BLINK_FROM_HERE, |
135 makeRepeatingTask(web_frame_scheduler_->loadingTaskRunner(), &run_count), | 190 makeRepeatingTask(web_frame_scheduler_->loadingTaskRunner(), &run_count), |
136 1.0); | 191 1.0); |
137 | 192 |
138 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | 193 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
139 EXPECT_EQ(1000, run_count); // Loading tasks should not be throttled | 194 EXPECT_EQ(1000, run_count); // Loading tasks should not be throttled |
140 } | 195 } |
141 | 196 |
142 TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) { | 197 TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) { |
143 std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler2( | 198 std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler2( |
144 new WebViewSchedulerImpl(nullptr, nullptr, scheduler_.get(), false)); | 199 new WebViewSchedulerImpl(nullptr, nullptr, scheduler_.get(), false)); |
145 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 = | 200 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 = |
146 web_view_scheduler2->createWebFrameSchedulerImpl(nullptr); | 201 web_view_scheduler2->createWebFrameSchedulerImpl(nullptr); |
147 | 202 |
148 web_view_scheduler_->setPageVisible(true); | 203 web_view_scheduler_->setPageVisible(true); |
149 web_view_scheduler2->setPageVisible(false); | 204 web_view_scheduler2->setPageVisible(false); |
150 | 205 |
| 206 // Advance past the no-throttling grace period. |
| 207 clock_->Advance(base::TimeDelta::FromSeconds(10)); |
| 208 |
151 int run_count1 = 0; | 209 int run_count1 = 0; |
152 int run_count2 = 0; | 210 int run_count2 = 0; |
153 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 211 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
154 BLINK_FROM_HERE, | 212 BLINK_FROM_HERE, |
155 makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1), | 213 makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1), |
156 1.0); | 214 1.0); |
157 web_frame_scheduler2->timerTaskRunner()->postDelayedTask( | 215 web_frame_scheduler2->timerTaskRunner()->postDelayedTask( |
158 BLINK_FROM_HERE, | 216 BLINK_FROM_HERE, |
159 makeRepeatingTask(web_frame_scheduler2->timerTaskRunner(), &run_count2), | 217 makeRepeatingTask(web_frame_scheduler2->timerTaskRunner(), &run_count2), |
160 1.0); | 218 1.0); |
(...skipping 270 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
431 | 489 |
432 TEST_F(WebViewSchedulerImplTest, DeleteWebViewScheduler_InTask) { | 490 TEST_F(WebViewSchedulerImplTest, DeleteWebViewScheduler_InTask) { |
433 web_frame_scheduler_->timerTaskRunner()->postTask( | 491 web_frame_scheduler_->timerTaskRunner()->postTask( |
434 BLINK_FROM_HERE, makeDeletionTask(web_view_scheduler_.release())); | 492 BLINK_FROM_HERE, makeDeletionTask(web_view_scheduler_.release())); |
435 mock_task_runner_->RunUntilIdle(); | 493 mock_task_runner_->RunUntilIdle(); |
436 } | 494 } |
437 | 495 |
438 TEST_F(WebViewSchedulerImplTest, DeleteThrottledQueue_InTask) { | 496 TEST_F(WebViewSchedulerImplTest, DeleteThrottledQueue_InTask) { |
439 web_view_scheduler_->setPageVisible(false); | 497 web_view_scheduler_->setPageVisible(false); |
440 | 498 |
| 499 // The task queue isn't throttled at all until it's been in the background for |
| 500 // a 10 second grace period. |
| 501 clock_->Advance(base::TimeDelta::FromSeconds(10)); |
| 502 |
441 WebFrameSchedulerImpl* web_frame_scheduler = | 503 WebFrameSchedulerImpl* web_frame_scheduler = |
442 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr).release(); | 504 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr).release(); |
443 RefPtr<blink::WebTaskRunner> timer_task_runner = | 505 RefPtr<blink::WebTaskRunner> timer_task_runner = |
444 web_frame_scheduler->timerTaskRunner(); | 506 web_frame_scheduler->timerTaskRunner(); |
445 | 507 |
446 int run_count = 0; | 508 int run_count = 0; |
447 timer_task_runner->postDelayedTask( | 509 timer_task_runner->postDelayedTask( |
448 BLINK_FROM_HERE, makeRepeatingTask(timer_task_runner, &run_count), 1.0); | 510 BLINK_FROM_HERE, makeRepeatingTask(timer_task_runner, &run_count), 1.0); |
449 | 511 |
450 // Note this will run at time t = 10s since we start at time t = 5000us, and | 512 // Note this will run at time t = 10s since we start at time t = 5000us, and |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
581 nullptr, &web_view_scheduler_settings, scheduler_.get(), false)); | 643 nullptr, &web_view_scheduler_settings, scheduler_.get(), false)); |
582 web_frame_scheduler_ = | 644 web_frame_scheduler_ = |
583 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); | 645 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); |
584 web_view_scheduler_->setPageVisible(false); | 646 web_view_scheduler_->setPageVisible(false); |
585 | 647 |
586 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 648 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
587 base::TimeDelta::FromMilliseconds(2500)); | 649 base::TimeDelta::FromMilliseconds(2500)); |
588 | 650 |
589 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 651 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
590 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), | 652 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), |
591 0.1); | 653 1); |
592 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 654 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
593 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), | 655 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), |
594 0.1); | 656 1); |
595 | 657 |
596 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 658 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
597 base::TimeDelta::FromMilliseconds(3500)); | 659 base::TimeDelta::FromMilliseconds(3500)); |
598 | 660 |
599 // Check that these tasks are aligned, but are not subject to | 661 // Check that these tasks are initially unthrottled. |
600 // budget-based throttling. | |
601 EXPECT_THAT( | 662 EXPECT_THAT( |
602 run_times, | 663 run_times, |
603 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3000), | 664 ElementsAre(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2501), |
604 base::TimeTicks() + base::TimeDelta::FromMilliseconds(3250))); | 665 base::TimeTicks() + base::TimeDelta::FromMilliseconds(2751))); |
605 run_times.clear(); | 666 run_times.clear(); |
606 | 667 |
607 mock_task_runner_->RunUntilTime(base::TimeTicks() + | 668 mock_task_runner_->RunUntilTime(base::TimeTicks() + |
608 base::TimeDelta::FromMilliseconds(11500)); | 669 base::TimeDelta::FromMilliseconds(11500)); |
609 | 670 |
610 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 671 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
611 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), | 672 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), |
612 0.1); | 673 1); |
613 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 674 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
614 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), | 675 BLINK_FROM_HERE, base::Bind(&ExpensiveTestTask, clock_.get(), &run_times), |
615 0.1); | 676 1); |
616 | 677 |
617 mock_task_runner_->RunUntilIdle(); | 678 mock_task_runner_->RunUntilIdle(); |
618 | 679 |
619 // Check that tasks are aligned and throttled. | 680 // After the grace period has passed, tasks should be aligned and have budget |
| 681 // based throttling. |
620 EXPECT_THAT( | 682 EXPECT_THAT( |
621 run_times, | 683 run_times, |
622 ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(12), | 684 ElementsAre(base::TimeTicks() + base::TimeDelta::FromSeconds(12), |
623 base::TimeTicks() + base::TimeDelta::FromSeconds(29))); | 685 base::TimeTicks() + base::TimeDelta::FromSeconds(26))); |
624 } | 686 } |
625 | 687 |
626 } // namespace scheduler | 688 } // namespace scheduler |
627 } // namespace blink | 689 } // namespace blink |
OLD | NEW |