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 "components/scheduler/renderer/web_view_scheduler_impl.h" | 5 #include "components/scheduler/renderer/web_view_scheduler_impl.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/memory/scoped_ptr.h" | 8 #include "base/memory/scoped_ptr.h" |
9 #include "base/test/simple_test_tick_clock.h" | 9 #include "base/test/simple_test_tick_clock.h" |
10 #include "cc/test/ordered_simple_task_runner.h" | 10 #include "cc/test/ordered_simple_task_runner.h" |
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
151 1.0); | 151 1.0); |
152 | 152 |
153 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | 153 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
154 EXPECT_EQ(1000, run_count1); | 154 EXPECT_EQ(1000, run_count1); |
155 EXPECT_EQ(1, run_count2); | 155 EXPECT_EQ(1, run_count2); |
156 } | 156 } |
157 | 157 |
158 namespace { | 158 namespace { |
159 class VirtualTimeRecorderTask : public blink::WebTaskRunner::Task { | 159 class VirtualTimeRecorderTask : public blink::WebTaskRunner::Task { |
160 public: | 160 public: |
161 VirtualTimeRecorderTask(RendererSchedulerImpl* scheduler, | 161 VirtualTimeRecorderTask(base::SimpleTestTickClock* clock, |
| 162 blink::WebTaskRunner* web_task_runner, |
162 std::vector<base::TimeTicks>* out_real_times, | 163 std::vector<base::TimeTicks>* out_real_times, |
163 std::vector<size_t>* out_virtual_times_ms) | 164 std::vector<size_t>* out_virtual_times_ms) |
164 : scheduler_(scheduler), | 165 : clock_(clock), |
| 166 web_task_runner_(web_task_runner), |
165 out_real_times_(out_real_times), | 167 out_real_times_(out_real_times), |
166 out_virtual_times_ms_(out_virtual_times_ms) {} | 168 out_virtual_times_ms_(out_virtual_times_ms) {} |
167 | 169 |
168 ~VirtualTimeRecorderTask() override {} | 170 ~VirtualTimeRecorderTask() override {} |
169 | 171 |
170 void run() override { | 172 void run() override { |
171 out_real_times_->push_back(scheduler_->tick_clock()->NowTicks()); | 173 out_real_times_->push_back(clock_->NowTicks()); |
172 out_virtual_times_ms_->push_back( | 174 out_virtual_times_ms_->push_back( |
173 scheduler_->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0); | 175 web_task_runner_->monotonicallyIncreasingVirtualTimeSeconds() * 1000.0); |
174 } | 176 } |
175 | 177 |
176 private: | 178 private: |
177 RendererSchedulerImpl* scheduler_; // NOT OWNED | 179 base::SimpleTestTickClock* clock_; // NOT OWNED |
| 180 blink::WebTaskRunner* web_task_runner_; // NOT OWNED |
178 std::vector<base::TimeTicks>* out_real_times_; // NOT OWNED | 181 std::vector<base::TimeTicks>* out_real_times_; // NOT OWNED |
179 std::vector<size_t>* out_virtual_times_ms_; // NOT OWNED | 182 std::vector<size_t>* out_virtual_times_ms_; // NOT OWNED |
180 }; | 183 }; |
181 } | 184 } |
182 | 185 |
183 TEST_F(WebViewSchedulerImplTest, VirtualTime_TimerFastForwarding) { | 186 TEST_F(WebViewSchedulerImplTest, VirtualTime_TimerFastForwarding) { |
184 std::vector<base::TimeTicks> real_times; | 187 std::vector<base::TimeTicks> real_times; |
185 std::vector<size_t> virtual_times_ms; | 188 std::vector<size_t> virtual_times_ms; |
186 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); | 189 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); |
187 size_t initial_virtual_time_ms = | 190 size_t initial_virtual_time_ms = |
188 scheduler_->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0; | 191 web_frame_scheduler_->timerTaskRunner() |
| 192 ->monotonicallyIncreasingVirtualTimeSeconds() * |
| 193 1000.0; |
189 | 194 |
190 web_view_scheduler_->enableVirtualTime(); | 195 web_view_scheduler_->enableVirtualTime(); |
191 | 196 |
192 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 197 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
193 BLINK_FROM_HERE, | 198 BLINK_FROM_HERE, |
194 new VirtualTimeRecorderTask(scheduler_.get(), &real_times, | 199 new VirtualTimeRecorderTask(clock_.get(), |
195 &virtual_times_ms), | 200 web_frame_scheduler_->timerTaskRunner(), |
| 201 &real_times, &virtual_times_ms), |
196 2.0); | 202 2.0); |
197 | 203 |
198 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 204 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
199 BLINK_FROM_HERE, | 205 BLINK_FROM_HERE, |
200 new VirtualTimeRecorderTask(scheduler_.get(), &real_times, | 206 new VirtualTimeRecorderTask(clock_.get(), |
201 &virtual_times_ms), | 207 web_frame_scheduler_->timerTaskRunner(), |
| 208 &real_times, &virtual_times_ms), |
202 20.0); | 209 20.0); |
203 | 210 |
204 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 211 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
205 BLINK_FROM_HERE, | 212 BLINK_FROM_HERE, |
206 new VirtualTimeRecorderTask(scheduler_.get(), &real_times, | 213 new VirtualTimeRecorderTask(clock_.get(), |
207 &virtual_times_ms), | 214 web_frame_scheduler_->timerTaskRunner(), |
| 215 &real_times, &virtual_times_ms), |
208 200.0); | 216 200.0); |
209 | 217 |
210 mock_task_runner_->RunUntilIdle(); | 218 mock_task_runner_->RunUntilIdle(); |
211 | 219 |
212 EXPECT_THAT(real_times, ElementsAre(initial_real_time, | 220 EXPECT_THAT(real_times, ElementsAre(initial_real_time, |
213 initial_real_time, initial_real_time)); | 221 initial_real_time, initial_real_time)); |
214 EXPECT_THAT(virtual_times_ms, | 222 EXPECT_THAT(virtual_times_ms, |
215 ElementsAre(initial_virtual_time_ms + 2, | 223 ElementsAre(initial_virtual_time_ms + 2, |
216 initial_virtual_time_ms + 20, | 224 initial_virtual_time_ms + 20, |
217 initial_virtual_time_ms + 200)); | 225 initial_virtual_time_ms + 200)); |
218 } | 226 } |
219 | 227 |
220 TEST_F(WebViewSchedulerImplTest, VirtualTime_LoadingTaskFastForwarding) { | 228 TEST_F(WebViewSchedulerImplTest, VirtualTime_LoadingTaskFastForwarding) { |
221 std::vector<base::TimeTicks> real_times; | 229 std::vector<base::TimeTicks> real_times; |
222 std::vector<size_t> virtual_times_ms; | 230 std::vector<size_t> virtual_times_ms; |
223 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); | 231 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); |
224 size_t initial_virtual_time_ms = | 232 size_t initial_virtual_time_ms = |
225 scheduler_->MonotonicallyIncreasingVirtualTimeSeconds() * 1000.0; | 233 web_frame_scheduler_->timerTaskRunner() |
| 234 ->monotonicallyIncreasingVirtualTimeSeconds() * |
| 235 1000.0; |
226 | 236 |
227 web_view_scheduler_->enableVirtualTime(); | 237 web_view_scheduler_->enableVirtualTime(); |
228 | 238 |
229 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | 239 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( |
230 BLINK_FROM_HERE, | 240 BLINK_FROM_HERE, |
231 new VirtualTimeRecorderTask(scheduler_.get(), &real_times, | 241 new VirtualTimeRecorderTask(clock_.get(), |
232 &virtual_times_ms), | 242 web_frame_scheduler_->loadingTaskRunner(), |
| 243 &real_times, &virtual_times_ms), |
233 2.0); | 244 2.0); |
234 | 245 |
235 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | 246 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( |
236 BLINK_FROM_HERE, | 247 BLINK_FROM_HERE, |
237 new VirtualTimeRecorderTask(scheduler_.get(), &real_times, | 248 new VirtualTimeRecorderTask(clock_.get(), |
238 &virtual_times_ms), | 249 web_frame_scheduler_->loadingTaskRunner(), |
| 250 &real_times, &virtual_times_ms), |
239 20.0); | 251 20.0); |
240 | 252 |
241 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | 253 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( |
242 BLINK_FROM_HERE, | 254 BLINK_FROM_HERE, |
243 new VirtualTimeRecorderTask(scheduler_.get(), &real_times, | 255 new VirtualTimeRecorderTask(clock_.get(), |
244 &virtual_times_ms), | 256 web_frame_scheduler_->loadingTaskRunner(), |
| 257 &real_times, &virtual_times_ms), |
245 200.0); | 258 200.0); |
246 | 259 |
247 mock_task_runner_->RunUntilIdle(); | 260 mock_task_runner_->RunUntilIdle(); |
248 | 261 |
249 EXPECT_THAT(real_times, ElementsAre(initial_real_time, | 262 EXPECT_THAT(real_times, ElementsAre(initial_real_time, |
250 initial_real_time, initial_real_time)); | 263 initial_real_time, initial_real_time)); |
251 EXPECT_THAT(virtual_times_ms, | 264 EXPECT_THAT(virtual_times_ms, |
252 ElementsAre(initial_virtual_time_ms + 2, | 265 ElementsAre(initial_virtual_time_ms + 2, |
253 initial_virtual_time_ms + 20, | 266 initial_virtual_time_ms + 20, |
254 initial_virtual_time_ms + 200)); | 267 initial_virtual_time_ms + 200)); |
255 } | 268 } |
256 | 269 |
257 TEST_F(WebViewSchedulerImplTest, | 270 TEST_F(WebViewSchedulerImplTest, |
258 RepeatingTimer_PageInBackground_MeansNothingForFirtualTime) { | 271 RepeatingTimer_PageInBackground_MeansNothingForVirtualTime) { |
259 web_view_scheduler_->enableVirtualTime(); | 272 web_view_scheduler_->enableVirtualTime(); |
260 web_view_scheduler_->setPageVisible(false); | 273 web_view_scheduler_->setPageVisible(false); |
261 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); | 274 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); |
262 | 275 |
263 int run_count = 0; | 276 int run_count = 0; |
264 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 277 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
265 BLINK_FROM_HERE, | 278 BLINK_FROM_HERE, |
266 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | 279 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), |
267 1.0); | 280 1.0); |
268 | 281 |
269 mock_task_runner_->RunTasksWhile(mock_task_runner_->TaskRunCountBelow(2000)); | 282 mock_task_runner_->RunTasksWhile(mock_task_runner_->TaskRunCountBelow(2000)); |
| 283 // Virtual time means page visibility is ignored. |
270 EXPECT_EQ(1999, run_count); | 284 EXPECT_EQ(1999, run_count); |
271 | 285 |
272 // The global tick clock has not moved, yet we ran a large number of "delayed" | 286 // The global tick clock has not moved, yet we ran a large number of "delayed" |
273 // tasks despite calling setPageVisible(false). | 287 // tasks despite calling setPageVisible(false). |
274 EXPECT_EQ(initial_real_time, scheduler_->tick_clock()->NowTicks()); | 288 EXPECT_EQ(initial_real_time, scheduler_->tick_clock()->NowTicks()); |
275 } | 289 } |
276 | 290 |
277 namespace { | 291 namespace { |
278 class RunOrderTask : public blink::WebTaskRunner::Task { | 292 class RunOrderTask : public blink::WebTaskRunner::Task { |
279 public: | 293 public: |
(...skipping 198 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
478 // it will prevent further tasks from running (i.e. the RepeatingTask) by | 492 // it will prevent further tasks from running (i.e. the RepeatingTask) by |
479 // deleting the WebFrameScheduler. | 493 // deleting the WebFrameScheduler. |
480 timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task, | 494 timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task, |
481 9990.0); | 495 9990.0); |
482 | 496 |
483 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100)); | 497 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100)); |
484 EXPECT_EQ(10, run_count); | 498 EXPECT_EQ(10, run_count); |
485 } | 499 } |
486 | 500 |
487 } // namespace scheduler | 501 } // namespace scheduler |
OLD | NEW |