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 <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" |
11 #include "base/test/simple_test_tick_clock.h" | 11 #include "base/test/simple_test_tick_clock.h" |
12 #include "cc/test/ordered_simple_task_runner.h" | 12 #include "cc/test/ordered_simple_task_runner.h" |
13 #include "components/scheduler/base/test_time_source.h" | 13 #include "components/scheduler/base/test_time_source.h" |
14 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h" | 14 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h" |
15 #include "components/scheduler/renderer/renderer_scheduler_impl.h" | 15 #include "components/scheduler/renderer/renderer_scheduler_impl.h" |
16 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" | 16 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" |
17 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "testing/gmock/include/gmock/gmock.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
19 #include "third_party/WebKit/public/platform/WebTaskRunner.h" | 19 #include "third_party/WebKit/public/platform/WebTaskRunner.h" |
20 #include "third_party/WebKit/public/platform/WebTraceLocation.h" | 20 #include "third_party/WebKit/public/platform/WebTraceLocation.h" |
21 | 21 |
22 using testing::ElementsAre; | 22 using testing::ElementsAre; |
23 using VirtualTimePolicy = blink::WebViewScheduler::VirtualTimePolicy; | |
23 | 24 |
24 namespace scheduler { | 25 namespace scheduler { |
25 | 26 |
26 class WebViewSchedulerImplTest : public testing::Test { | 27 class WebViewSchedulerImplTest : public testing::Test { |
27 public: | 28 public: |
28 WebViewSchedulerImplTest() {} | 29 WebViewSchedulerImplTest() {} |
29 ~WebViewSchedulerImplTest() override {} | 30 ~WebViewSchedulerImplTest() override {} |
30 | 31 |
31 void SetUp() override { | 32 void SetUp() override { |
32 clock_.reset(new base::SimpleTestTickClock()); | 33 clock_.reset(new base::SimpleTestTickClock()); |
(...skipping 295 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
328 private: | 329 private: |
329 int index_; | 330 int index_; |
330 blink::WebTaskRunner* task_runner_; // NOT OWNED | 331 blink::WebTaskRunner* task_runner_; // NOT OWNED |
331 std::vector<int>* out_run_order_; // NOT OWNED | 332 std::vector<int>* out_run_order_; // NOT OWNED |
332 }; | 333 }; |
333 } | 334 } |
334 | 335 |
335 TEST_F(WebViewSchedulerImplTest, VirtualTime_NotAllowedToAdvance) { | 336 TEST_F(WebViewSchedulerImplTest, VirtualTime_NotAllowedToAdvance) { |
336 std::vector<int> run_order; | 337 std::vector<int> run_order; |
337 | 338 |
338 web_view_scheduler_->setAllowVirtualTimeToAdvance(false); | 339 web_view_scheduler_->setVirtualTimePolicy( |
340 blink::WebViewScheduler::VirtualTimePolicy::PAUSE); | |
Sami
2016/07/05 10:26:55
nit: no need for the namespace prefix with the 'us
alex clarke (OOO till 29th)
2016/07/05 13:08:13
Done.
| |
339 web_view_scheduler_->enableVirtualTime(); | 341 web_view_scheduler_->enableVirtualTime(); |
340 | 342 |
341 web_frame_scheduler_->timerTaskRunner()->postTask( | 343 web_frame_scheduler_->timerTaskRunner()->postTask( |
342 BLINK_FROM_HERE, new RunOrderTask(0, &run_order)); | 344 BLINK_FROM_HERE, new RunOrderTask(0, &run_order)); |
343 | 345 |
344 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 346 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
345 BLINK_FROM_HERE, | 347 BLINK_FROM_HERE, |
346 new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(), | 348 new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(), |
347 &run_order), | 349 &run_order), |
348 2.0); | 350 2.0); |
349 | 351 |
350 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 352 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
351 BLINK_FROM_HERE, | 353 BLINK_FROM_HERE, |
352 new DelayedRunOrderTask(3, web_frame_scheduler_->timerTaskRunner(), | 354 new DelayedRunOrderTask(3, web_frame_scheduler_->timerTaskRunner(), |
353 &run_order), | 355 &run_order), |
354 4.0); | 356 4.0); |
355 | 357 |
356 mock_task_runner_->RunUntilIdle(); | 358 mock_task_runner_->RunUntilIdle(); |
357 | 359 |
358 // Immediate tasks are allowed to run even if delayed tasks are not. | 360 // Immediate tasks are allowed to run even if delayed tasks are not. |
359 EXPECT_THAT(run_order, ElementsAre(0)); | 361 EXPECT_THAT(run_order, ElementsAre(0)); |
360 } | 362 } |
361 | 363 |
362 TEST_F(WebViewSchedulerImplTest, VirtualTime_AllowedToAdvance) { | 364 TEST_F(WebViewSchedulerImplTest, VirtualTime_AllowedToAdvance) { |
363 std::vector<int> run_order; | 365 std::vector<int> run_order; |
364 | 366 |
365 web_view_scheduler_->setAllowVirtualTimeToAdvance(true); | 367 web_view_scheduler_->setVirtualTimePolicy( |
368 blink::WebViewScheduler::VirtualTimePolicy::ADVANCE); | |
366 web_view_scheduler_->enableVirtualTime(); | 369 web_view_scheduler_->enableVirtualTime(); |
367 | 370 |
368 web_frame_scheduler_->timerTaskRunner()->postTask( | 371 web_frame_scheduler_->timerTaskRunner()->postTask( |
369 BLINK_FROM_HERE, new RunOrderTask(0, &run_order)); | 372 BLINK_FROM_HERE, new RunOrderTask(0, &run_order)); |
370 | 373 |
371 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | 374 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( |
372 BLINK_FROM_HERE, | 375 BLINK_FROM_HERE, |
373 new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(), | 376 new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(), |
374 &run_order), | 377 &run_order), |
375 2.0); | 378 2.0); |
(...skipping 28 matching lines...) Expand all Loading... | |
404 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | 407 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), |
405 1.0); | 408 1.0); |
406 | 409 |
407 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | 410 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); |
408 EXPECT_EQ(1000, run_count); | 411 EXPECT_EQ(1000, run_count); |
409 } | 412 } |
410 | 413 |
411 TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) { | 414 TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) { |
412 std::vector<int> run_order; | 415 std::vector<int> run_order; |
413 | 416 |
414 web_view_scheduler_->setAllowVirtualTimeToAdvance(false); | 417 web_view_scheduler_->setVirtualTimePolicy(VirtualTimePolicy::PAUSE); |
415 web_view_scheduler_->enableVirtualTime(); | 418 web_view_scheduler_->enableVirtualTime(); |
416 | 419 |
417 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler = | 420 std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler = |
418 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); | 421 web_view_scheduler_->createWebFrameSchedulerImpl(nullptr); |
419 | 422 |
420 web_frame_scheduler->timerTaskRunner()->postDelayedTask( | 423 web_frame_scheduler->timerTaskRunner()->postDelayedTask( |
421 BLINK_FROM_HERE, new RunOrderTask(1, &run_order), 0.1); | 424 BLINK_FROM_HERE, new RunOrderTask(1, &run_order), 0.1); |
422 | 425 |
423 mock_task_runner_->RunUntilIdle(); | 426 mock_task_runner_->RunUntilIdle(); |
424 EXPECT_TRUE(run_order.empty()); | 427 EXPECT_TRUE(run_order.empty()); |
425 | 428 |
426 web_view_scheduler_->setAllowVirtualTimeToAdvance(true); | 429 web_view_scheduler_->setVirtualTimePolicy(VirtualTimePolicy::ADVANCE); |
427 mock_task_runner_->RunUntilIdle(); | 430 mock_task_runner_->RunUntilIdle(); |
428 | 431 |
429 EXPECT_THAT(run_order, ElementsAre(1)); | 432 EXPECT_THAT(run_order, ElementsAre(1)); |
430 } | 433 } |
431 | 434 |
432 namespace { | 435 namespace { |
433 class DeleteWebFrameSchedulerTask : public blink::WebTaskRunner::Task { | 436 class DeleteWebFrameSchedulerTask : public blink::WebTaskRunner::Task { |
434 public: | 437 public: |
435 explicit DeleteWebFrameSchedulerTask(WebViewSchedulerImpl* web_view_scheduler) | 438 explicit DeleteWebFrameSchedulerTask(WebViewSchedulerImpl* web_view_scheduler) |
436 : web_frame_scheduler_( | 439 : web_frame_scheduler_( |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
494 // Note this will run at time t = 10s since we start at time t = 5000us, and | 497 // Note this will run at time t = 10s since we start at time t = 5000us, and |
495 // it will prevent further tasks from running (i.e. the RepeatingTask) by | 498 // it will prevent further tasks from running (i.e. the RepeatingTask) by |
496 // deleting the WebFrameScheduler. | 499 // deleting the WebFrameScheduler. |
497 timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task, | 500 timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task, |
498 9990.0); | 501 9990.0); |
499 | 502 |
500 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100)); | 503 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100)); |
501 EXPECT_EQ(10, run_count); | 504 EXPECT_EQ(10, run_count); |
502 } | 505 } |
503 | 506 |
507 TEST_F(WebViewSchedulerImplTest, | |
508 VirtualTimePolicy_PAUSE_IF_NETWORK_FETCHES_PENDING) { | |
509 web_view_scheduler_->setVirtualTimePolicy( | |
510 VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING); | |
511 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
512 | |
513 web_view_scheduler_->incrementPendingResourceLoadCount(); | |
514 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
515 | |
516 web_view_scheduler_->incrementPendingResourceLoadCount(); | |
517 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
518 | |
519 web_view_scheduler_->decrementPendingResourceLoadCount(); | |
520 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
521 | |
522 web_view_scheduler_->incrementPendingResourceLoadCount(); | |
523 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
524 | |
525 web_view_scheduler_->decrementPendingResourceLoadCount(); | |
526 EXPECT_FALSE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
527 | |
528 web_view_scheduler_->decrementPendingResourceLoadCount(); | |
529 EXPECT_TRUE(web_view_scheduler_->virtualTimeAllowedToAdvance()); | |
530 } | |
531 | |
504 } // namespace scheduler | 532 } // namespace scheduler |
OLD | NEW |