Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(198)

Side by Side Diff: content/browser/startup_task_runner_unittest.cc

Issue 2122543002: Replace Closure in TaskRunner::PostTask with OneShotCallback (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@07_oneshot
Patch Set: fix Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
OLDNEW
« no previous file with comments | « content/browser/dom_storage/dom_storage_task_runner.cc ('k') | content/child/worker_thread_registry.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698