| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/scheduler/renderer/web_view_scheduler_impl.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 | |
| 9 #include "base/callback.h" | |
| 10 #include "base/memory/ptr_util.h" | |
| 11 #include "base/test/simple_test_tick_clock.h" | |
| 12 #include "cc/test/ordered_simple_task_runner.h" | |
| 13 #include "components/scheduler/base/test_time_source.h" | |
| 14 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h" | |
| 15 #include "components/scheduler/renderer/renderer_scheduler_impl.h" | |
| 16 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" | |
| 17 #include "testing/gmock/include/gmock/gmock.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 #include "third_party/WebKit/public/platform/WebTaskRunner.h" | |
| 20 #include "third_party/WebKit/public/platform/WebTraceLocation.h" | |
| 21 | |
| 22 using testing::ElementsAre; | |
| 23 using VirtualTimePolicy = blink::WebViewScheduler::VirtualTimePolicy; | |
| 24 | |
| 25 namespace scheduler { | |
| 26 | |
| 27 class WebViewSchedulerImplTest : public testing::Test { | |
| 28 public: | |
| 29 WebViewSchedulerImplTest() {} | |
| 30 ~WebViewSchedulerImplTest() override {} | |
| 31 | |
| 32 void SetUp() override { | |
| 33 clock_.reset(new base::SimpleTestTickClock()); | |
| 34 clock_->Advance(base::TimeDelta::FromMicroseconds(5000)); | |
| 35 mock_task_runner_ = | |
| 36 make_scoped_refptr(new cc::OrderedSimpleTaskRunner(clock_.get(), true)); | |
| 37 delegate_ = SchedulerTqmDelegateForTest::Create( | |
| 38 mock_task_runner_, base::WrapUnique(new TestTimeSource(clock_.get()))); | |
| 39 scheduler_.reset(new RendererSchedulerImpl(delegate_)); | |
| 40 web_view_scheduler_.reset(new WebViewSchedulerImpl( | |
| 41 nullptr, scheduler_.get(), DisableBackgroundTimerThrottling())); | |
| 42 web_frame_scheduler_ = | |
| 43 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); | |
| 44 } | |
| 45 | |
| 46 void TearDown() override { | |
| 47 web_frame_scheduler_.reset(); | |
| 48 web_view_scheduler_.reset(); | |
| 49 scheduler_->Shutdown(); | |
| 50 scheduler_.reset(); | |
| 51 } | |
| 52 | |
| 53 virtual bool DisableBackgroundTimerThrottling() const { return false; } | |
| 54 | |
| 55 std::unique_ptr<base::SimpleTestTickClock> clock_; | |
| 56 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; | |
| 57 scoped_refptr<SchedulerTqmDelegate> delegate_; | |
| 58 std::unique_ptr<RendererSchedulerImpl> scheduler_; | |
| 59 std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler_; | |
| 60 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler_; | |
| 61 }; | |
| 62 | |
| 63 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersBefore) { | |
| 64 std::unique_ptr<blink::WebFrameScheduler> frame1( | |
| 65 web_view_scheduler_->createFrameScheduler(nullptr)); | |
| 66 std::unique_ptr<blink::WebFrameScheduler> frame2( | |
| 67 web_view_scheduler_->createFrameScheduler(nullptr)); | |
| 68 } | |
| 69 | |
| 70 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersAfter) { | |
| 71 std::unique_ptr<blink::WebFrameScheduler> frame1( | |
| 72 web_view_scheduler_->createFrameScheduler(nullptr)); | |
| 73 std::unique_ptr<blink::WebFrameScheduler> frame2( | |
| 74 web_view_scheduler_->createFrameScheduler(nullptr)); | |
| 75 web_view_scheduler_.reset(); | |
| 76 } | |
| 77 | |
| 78 namespace { | |
| 79 class RepeatingTask : public blink::WebTaskRunner::Task { | |
| 80 public: | |
| 81 RepeatingTask(blink::WebTaskRunner* web_task_runner, int* run_count) | |
| 82 : web_task_runner_(web_task_runner), run_count_(run_count) {} | |
| 83 | |
| 84 ~RepeatingTask() override {} | |
| 85 | |
| 86 void run() override { | |
| 87 (*run_count_)++; | |
| 88 web_task_runner_->postDelayedTask( | |
| 89 BLINK_FROM_HERE, new RepeatingTask(web_task_runner_, run_count_), 1.0); | |
| 90 } | |
| 91 | |
| 92 private: | |
| 93 blink::WebTaskRunner* web_task_runner_; // NOT OWNED | |
| 94 int* run_count_; // NOT OWNED | |
| 95 }; | |
| 96 } // namespace | |
| 97 | |
| 98 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInForeground) { | |
| 99 web_view_scheduler_->setPageVisible(true); | |
| 100 | |
| 101 int run_count = 0; | |
| 102 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 103 BLINK_FROM_HERE, | |
| 104 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | |
| 105 1.0); | |
| 106 | |
| 107 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
| 108 EXPECT_EQ(1000, run_count); | |
| 109 } | |
| 110 | |
| 111 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInBackground) { | |
| 112 web_view_scheduler_->setPageVisible(false); | |
| 113 | |
| 114 int run_count = 0; | |
| 115 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 116 BLINK_FROM_HERE, | |
| 117 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | |
| 118 1.0); | |
| 119 | |
| 120 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
| 121 EXPECT_EQ(1, run_count); | |
| 122 } | |
| 123 | |
| 124 TEST_F(WebViewSchedulerImplTest, RepeatingLoadingTask_PageInBackground) { | |
| 125 web_view_scheduler_->setPageVisible(false); | |
| 126 | |
| 127 int run_count = 0; | |
| 128 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | |
| 129 BLINK_FROM_HERE, | |
| 130 new RepeatingTask(web_frame_scheduler_->loadingTaskRunner(), &run_count), | |
| 131 1.0); | |
| 132 | |
| 133 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
| 134 EXPECT_EQ(1000, run_count); // Loading tasks should not be throttled | |
| 135 } | |
| 136 | |
| 137 TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) { | |
| 138 std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler2( | |
| 139 new WebViewSchedulerImpl(nullptr, scheduler_.get(), false)); | |
| 140 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 = | |
| 141 web_view_scheduler2->createWebFrameSchedulerImpl(nullptr); | |
| 142 | |
| 143 web_view_scheduler_->setPageVisible(true); | |
| 144 web_view_scheduler2->setPageVisible(false); | |
| 145 | |
| 146 int run_count1 = 0; | |
| 147 int run_count2 = 0; | |
| 148 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 149 BLINK_FROM_HERE, | |
| 150 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1), | |
| 151 1.0); | |
| 152 web_frame_scheduler2->timerTaskRunner()->postDelayedTask( | |
| 153 BLINK_FROM_HERE, | |
| 154 new RepeatingTask(web_frame_scheduler2->timerTaskRunner(), &run_count2), | |
| 155 1.0); | |
| 156 | |
| 157 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
| 158 EXPECT_EQ(1000, run_count1); | |
| 159 EXPECT_EQ(1, run_count2); | |
| 160 } | |
| 161 | |
| 162 namespace { | |
| 163 class VirtualTimeRecorderTask : public blink::WebTaskRunner::Task { | |
| 164 public: | |
| 165 VirtualTimeRecorderTask(base::SimpleTestTickClock* clock, | |
| 166 blink::WebTaskRunner* web_task_runner, | |
| 167 std::vector<base::TimeTicks>* out_real_times, | |
| 168 std::vector<size_t>* out_virtual_times_ms) | |
| 169 : clock_(clock), | |
| 170 web_task_runner_(web_task_runner), | |
| 171 out_real_times_(out_real_times), | |
| 172 out_virtual_times_ms_(out_virtual_times_ms) {} | |
| 173 | |
| 174 ~VirtualTimeRecorderTask() override {} | |
| 175 | |
| 176 void run() override { | |
| 177 out_real_times_->push_back(clock_->NowTicks()); | |
| 178 out_virtual_times_ms_->push_back( | |
| 179 web_task_runner_->monotonicallyIncreasingVirtualTimeSeconds() * 1000.0); | |
| 180 } | |
| 181 | |
| 182 private: | |
| 183 base::SimpleTestTickClock* clock_; // NOT OWNED | |
| 184 blink::WebTaskRunner* web_task_runner_; // NOT OWNED | |
| 185 std::vector<base::TimeTicks>* out_real_times_; // NOT OWNED | |
| 186 std::vector<size_t>* out_virtual_times_ms_; // NOT OWNED | |
| 187 }; | |
| 188 } | |
| 189 | |
| 190 TEST_F(WebViewSchedulerImplTest, VirtualTime_TimerFastForwarding) { | |
| 191 std::vector<base::TimeTicks> real_times; | |
| 192 std::vector<size_t> virtual_times_ms; | |
| 193 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); | |
| 194 size_t initial_virtual_time_ms = | |
| 195 web_frame_scheduler_->timerTaskRunner() | |
| 196 ->monotonicallyIncreasingVirtualTimeSeconds() * | |
| 197 1000.0; | |
| 198 | |
| 199 web_view_scheduler_->enableVirtualTime(); | |
| 200 | |
| 201 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 202 BLINK_FROM_HERE, | |
| 203 new VirtualTimeRecorderTask(clock_.get(), | |
| 204 web_frame_scheduler_->timerTaskRunner(), | |
| 205 &real_times, &virtual_times_ms), | |
| 206 2.0); | |
| 207 | |
| 208 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 209 BLINK_FROM_HERE, | |
| 210 new VirtualTimeRecorderTask(clock_.get(), | |
| 211 web_frame_scheduler_->timerTaskRunner(), | |
| 212 &real_times, &virtual_times_ms), | |
| 213 20.0); | |
| 214 | |
| 215 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 216 BLINK_FROM_HERE, | |
| 217 new VirtualTimeRecorderTask(clock_.get(), | |
| 218 web_frame_scheduler_->timerTaskRunner(), | |
| 219 &real_times, &virtual_times_ms), | |
| 220 200.0); | |
| 221 | |
| 222 mock_task_runner_->RunUntilIdle(); | |
| 223 | |
| 224 EXPECT_THAT(real_times, ElementsAre(initial_real_time, | |
| 225 initial_real_time, initial_real_time)); | |
| 226 EXPECT_THAT(virtual_times_ms, | |
| 227 ElementsAre(initial_virtual_time_ms + 2, | |
| 228 initial_virtual_time_ms + 20, | |
| 229 initial_virtual_time_ms + 200)); | |
| 230 } | |
| 231 | |
| 232 TEST_F(WebViewSchedulerImplTest, VirtualTime_LoadingTaskFastForwarding) { | |
| 233 std::vector<base::TimeTicks> real_times; | |
| 234 std::vector<size_t> virtual_times_ms; | |
| 235 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); | |
| 236 size_t initial_virtual_time_ms = | |
| 237 web_frame_scheduler_->timerTaskRunner() | |
| 238 ->monotonicallyIncreasingVirtualTimeSeconds() * | |
| 239 1000.0; | |
| 240 | |
| 241 web_view_scheduler_->enableVirtualTime(); | |
| 242 | |
| 243 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | |
| 244 BLINK_FROM_HERE, | |
| 245 new VirtualTimeRecorderTask(clock_.get(), | |
| 246 web_frame_scheduler_->loadingTaskRunner(), | |
| 247 &real_times, &virtual_times_ms), | |
| 248 2.0); | |
| 249 | |
| 250 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | |
| 251 BLINK_FROM_HERE, | |
| 252 new VirtualTimeRecorderTask(clock_.get(), | |
| 253 web_frame_scheduler_->loadingTaskRunner(), | |
| 254 &real_times, &virtual_times_ms), | |
| 255 20.0); | |
| 256 | |
| 257 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | |
| 258 BLINK_FROM_HERE, | |
| 259 new VirtualTimeRecorderTask(clock_.get(), | |
| 260 web_frame_scheduler_->loadingTaskRunner(), | |
| 261 &real_times, &virtual_times_ms), | |
| 262 200.0); | |
| 263 | |
| 264 mock_task_runner_->RunUntilIdle(); | |
| 265 | |
| 266 EXPECT_THAT(real_times, ElementsAre(initial_real_time, | |
| 267 initial_real_time, initial_real_time)); | |
| 268 EXPECT_THAT(virtual_times_ms, | |
| 269 ElementsAre(initial_virtual_time_ms + 2, | |
| 270 initial_virtual_time_ms + 20, | |
| 271 initial_virtual_time_ms + 200)); | |
| 272 } | |
| 273 | |
| 274 TEST_F(WebViewSchedulerImplTest, | |
| 275 RepeatingTimer_PageInBackground_MeansNothingForVirtualTime) { | |
| 276 web_view_scheduler_->enableVirtualTime(); | |
| 277 web_view_scheduler_->setPageVisible(false); | |
| 278 base::TimeTicks initial_real_time = scheduler_->tick_clock()->NowTicks(); | |
| 279 | |
| 280 int run_count = 0; | |
| 281 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 282 BLINK_FROM_HERE, | |
| 283 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | |
| 284 1.0); | |
| 285 | |
| 286 mock_task_runner_->RunTasksWhile(mock_task_runner_->TaskRunCountBelow(2000)); | |
| 287 // Virtual time means page visibility is ignored. | |
| 288 EXPECT_EQ(1999, run_count); | |
| 289 | |
| 290 // The global tick clock has not moved, yet we ran a large number of "delayed" | |
| 291 // tasks despite calling setPageVisible(false). | |
| 292 EXPECT_EQ(initial_real_time, scheduler_->tick_clock()->NowTicks()); | |
| 293 } | |
| 294 | |
| 295 namespace { | |
| 296 class RunOrderTask : public blink::WebTaskRunner::Task { | |
| 297 public: | |
| 298 RunOrderTask(int index, std::vector<int>* out_run_order) | |
| 299 : index_(index), | |
| 300 out_run_order_(out_run_order) {} | |
| 301 | |
| 302 ~RunOrderTask() override {} | |
| 303 | |
| 304 void run() override { | |
| 305 out_run_order_->push_back(index_); | |
| 306 } | |
| 307 | |
| 308 private: | |
| 309 int index_; | |
| 310 std::vector<int>* out_run_order_; // NOT OWNED | |
| 311 }; | |
| 312 | |
| 313 class DelayedRunOrderTask : public blink::WebTaskRunner::Task { | |
| 314 public: | |
| 315 DelayedRunOrderTask(int index, blink::WebTaskRunner* task_runner, | |
| 316 std::vector<int>* out_run_order) | |
| 317 : index_(index), | |
| 318 task_runner_(task_runner), | |
| 319 out_run_order_(out_run_order) {} | |
| 320 | |
| 321 ~DelayedRunOrderTask() override {} | |
| 322 | |
| 323 void run() override { | |
| 324 out_run_order_->push_back(index_); | |
| 325 task_runner_->postTask( | |
| 326 BLINK_FROM_HERE, new RunOrderTask(index_ + 1, out_run_order_)); | |
| 327 } | |
| 328 | |
| 329 private: | |
| 330 int index_; | |
| 331 blink::WebTaskRunner* task_runner_; // NOT OWNED | |
| 332 std::vector<int>* out_run_order_; // NOT OWNED | |
| 333 }; | |
| 334 } | |
| 335 | |
| 336 TEST_F(WebViewSchedulerImplTest, VirtualTime_NotAllowedToAdvance) { | |
| 337 std::vector<int> run_order; | |
| 338 | |
| 339 web_view_scheduler_->setVirtualTimePolicy(VirtualTimePolicy::PAUSE); | |
| 340 web_view_scheduler_->enableVirtualTime(); | |
| 341 | |
| 342 web_frame_scheduler_->timerTaskRunner()->postTask( | |
| 343 BLINK_FROM_HERE, new RunOrderTask(0, &run_order)); | |
| 344 | |
| 345 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 346 BLINK_FROM_HERE, | |
| 347 new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(), | |
| 348 &run_order), | |
| 349 2.0); | |
| 350 | |
| 351 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 352 BLINK_FROM_HERE, | |
| 353 new DelayedRunOrderTask(3, web_frame_scheduler_->timerTaskRunner(), | |
| 354 &run_order), | |
| 355 4.0); | |
| 356 | |
| 357 mock_task_runner_->RunUntilIdle(); | |
| 358 | |
| 359 // Immediate tasks are allowed to run even if delayed tasks are not. | |
| 360 EXPECT_THAT(run_order, ElementsAre(0)); | |
| 361 } | |
| 362 | |
| 363 TEST_F(WebViewSchedulerImplTest, VirtualTime_AllowedToAdvance) { | |
| 364 std::vector<int> run_order; | |
| 365 | |
| 366 web_view_scheduler_->setVirtualTimePolicy(VirtualTimePolicy::ADVANCE); | |
| 367 web_view_scheduler_->enableVirtualTime(); | |
| 368 | |
| 369 web_frame_scheduler_->timerTaskRunner()->postTask( | |
| 370 BLINK_FROM_HERE, new RunOrderTask(0, &run_order)); | |
| 371 | |
| 372 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 373 BLINK_FROM_HERE, | |
| 374 new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(), | |
| 375 &run_order), | |
| 376 2.0); | |
| 377 | |
| 378 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 379 BLINK_FROM_HERE, | |
| 380 new DelayedRunOrderTask(3, web_frame_scheduler_->timerTaskRunner(), | |
| 381 &run_order), | |
| 382 4.0); | |
| 383 | |
| 384 mock_task_runner_->RunUntilIdle(); | |
| 385 | |
| 386 EXPECT_THAT(run_order, ElementsAre(0, 1, 2, 3, 4)); | |
| 387 } | |
| 388 | |
| 389 class WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling | |
| 390 : public WebViewSchedulerImplTest { | |
| 391 public: | |
| 392 WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling() {} | |
| 393 ~WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling() override {} | |
| 394 | |
| 395 bool DisableBackgroundTimerThrottling() const override { return true; } | |
| 396 }; | |
| 397 | |
| 398 TEST_F(WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling, | |
| 399 RepeatingTimer_PageInBackground) { | |
| 400 web_view_scheduler_->setPageVisible(false); | |
| 401 | |
| 402 int run_count = 0; | |
| 403 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
| 404 BLINK_FROM_HERE, | |
| 405 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | |
| 406 1.0); | |
| 407 | |
| 408 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
| 409 EXPECT_EQ(1000, run_count); | |
| 410 } | |
| 411 | |
| 412 TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) { | |
| 413 std::vector<int> run_order; | |
| 414 | |
| 415 web_view_scheduler_->setVirtualTimePolicy(VirtualTimePolicy::PAUSE); | |
| 416 web_view_scheduler_->enableVirtualTime(); | |
| 417 | |
| 418 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler = | |
| 419 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); | |
| 420 | |
| 421 web_frame_scheduler->timerTaskRunner()->postDelayedTask( | |
| 422 BLINK_FROM_HERE, new RunOrderTask(1, &run_order), 0.1); | |
| 423 | |
| 424 mock_task_runner_->RunUntilIdle(); | |
| 425 EXPECT_TRUE(run_order.empty()); | |
| 426 | |
| 427 web_view_scheduler_->setVirtualTimePolicy(VirtualTimePolicy::ADVANCE); | |
| 428 mock_task_runner_->RunUntilIdle(); | |
| 429 | |
| 430 EXPECT_THAT(run_order, ElementsAre(1)); | |
| 431 } | |
| 432 | |
| 433 namespace { | |
| 434 class DeleteWebFrameSchedulerTask : public blink::WebTaskRunner::Task { | |
| 435 public: | |
| 436 explicit DeleteWebFrameSchedulerTask(WebViewSchedulerImpl* web_view_scheduler) | |
| 437 : web_frame_scheduler_( | |
| 438 web_view_scheduler->createWebFrameSchedulerImpl(nullptr)) {} | |
| 439 | |
| 440 ~DeleteWebFrameSchedulerTask() override {} | |
| 441 | |
| 442 void run() override { web_frame_scheduler_.reset(); } | |
| 443 | |
| 444 WebFrameSchedulerImpl* web_frame_scheduler() const { | |
| 445 return web_frame_scheduler_.get(); | |
| 446 } | |
| 447 | |
| 448 private: | |
| 449 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler_; | |
| 450 }; | |
| 451 | |
| 452 class DeleteWebViewSchedulerTask : public blink::WebTaskRunner::Task { | |
| 453 public: | |
| 454 explicit DeleteWebViewSchedulerTask(WebViewSchedulerImpl* web_view_scheduler) | |
| 455 : web_view_scheduler_(web_view_scheduler) {} | |
| 456 | |
| 457 ~DeleteWebViewSchedulerTask() override {} | |
| 458 | |
| 459 void run() override { web_view_scheduler_.reset(); } | |
| 460 | |
| 461 private: | |
| 462 std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler_; | |
| 463 }; | |
| 464 } // namespace | |
| 465 | |
| 466 TEST_F(WebViewSchedulerImplTest, DeleteWebFrameSchedulers_InTask) { | |
| 467 for (int i = 0; i < 10; i++) { | |
| 468 DeleteWebFrameSchedulerTask* task = | |
| 469 new DeleteWebFrameSchedulerTask(web_view_scheduler_.get()); | |
| 470 task->web_frame_scheduler()->timerTaskRunner()->postDelayedTask( | |
| 471 BLINK_FROM_HERE, task, 1.0); | |
| 472 } | |
| 473 mock_task_runner_->RunUntilIdle(); | |
| 474 } | |
| 475 | |
| 476 TEST_F(WebViewSchedulerImplTest, DeleteWebViewScheduler_InTask) { | |
| 477 web_frame_scheduler_->timerTaskRunner()->postTask( | |
| 478 BLINK_FROM_HERE, | |
| 479 new DeleteWebViewSchedulerTask(web_view_scheduler_.release())); | |
| 480 mock_task_runner_->RunUntilIdle(); | |
| 481 } | |
| 482 | |
| 483 TEST_F(WebViewSchedulerImplTest, DeleteThrottledQueue_InTask) { | |
| 484 web_view_scheduler_->setPageVisible(false); | |
| 485 | |
| 486 DeleteWebFrameSchedulerTask* delete_frame_task = | |
| 487 new DeleteWebFrameSchedulerTask(web_view_scheduler_.get()); | |
| 488 blink::WebTaskRunner* timer_task_runner = | |
| 489 delete_frame_task->web_frame_scheduler()->timerTaskRunner(); | |
| 490 | |
| 491 int run_count = 0; | |
| 492 timer_task_runner->postDelayedTask( | |
| 493 BLINK_FROM_HERE, new RepeatingTask(timer_task_runner, &run_count), 1.0); | |
| 494 | |
| 495 // Note this will run at time t = 10s since we start at time t = 5000us, and | |
| 496 // it will prevent further tasks from running (i.e. the RepeatingTask) by | |
| 497 // deleting the WebFrameScheduler. | |
| 498 timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task, | |
| 499 9990.0); | |
| 500 | |
| 501 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100)); | |
| 502 EXPECT_EQ(10, run_count); | |
| 503 } | |
| 504 | |
| 505 TEST_F(WebViewSchedulerImplTest, VirtualTimePolicy_DETERMINISTIC_LOADING) { | |
| 506 web_view_scheduler_->setVirtualTimePolicy( | |
| 507 VirtualTimePolicy::DETERMINISTIC_LOADING); | |
| 508 // Initially virtual time is not allowed to advance until we have seen at | |
| 509 // least one load. | |
| 510 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 511 | |
| 512 web_view_scheduler_->DidStartLoading(1u); | |
| 513 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 514 | |
| 515 web_view_scheduler_->DidStartLoading(2u); | |
| 516 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 517 | |
| 518 web_view_scheduler_->DidStopLoading(2u); | |
| 519 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 520 | |
| 521 web_view_scheduler_->DidStartLoading(3u); | |
| 522 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 523 | |
| 524 web_view_scheduler_->DidStopLoading(1u); | |
| 525 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 526 | |
| 527 web_view_scheduler_->DidStopLoading(3u); | |
| 528 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 529 | |
| 530 web_view_scheduler_->DidStartLoading(4u); | |
| 531 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 532 | |
| 533 web_view_scheduler_->DidStopLoading(4u); | |
| 534 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 535 } | |
| 536 | |
| 537 TEST_F(WebViewSchedulerImplTest, RedundantDidStopLoadingCallsAreHarmless) { | |
| 538 web_view_scheduler_->setVirtualTimePolicy( | |
| 539 VirtualTimePolicy::DETERMINISTIC_LOADING); | |
| 540 | |
| 541 web_view_scheduler_->DidStartLoading(1u); | |
| 542 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 543 | |
| 544 web_view_scheduler_->DidStopLoading(1u); | |
| 545 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 546 | |
| 547 web_view_scheduler_->DidStopLoading(1u); | |
| 548 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 549 | |
| 550 web_view_scheduler_->DidStopLoading(1u); | |
| 551 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 552 | |
| 553 web_view_scheduler_->DidStartLoading(2u); | |
| 554 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 555 | |
| 556 web_view_scheduler_->DidStopLoading(2u); | |
| 557 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 558 } | |
| 559 | |
| 560 TEST_F(WebViewSchedulerImplTest, BackgroundParser_DETERMINISTIC_LOADING) { | |
| 561 web_view_scheduler_->setVirtualTimePolicy( | |
| 562 VirtualTimePolicy::DETERMINISTIC_LOADING); | |
| 563 // Initially virtual time is not allowed to advance until we have seen at | |
| 564 // least one load. | |
| 565 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 566 | |
| 567 web_view_scheduler_->IncrementBackgroundParserCount(); | |
| 568 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 569 | |
| 570 web_view_scheduler_->DidStartLoading(1u); | |
| 571 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 572 | |
| 573 web_view_scheduler_->DidStopLoading(1u); | |
| 574 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 575 | |
| 576 web_view_scheduler_->IncrementBackgroundParserCount(); | |
| 577 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 578 | |
| 579 web_view_scheduler_->DecrementBackgroundParserCount(); | |
| 580 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 581 | |
| 582 web_view_scheduler_->DecrementBackgroundParserCount(); | |
| 583 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 584 | |
| 585 web_view_scheduler_->IncrementBackgroundParserCount(); | |
| 586 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 587 | |
| 588 web_view_scheduler_->DecrementBackgroundParserCount(); | |
| 589 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
| 590 } | |
| 591 | |
| 592 } // namespace scheduler | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2118903002:
scheduler: Move the Blink scheduler into Blink (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master