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" |
11 #include "components/scheduler/base/test_time_source.h" | 11 #include "components/scheduler/base/test_time_source.h" |
12 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h" | 12 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h" |
13 #include "components/scheduler/renderer/renderer_scheduler_impl.h" | 13 #include "components/scheduler/renderer/renderer_scheduler_impl.h" |
14 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" | 14 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 #include "third_party/WebKit/public/platform/WebTaskRunner.h" | |
17 #include "third_party/WebKit/public/platform/WebTraceLocation.h" | |
18 | 16 |
19 namespace scheduler { | 17 namespace scheduler { |
20 | 18 |
21 class WebViewSchedulerImplTest : public testing::Test { | 19 class WebViewSchedulerImplTest : public testing::Test { |
22 public: | 20 public: |
23 WebViewSchedulerImplTest() {} | 21 WebViewSchedulerImplTest() {} |
24 ~WebViewSchedulerImplTest() override {} | 22 ~WebViewSchedulerImplTest() override {} |
25 | 23 |
26 void SetUp() override { | 24 void SetUp() override { |
27 clock_.reset(new base::SimpleTestTickClock()); | 25 clock_.reset(new base::SimpleTestTickClock()); |
28 clock_->Advance(base::TimeDelta::FromMicroseconds(5000)); | 26 clock_->Advance(base::TimeDelta::FromMicroseconds(5000)); |
29 mock_task_runner_ = | 27 mock_task_runner_ = make_scoped_refptr( |
30 make_scoped_refptr(new cc::OrderedSimpleTaskRunner(clock_.get(), true)); | 28 new cc::OrderedSimpleTaskRunner(clock_.get(), false)); |
31 delagate_ = SchedulerTqmDelegateForTest::Create( | 29 main_task_runner_ = SchedulerTqmDelegateForTest::Create( |
32 mock_task_runner_, make_scoped_ptr(new TestTimeSource(clock_.get()))); | 30 mock_task_runner_, make_scoped_ptr(new TestTimeSource(clock_.get()))); |
33 scheduler_.reset(new RendererSchedulerImpl(delagate_)); | 31 scheduler_.reset(new RendererSchedulerImpl(main_task_runner_)); |
34 web_view_scheduler_.reset( | 32 web_view_scheduler_.reset( |
35 new WebViewSchedulerImpl(nullptr, scheduler_.get())); | 33 new WebViewSchedulerImpl(nullptr, scheduler_.get())); |
36 web_frame_scheduler_ = web_view_scheduler_->createWebFrameSchedulerImpl(); | |
37 } | 34 } |
38 | 35 |
39 void TearDown() override { | 36 void TearDown() override { scheduler_->Shutdown(); } |
40 web_frame_scheduler_.reset(); | |
41 web_view_scheduler_.reset(); | |
42 scheduler_->Shutdown(); | |
43 scheduler_.reset(); | |
44 } | |
45 | 37 |
46 scoped_ptr<base::SimpleTestTickClock> clock_; | 38 scoped_ptr<base::SimpleTestTickClock> clock_; |
47 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; | 39 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; |
48 scoped_refptr<SchedulerTqmDelegate> delagate_; | 40 scoped_refptr<SchedulerTqmDelegate> main_task_runner_; |
49 scoped_ptr<RendererSchedulerImpl> scheduler_; | 41 scoped_ptr<RendererSchedulerImpl> scheduler_; |
50 scoped_ptr<WebViewSchedulerImpl> web_view_scheduler_; | 42 scoped_ptr<WebViewSchedulerImpl> web_view_scheduler_; |
51 scoped_ptr<WebFrameSchedulerImpl> web_frame_scheduler_; | |
52 }; | 43 }; |
53 | 44 |
54 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersBefore) { | 45 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersBefore) { |
55 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame1( | 46 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame1( |
56 web_view_scheduler_->createFrameScheduler()); | 47 web_view_scheduler_->createFrameScheduler()); |
57 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame2( | 48 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame2( |
58 web_view_scheduler_->createFrameScheduler()); | 49 web_view_scheduler_->createFrameScheduler()); |
59 } | 50 } |
60 | 51 |
61 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersAfter) { | 52 TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersAfter) { |
62 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame1( | 53 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame1( |
63 web_view_scheduler_->createFrameScheduler()); | 54 web_view_scheduler_->createFrameScheduler()); |
64 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame2( | 55 blink::WebPassOwnPtr<blink::WebFrameScheduler> frame2( |
65 web_view_scheduler_->createFrameScheduler()); | 56 web_view_scheduler_->createFrameScheduler()); |
66 web_view_scheduler_.reset(); | 57 web_view_scheduler_.reset(); |
67 } | 58 } |
68 | 59 |
69 namespace { | |
70 class RepeatingTask : public blink::WebTaskRunner::Task { | |
71 public: | |
72 RepeatingTask(blink::WebTaskRunner* web_task_runner, int* run_count) | |
73 : web_task_runner_(web_task_runner), run_count_(run_count) {} | |
74 | |
75 ~RepeatingTask() override {} | |
76 | |
77 void run() override { | |
78 (*run_count_)++; | |
79 web_task_runner_->postDelayedTask( | |
80 BLINK_FROM_HERE, new RepeatingTask(web_task_runner_, run_count_), 1.0); | |
81 } | |
82 | |
83 private: | |
84 blink::WebTaskRunner* web_task_runner_; // NOT OWNED | |
85 int* run_count_; // NOT OWNED | |
86 }; | |
87 } // namespace | |
88 | |
89 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInForeground) { | |
90 web_view_scheduler_->setPageInBackground(false); | |
91 | |
92 int run_count = 0; | |
93 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
94 BLINK_FROM_HERE, | |
95 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | |
96 1.0); | |
97 | |
98 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
99 EXPECT_EQ(1000, run_count); | |
100 } | |
101 | |
102 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInBackground) { | |
103 web_view_scheduler_->setPageInBackground(true); | |
104 | |
105 int run_count = 0; | |
106 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
107 BLINK_FROM_HERE, | |
108 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count), | |
109 1.0); | |
110 | |
111 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
112 EXPECT_EQ(1, run_count); | |
113 } | |
114 | |
115 TEST_F(WebViewSchedulerImplTest, RepeatingLoadingTask_PageInBackground) { | |
116 web_view_scheduler_->setPageInBackground(true); | |
117 | |
118 int run_count = 0; | |
119 web_frame_scheduler_->loadingTaskRunner()->postDelayedTask( | |
120 BLINK_FROM_HERE, | |
121 new RepeatingTask(web_frame_scheduler_->loadingTaskRunner(), &run_count), | |
122 1.0); | |
123 | |
124 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
125 EXPECT_EQ(1000, run_count); // Loading tasks should not be throttled | |
126 } | |
127 | |
128 TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) { | |
129 scoped_ptr<WebViewSchedulerImpl> web_view_scheduler2( | |
130 new WebViewSchedulerImpl(nullptr, scheduler_.get())); | |
131 scoped_ptr<WebFrameSchedulerImpl> web_frame_scheduler2 = | |
132 web_view_scheduler2->createWebFrameSchedulerImpl(); | |
133 | |
134 web_view_scheduler_->setPageInBackground(false); | |
135 web_view_scheduler2->setPageInBackground(true); | |
136 | |
137 int run_count1 = 0; | |
138 int run_count2 = 0; | |
139 web_frame_scheduler_->timerTaskRunner()->postDelayedTask( | |
140 BLINK_FROM_HERE, | |
141 new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1), | |
142 1.0); | |
143 web_frame_scheduler2->timerTaskRunner()->postDelayedTask( | |
144 BLINK_FROM_HERE, | |
145 new RepeatingTask(web_frame_scheduler2->timerTaskRunner(), &run_count2), | |
146 1.0); | |
147 | |
148 mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1)); | |
149 EXPECT_EQ(1000, run_count1); | |
150 EXPECT_EQ(1, run_count2); | |
151 } | |
152 | |
153 } // namespace scheduler | 60 } // namespace scheduler |
OLD | NEW |