OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "content/browser/startup_task_runner.h" | 5 #include "content/browser/startup_task_runner.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
11 #include "base/run_loop.h" | 11 #include "base/run_loop.h" |
12 #include "base/task_runner.h" | 12 #include "base/task_runner.h" |
13 | 13 |
14 #include "testing/gmock/include/gmock/gmock.h" | 14 #include "testing/gmock/include/gmock/gmock.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 namespace content { | 17 namespace content { |
18 namespace { | 18 namespace { |
19 | 19 |
20 using base::Closure; | 20 using base::Closure; |
21 using testing::_; | 21 using testing::_; |
22 using testing::Assign; | 22 using testing::Assign; |
23 using testing::Invoke; | 23 using testing::Invoke; |
24 using testing::WithArg; | 24 using testing::Return; |
25 | 25 |
26 int observer_calls = 0; | 26 int observer_calls = 0; |
27 int task_count = 0; | 27 int task_count = 0; |
28 int observer_result; | 28 int observer_result; |
29 base::Closure task; | |
30 | |
31 // I couldn't get gMock's SaveArg to compile, hence had to save the argument | |
32 // this way | |
33 bool SaveTaskArg(const Closure& arg) { | |
34 task = arg; | |
35 return true; | |
36 } | |
37 | 29 |
38 void Observer(int result) { | 30 void Observer(int result) { |
39 observer_calls++; | 31 observer_calls++; |
40 observer_result = result; | 32 observer_result = result; |
41 } | 33 } |
42 | 34 |
43 class StartupTaskRunnerTest : public testing::Test { | 35 class StartupTaskRunnerTest : public testing::Test { |
44 public: | 36 public: |
45 void SetUp() override { | 37 void SetUp() override { |
46 last_task_ = 0; | 38 last_task_ = 0; |
(...skipping 30 matching lines...) Expand all Loading... |
77 // We can't use the real message loop, even if we want to, since doing so on | 69 // We can't use the real message loop, even if we want to, since doing so on |
78 // Android requires a complex Java infrastructure. The test would have to built | 70 // Android requires a complex Java infrastructure. The test would have to built |
79 // as a content_shell test; but content_shell startup invokes the class we are | 71 // as a content_shell test; but content_shell startup invokes the class we are |
80 // trying to test. | 72 // trying to test. |
81 // | 73 // |
82 // The mocks are not directly in TaskRunnerProxy because reference counted | 74 // The mocks are not directly in TaskRunnerProxy because reference counted |
83 // objects seem to confuse the mocking framework | 75 // objects seem to confuse the mocking framework |
84 | 76 |
85 class MockTaskRunner { | 77 class MockTaskRunner { |
86 public: | 78 public: |
87 MOCK_METHOD3( | 79 MOCK_METHOD0(PostDelayedTask, bool()); |
88 PostDelayedTask, | 80 MOCK_METHOD1(PostNonNestableDelayedTask, bool(base::TimeDelta)); |
89 bool(const tracked_objects::Location&, const Closure&, base::TimeDelta)); | |
90 MOCK_METHOD3( | |
91 PostNonNestableDelayedTask, | |
92 bool(const tracked_objects::Location&, const Closure&, base::TimeDelta)); | |
93 }; | 81 }; |
94 | 82 |
95 class TaskRunnerProxy : public base::SingleThreadTaskRunner { | 83 class TaskRunnerProxy : public base::SingleThreadTaskRunner { |
96 public: | 84 public: |
97 TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {} | 85 TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {} |
98 bool RunsTasksOnCurrentThread() const override { return true; } | 86 bool RunsTasksOnCurrentThread() const override { return true; } |
99 bool PostDelayedTask(const tracked_objects::Location& location, | 87 bool PostDelayedTask(const tracked_objects::Location& location, |
100 const Closure& closure, | 88 base::OnceClosure closure, |
101 base::TimeDelta delta) override { | 89 base::TimeDelta delta) override { |
102 return mock_->PostDelayedTask(location, closure, delta); | 90 task_ = std::move(closure); |
| 91 return mock_->PostDelayedTask(); |
103 } | 92 } |
104 bool PostNonNestableDelayedTask(const tracked_objects::Location& location, | 93 bool PostNonNestableDelayedTask(const tracked_objects::Location& location, |
105 const Closure& closure, | 94 base::OnceClosure closure, |
106 base::TimeDelta delta) override { | 95 base::TimeDelta delta) override { |
107 return mock_->PostNonNestableDelayedTask(location, closure, delta); | 96 task_ = std::move(closure); |
| 97 return mock_->PostNonNestableDelayedTask(delta); |
108 } | 98 } |
109 | 99 |
| 100 base::OnceClosure TakeTask() { return std::move(task_); } |
| 101 |
110 private: | 102 private: |
| 103 base::OnceClosure task_; |
111 MockTaskRunner* mock_; | 104 MockTaskRunner* mock_; |
112 ~TaskRunnerProxy() override {} | 105 ~TaskRunnerProxy() override {} |
113 }; | 106 }; |
114 | 107 |
115 TEST_F(StartupTaskRunnerTest, SynchronousExecution) { | 108 TEST_F(StartupTaskRunnerTest, SynchronousExecution) { |
116 MockTaskRunner mock_runner; | 109 MockTaskRunner mock_runner; |
117 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); | 110 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); |
118 | 111 |
119 EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0); | 112 EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0); |
120 EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0); | 113 EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_)).Times(0); |
121 | 114 |
122 StartupTaskRunner runner(base::Bind(&Observer), proxy); | 115 StartupTaskRunner runner(base::Bind(&Observer), proxy); |
123 | 116 |
124 StartupTask task1 = | 117 StartupTask task1 = |
125 base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this)); | 118 base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this)); |
126 runner.AddTask(task1); | 119 runner.AddTask(task1); |
127 EXPECT_EQ(GetLastTask(), 0); | 120 EXPECT_EQ(GetLastTask(), 0); |
128 StartupTask task2 = | 121 StartupTask task2 = |
129 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); | 122 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); |
130 runner.AddTask(task2); | 123 runner.AddTask(task2); |
(...skipping 16 matching lines...) Expand all Loading... |
147 // No more tasks should be run and the observer should not have been called | 140 // No more tasks should be run and the observer should not have been called |
148 // again | 141 // again |
149 EXPECT_EQ(task_count, 2); | 142 EXPECT_EQ(task_count, 2); |
150 EXPECT_EQ(observer_calls, 1); | 143 EXPECT_EQ(observer_calls, 1); |
151 } | 144 } |
152 | 145 |
153 TEST_F(StartupTaskRunnerTest, NullObserver) { | 146 TEST_F(StartupTaskRunnerTest, NullObserver) { |
154 MockTaskRunner mock_runner; | 147 MockTaskRunner mock_runner; |
155 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); | 148 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); |
156 | 149 |
157 EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0); | 150 EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0); |
158 EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0); | 151 EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_)).Times(0); |
159 | 152 |
160 StartupTaskRunner runner(base::Callback<void(int)>(), proxy); | 153 StartupTaskRunner runner(base::Callback<void(int)>(), proxy); |
161 | 154 |
162 StartupTask task1 = | 155 StartupTask task1 = |
163 base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this)); | 156 base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this)); |
164 runner.AddTask(task1); | 157 runner.AddTask(task1); |
165 EXPECT_EQ(GetLastTask(), 0); | 158 EXPECT_EQ(GetLastTask(), 0); |
166 StartupTask task2 = | 159 StartupTask task2 = |
167 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); | 160 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); |
168 runner.AddTask(task2); | 161 runner.AddTask(task2); |
(...skipping 13 matching lines...) Expand all Loading... |
182 // No more tasks should have been run | 175 // No more tasks should have been run |
183 EXPECT_EQ(task_count, 2); | 176 EXPECT_EQ(task_count, 2); |
184 | 177 |
185 EXPECT_EQ(observer_calls, 0); | 178 EXPECT_EQ(observer_calls, 0); |
186 } | 179 } |
187 | 180 |
188 TEST_F(StartupTaskRunnerTest, SynchronousExecutionFailedTask) { | 181 TEST_F(StartupTaskRunnerTest, SynchronousExecutionFailedTask) { |
189 MockTaskRunner mock_runner; | 182 MockTaskRunner mock_runner; |
190 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); | 183 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); |
191 | 184 |
192 EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0); | 185 EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0); |
193 EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0); | 186 EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_)).Times(0); |
194 | 187 |
195 StartupTaskRunner runner(base::Bind(&Observer), proxy); | 188 StartupTaskRunner runner(base::Bind(&Observer), proxy); |
196 | 189 |
197 StartupTask task3 = | 190 StartupTask task3 = |
198 base::Bind(&StartupTaskRunnerTest::FailingTask, base::Unretained(this)); | 191 base::Bind(&StartupTaskRunnerTest::FailingTask, base::Unretained(this)); |
199 runner.AddTask(task3); | 192 runner.AddTask(task3); |
200 EXPECT_EQ(GetLastTask(), 0); | 193 EXPECT_EQ(GetLastTask(), 0); |
201 StartupTask task2 = | 194 StartupTask task2 = |
202 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); | 195 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); |
203 runner.AddTask(task2); | 196 runner.AddTask(task2); |
(...skipping 16 matching lines...) Expand all Loading... |
220 // no more tasks should have run | 213 // no more tasks should have run |
221 EXPECT_EQ(observer_calls, 1); | 214 EXPECT_EQ(observer_calls, 1); |
222 EXPECT_EQ(task_count, 1); | 215 EXPECT_EQ(task_count, 1); |
223 } | 216 } |
224 | 217 |
225 TEST_F(StartupTaskRunnerTest, AsynchronousExecution) { | 218 TEST_F(StartupTaskRunnerTest, AsynchronousExecution) { |
226 | 219 |
227 MockTaskRunner mock_runner; | 220 MockTaskRunner mock_runner; |
228 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); | 221 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); |
229 | 222 |
230 EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0); | 223 EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0); |
231 EXPECT_CALL( | 224 EXPECT_CALL(mock_runner, |
232 mock_runner, | 225 PostNonNestableDelayedTask(base::TimeDelta::FromMilliseconds(0))) |
233 PostNonNestableDelayedTask(_, _, base::TimeDelta::FromMilliseconds(0))) | |
234 .Times(testing::Between(2, 3)) | 226 .Times(testing::Between(2, 3)) |
235 .WillRepeatedly(WithArg<1>(Invoke(SaveTaskArg))); | 227 .WillRepeatedly(Return(true)); |
236 | 228 |
237 StartupTaskRunner runner(base::Bind(&Observer), proxy); | 229 StartupTaskRunner runner(base::Bind(&Observer), proxy); |
238 | 230 |
239 StartupTask task1 = | 231 StartupTask task1 = |
240 base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this)); | 232 base::Bind(&StartupTaskRunnerTest::Task1, base::Unretained(this)); |
241 runner.AddTask(task1); | 233 runner.AddTask(task1); |
242 StartupTask task2 = | 234 StartupTask task2 = |
243 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); | 235 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); |
244 runner.AddTask(task2); | 236 runner.AddTask(task2); |
245 | 237 |
246 // Nothing should run until we tell them to. | 238 // Nothing should run until we tell them to. |
247 EXPECT_EQ(GetLastTask(), 0); | 239 EXPECT_EQ(GetLastTask(), 0); |
248 runner.StartRunningTasksAsync(); | 240 runner.StartRunningTasksAsync(); |
249 | 241 |
250 // No tasks should have run yet, since we the message loop hasn't run. | 242 // No tasks should have run yet, since we the message loop hasn't run. |
251 EXPECT_EQ(GetLastTask(), 0); | 243 EXPECT_EQ(GetLastTask(), 0); |
252 | 244 |
253 // Fake the actual message loop. Each time a task is run a new task should | 245 // Fake the actual message loop. Each time a task is run a new task should |
254 // be added to the queue, hence updating "task". The loop should actually run | 246 // be added to the queue, hence updating "task". The loop should actually run |
255 // at most 3 times (once for each task plus possibly once for the observer), | 247 // at most 3 times (once for each task plus possibly once for the observer), |
256 // the "4" is a backstop. | 248 // the "4" is a backstop. |
257 for (int i = 0; i < 4 && observer_calls == 0; i++) { | 249 for (int i = 0; i < 4 && observer_calls == 0; i++) { |
258 task.Run(); | 250 proxy->TakeTask().Run(); |
259 EXPECT_EQ(i + 1, GetLastTask()); | 251 EXPECT_EQ(i + 1, GetLastTask()); |
260 } | 252 } |
261 EXPECT_EQ(task_count, 2); | 253 EXPECT_EQ(task_count, 2); |
262 EXPECT_EQ(observer_calls, 1); | 254 EXPECT_EQ(observer_calls, 1); |
263 EXPECT_EQ(observer_result, 0); | 255 EXPECT_EQ(observer_result, 0); |
264 | 256 |
265 // Check that running synchronously now doesn't do anything | 257 // Check that running synchronously now doesn't do anything |
266 | 258 |
267 runner.RunAllTasksNow(); | 259 runner.RunAllTasksNow(); |
268 EXPECT_EQ(task_count, 2); | 260 EXPECT_EQ(task_count, 2); |
269 EXPECT_EQ(observer_calls, 1); | 261 EXPECT_EQ(observer_calls, 1); |
270 } | 262 } |
271 | 263 |
272 TEST_F(StartupTaskRunnerTest, AsynchronousExecutionFailedTask) { | 264 TEST_F(StartupTaskRunnerTest, AsynchronousExecutionFailedTask) { |
273 | 265 |
274 MockTaskRunner mock_runner; | 266 MockTaskRunner mock_runner; |
275 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); | 267 scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner); |
276 | 268 |
277 EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0); | 269 EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0); |
278 EXPECT_CALL( | 270 EXPECT_CALL(mock_runner, |
279 mock_runner, | 271 PostNonNestableDelayedTask(base::TimeDelta::FromMilliseconds(0))) |
280 PostNonNestableDelayedTask(_, _, base::TimeDelta::FromMilliseconds(0))) | |
281 .Times(testing::Between(1, 2)) | 272 .Times(testing::Between(1, 2)) |
282 .WillRepeatedly(WithArg<1>(Invoke(SaveTaskArg))); | 273 .WillRepeatedly(Return(true)); |
283 | 274 |
284 StartupTaskRunner runner(base::Bind(&Observer), proxy); | 275 StartupTaskRunner runner(base::Bind(&Observer), proxy); |
285 | 276 |
286 StartupTask task3 = | 277 StartupTask task3 = |
287 base::Bind(&StartupTaskRunnerTest::FailingTask, base::Unretained(this)); | 278 base::Bind(&StartupTaskRunnerTest::FailingTask, base::Unretained(this)); |
288 runner.AddTask(task3); | 279 runner.AddTask(task3); |
289 StartupTask task2 = | 280 StartupTask task2 = |
290 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); | 281 base::Bind(&StartupTaskRunnerTest::Task2, base::Unretained(this)); |
291 runner.AddTask(task2); | 282 runner.AddTask(task2); |
292 | 283 |
293 // Nothing should run until we tell them to. | 284 // Nothing should run until we tell them to. |
294 EXPECT_EQ(GetLastTask(), 0); | 285 EXPECT_EQ(GetLastTask(), 0); |
295 runner.StartRunningTasksAsync(); | 286 runner.StartRunningTasksAsync(); |
296 | 287 |
297 // No tasks should have run yet, since we the message loop hasn't run. | 288 // No tasks should have run yet, since we the message loop hasn't run. |
298 EXPECT_EQ(GetLastTask(), 0); | 289 EXPECT_EQ(GetLastTask(), 0); |
299 | 290 |
300 // Fake the actual message loop. Each time a task is run a new task should | 291 // Fake the actual message loop. Each time a task is run a new task should |
301 // be added to the queue, hence updating "task". The loop should actually run | 292 // be added to the queue, hence updating "task". The loop should actually run |
302 // at most twice (once for the failed task plus possibly once for the | 293 // at most twice (once for the failed task plus possibly once for the |
303 // observer), the "4" is a backstop. | 294 // observer), the "4" is a backstop. |
304 for (int i = 0; i < 4 && observer_calls == 0; i++) { | 295 for (int i = 0; i < 4 && observer_calls == 0; i++) { |
305 task.Run(); | 296 proxy->TakeTask().Run(); |
306 } | 297 } |
307 EXPECT_EQ(GetLastTask(), 3); | 298 EXPECT_EQ(GetLastTask(), 3); |
308 EXPECT_EQ(task_count, 1); | 299 EXPECT_EQ(task_count, 1); |
309 | 300 |
310 EXPECT_EQ(observer_calls, 1); | 301 EXPECT_EQ(observer_calls, 1); |
311 EXPECT_EQ(observer_result, 1); | 302 EXPECT_EQ(observer_result, 1); |
312 | 303 |
313 // Check that running synchronously now doesn't do anything | 304 // Check that running synchronously now doesn't do anything |
314 runner.RunAllTasksNow(); | 305 runner.RunAllTasksNow(); |
315 EXPECT_EQ(observer_calls, 1); | 306 EXPECT_EQ(observer_calls, 1); |
316 EXPECT_EQ(task_count, 1); | 307 EXPECT_EQ(task_count, 1); |
317 } | 308 } |
318 } // namespace | 309 } // namespace |
319 } // namespace content | 310 } // namespace content |
OLD | NEW |