OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/child/scheduler_helper.h" | 5 #include "components/scheduler/child/scheduler_helper.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "cc/test/ordered_simple_task_runner.h" | 8 #include "cc/test/ordered_simple_task_runner.h" |
9 #include "cc/test/test_now_source.h" | 9 #include "cc/test/test_now_source.h" |
10 #include "components/scheduler/child/nestable_task_runner_for_test.h" | 10 #include "components/scheduler/child/nestable_task_runner_for_test.h" |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
123 TASK_QUEUE_COUNT, | 123 TASK_QUEUE_COUNT, |
124 required_quiescence_duration_before_long_idle_period) {} | 124 required_quiescence_duration_before_long_idle_period) {} |
125 | 125 |
126 ~SchedulerHelperForTest() override {} | 126 ~SchedulerHelperForTest() override {} |
127 | 127 |
128 // SchedulerHelperDelegate implementation: | 128 // SchedulerHelperDelegate implementation: |
129 MOCK_METHOD2(CanEnterLongIdlePeriod, | 129 MOCK_METHOD2(CanEnterLongIdlePeriod, |
130 bool(base::TimeTicks now, | 130 bool(base::TimeTicks now, |
131 base::TimeDelta* next_long_idle_period_delay_out)); | 131 base::TimeDelta* next_long_idle_period_delay_out)); |
132 | 132 |
133 MOCK_METHOD0(IsNotQuiescent, void()); | 133 void IsNotQuiescent() override {} |
134 }; | 134 }; |
135 | 135 |
136 class BaseSchedulerHelperTest : public testing::Test { | 136 class BaseSchedulerHelperTest : public testing::Test { |
137 public: | 137 public: |
138 BaseSchedulerHelperTest( | 138 BaseSchedulerHelperTest( |
139 base::MessageLoop* message_loop, | 139 base::MessageLoop* message_loop, |
140 base::TimeDelta required_quiescence_duration_before_long_idle_period) | 140 base::TimeDelta required_quiescence_duration_before_long_idle_period) |
141 : clock_(cc::TestNowSource::Create(5000)), | 141 : clock_(cc::TestNowSource::Create(5000)), |
142 mock_task_runner_(message_loop | 142 mock_task_runner_(message_loop |
143 ? nullptr | 143 ? nullptr |
144 : new cc::OrderedSimpleTaskRunner(clock_, false)), | 144 : new cc::OrderedSimpleTaskRunner(clock_, false)), |
145 message_loop_(message_loop), | 145 message_loop_(message_loop), |
146 nestable_task_runner_( | 146 nestable_task_runner_( |
147 CreateNestableSingleThreadTaskRunner(message_loop, | 147 CreateNestableSingleThreadTaskRunner(message_loop, |
148 mock_task_runner_)), | 148 mock_task_runner_)), |
149 scheduler_helper_(new SchedulerHelperForTest( | 149 scheduler_helper_(new SchedulerHelperForTest( |
150 nestable_task_runner_, | 150 nestable_task_runner_, |
151 required_quiescence_duration_before_long_idle_period)), | 151 required_quiescence_duration_before_long_idle_period)), |
152 default_task_runner_(scheduler_helper_->DefaultTaskRunner()), | 152 default_task_runner_(scheduler_helper_->DefaultTaskRunner()), |
153 idle_task_runner_(scheduler_helper_->IdleTaskRunner()) { | 153 idle_task_runner_(scheduler_helper_->IdleTaskRunner()), |
154 control_task_runner_(scheduler_helper_->ControlTaskRunner()), | |
155 shutdown_task_runner_(scheduler_helper_->ShutdownTaskRunner()) { | |
154 scheduler_helper_->SetTimeSourceForTesting( | 156 scheduler_helper_->SetTimeSourceForTesting( |
155 make_scoped_ptr(new TestTimeSource(clock_))); | 157 make_scoped_ptr(new TestTimeSource(clock_))); |
156 scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting( | 158 scheduler_helper_->GetTaskQueueManagerForTesting()->SetTimeSourceForTesting( |
157 make_scoped_ptr(new TestTimeSource(clock_))); | 159 make_scoped_ptr(new TestTimeSource(clock_))); |
158 } | 160 } |
159 | 161 |
160 ~BaseSchedulerHelperTest() override {} | 162 ~BaseSchedulerHelperTest() override {} |
161 | 163 |
162 void TearDown() override { | 164 void TearDown() override { |
163 DCHECK(!mock_task_runner_.get() || !message_loop_.get()); | 165 DCHECK(!mock_task_runner_.get() || !message_loop_.get()); |
(...skipping 14 matching lines...) Expand all Loading... | |
178 mock_task_runner_->RunUntilIdle(); | 180 mock_task_runner_->RunUntilIdle(); |
179 else | 181 else |
180 message_loop_->RunUntilIdle(); | 182 message_loop_->RunUntilIdle(); |
181 } | 183 } |
182 | 184 |
183 // Helper for posting several tasks of specific types. |task_descriptor| is a | 185 // Helper for posting several tasks of specific types. |task_descriptor| is a |
184 // string with space delimited task identifiers. The first letter of each | 186 // string with space delimited task identifiers. The first letter of each |
185 // task identifier specifies the task type: | 187 // task identifier specifies the task type: |
186 // - 'D': Default task | 188 // - 'D': Default task |
187 // - 'I': Idle task | 189 // - 'I': Idle task |
190 // - 'S': Shutdown task | |
191 // - 'T': conTrol task (to avoid confusion with compositor tasks) | |
188 void PostTestTasks(std::vector<std::string>* run_order, | 192 void PostTestTasks(std::vector<std::string>* run_order, |
189 const std::string& task_descriptor) { | 193 const std::string& task_descriptor) { |
190 std::istringstream stream(task_descriptor); | 194 std::istringstream stream(task_descriptor); |
191 while (!stream.eof()) { | 195 while (!stream.eof()) { |
192 std::string task; | 196 std::string task; |
193 stream >> task; | 197 stream >> task; |
194 switch (task[0]) { | 198 switch (task[0]) { |
195 case 'D': | 199 case 'D': |
196 default_task_runner_->PostTask( | 200 default_task_runner_->PostTask( |
197 FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task)); | 201 FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task)); |
198 break; | 202 break; |
199 case 'I': | 203 case 'I': |
200 idle_task_runner_->PostIdleTask( | 204 idle_task_runner_->PostIdleTask( |
201 FROM_HERE, | 205 FROM_HERE, |
202 base::Bind(&AppendToVectorIdleTestTask, run_order, task)); | 206 base::Bind(&AppendToVectorIdleTestTask, run_order, task)); |
203 break; | 207 break; |
208 case 'S': | |
209 shutdown_task_runner_->PostTask( | |
210 FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task)); | |
211 break; | |
212 case 'T': | |
213 control_task_runner_->PostTask( | |
214 FROM_HERE, base::Bind(&AppendToVectorTestTask, run_order, task)); | |
215 break; | |
204 default: | 216 default: |
205 NOTREACHED(); | 217 NOTREACHED(); |
206 } | 218 } |
207 } | 219 } |
208 } | 220 } |
209 | 221 |
210 protected: | 222 protected: |
211 static base::TimeDelta maximum_idle_period_duration() { | 223 static base::TimeDelta maximum_idle_period_duration() { |
212 return base::TimeDelta::FromMilliseconds( | 224 return base::TimeDelta::FromMilliseconds( |
213 SchedulerHelper::kMaximumIdlePeriodMillis); | 225 SchedulerHelper::kMaximumIdlePeriodMillis); |
214 } | 226 } |
215 | 227 |
216 base::TimeTicks CurrentIdleTaskDeadlineForTesting() { | 228 base::TimeTicks CurrentIdleTaskDeadlineForTesting() { |
217 base::TimeTicks deadline; | 229 base::TimeTicks deadline; |
218 scheduler_helper_->CurrentIdleTaskDeadlineCallback(&deadline); | 230 scheduler_helper_->CurrentIdleTaskDeadlineCallback(&deadline); |
219 return deadline; | 231 return deadline; |
220 } | 232 } |
221 | 233 |
222 scoped_refptr<cc::TestNowSource> clock_; | 234 scoped_refptr<cc::TestNowSource> clock_; |
223 // Only one of mock_task_runner_ or message_loop_ will be set. | 235 // Only one of mock_task_runner_ or message_loop_ will be set. |
224 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; | 236 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_; |
225 scoped_ptr<base::MessageLoop> message_loop_; | 237 scoped_ptr<base::MessageLoop> message_loop_; |
226 | 238 |
227 scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_; | 239 scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_; |
228 scoped_ptr<SchedulerHelperForTest> scheduler_helper_; | 240 scoped_ptr<SchedulerHelperForTest> scheduler_helper_; |
229 scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_; | 241 scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_; |
230 scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_; | 242 scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_; |
243 scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_; | |
244 scoped_refptr<base::SingleThreadTaskRunner> shutdown_task_runner_; | |
231 | 245 |
232 DISALLOW_COPY_AND_ASSIGN(BaseSchedulerHelperTest); | 246 DISALLOW_COPY_AND_ASSIGN(BaseSchedulerHelperTest); |
233 }; | 247 }; |
234 | 248 |
235 class SchedulerHelperTest : public BaseSchedulerHelperTest { | 249 class SchedulerHelperTest : public BaseSchedulerHelperTest { |
236 public: | 250 public: |
237 SchedulerHelperTest() : BaseSchedulerHelperTest(nullptr, base::TimeDelta()) {} | 251 SchedulerHelperTest() : BaseSchedulerHelperTest(nullptr, base::TimeDelta()) {} |
238 | 252 |
239 ~SchedulerHelperTest() override {} | 253 ~SchedulerHelperTest() override {} |
240 | 254 |
(...skipping 664 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
905 base::TimeTicks expected_deadline = | 919 base::TimeTicks expected_deadline = |
906 clock_->Now() + | 920 clock_->Now() + |
907 base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs); | 921 base::TimeDelta::FromMilliseconds(kQuiescenceDelayMs + kLongIdlePeriodMs); |
908 default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask)); | 922 default_task_runner_->PostTask(FROM_HERE, base::Bind(NullTask)); |
909 RunUntilIdle(); | 923 RunUntilIdle(); |
910 | 924 |
911 EXPECT_EQ(1, run_count); | 925 EXPECT_EQ(1, run_count); |
912 EXPECT_EQ(expected_deadline, deadline_in_task); | 926 EXPECT_EQ(expected_deadline, deadline_in_task); |
913 } | 927 } |
914 | 928 |
929 TEST_F(SchedulerHelperTest, | |
930 TestPreShutdown_BlocksAllButControlAndShutdownTasks) { | |
931 std::vector<std::string> run_order; | |
932 PostTestTasks(&run_order, "D1 I1 T1"); | |
Sami
2015/04/28 11:52:46
I noticed we weren't actually posting a shutdown t
| |
933 | |
934 scheduler_helper_->PreShutdown(); | |
935 | |
936 RunUntilIdle(); | |
937 EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1"))); | |
938 } | |
939 | |
940 TEST_F(SchedulerHelperTest, TestPreShutdown_BlocksFutureLongIdleTasks) { | |
941 int run_count = 0; | |
942 | |
943 EXPECT_CALL(*scheduler_helper_, CanEnterLongIdlePeriod(_, _)) | |
944 .Times(2) | |
945 .WillRepeatedly(Return(true)); | |
946 | |
947 max_idle_task_reposts = 3; | |
948 idle_task_runner_->PostIdleTask( | |
949 FROM_HERE, | |
950 base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count)); | |
951 | |
952 scheduler_helper_->EnableLongIdlePeriod(); | |
953 RunUntilIdle(); | |
954 EXPECT_EQ(1, run_count); // Should only run once per idle period. | |
955 | |
956 // Advance time to start of next long idle period and check task reposted task | |
957 // does not get run (it should be blocked by PreShutdown). | |
958 scheduler_helper_->PreShutdown(); | |
959 clock_->AdvanceNow(maximum_idle_period_duration()); | |
960 RunUntilIdle(); | |
961 EXPECT_EQ(1, run_count); | |
962 | |
963 // Must destroy all tasks posted to scheduler_helper_ before run_count goes | |
964 // out of scope. | |
965 scheduler_helper_.reset(); | |
966 } | |
967 | |
915 } // namespace scheduler | 968 } // namespace scheduler |
OLD | NEW |