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 "cc/test/ordered_simple_task_runner.h" | 5 #include "cc/test/ordered_simple_task_runner.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <limits> | 10 #include <limits> |
(...skipping 15 matching lines...) Expand all Loading... |
26 #define TRACE_TASK_RUN(function, tag, task) | 26 #define TRACE_TASK_RUN(function, tag, task) |
27 | 27 |
28 namespace cc { | 28 namespace cc { |
29 | 29 |
30 // TestOrderablePendingTask implementation | 30 // TestOrderablePendingTask implementation |
31 TestOrderablePendingTask::TestOrderablePendingTask() | 31 TestOrderablePendingTask::TestOrderablePendingTask() |
32 : base::TestPendingTask(), | 32 : base::TestPendingTask(), |
33 task_id_(TestOrderablePendingTask::task_id_counter++) { | 33 task_id_(TestOrderablePendingTask::task_id_counter++) { |
34 } | 34 } |
35 | 35 |
| 36 TestOrderablePendingTask::TestOrderablePendingTask(TestOrderablePendingTask&&) = |
| 37 default; |
| 38 |
36 TestOrderablePendingTask::TestOrderablePendingTask( | 39 TestOrderablePendingTask::TestOrderablePendingTask( |
37 const tracked_objects::Location& location, | 40 const tracked_objects::Location& location, |
38 const base::Closure& task, | 41 base::OnceClosure task, |
39 base::TimeTicks post_time, | 42 base::TimeTicks post_time, |
40 base::TimeDelta delay, | 43 base::TimeDelta delay, |
41 TestNestability nestability) | 44 TestNestability nestability) |
42 : base::TestPendingTask(location, task, post_time, delay, nestability), | 45 : base::TestPendingTask(location, |
43 task_id_(TestOrderablePendingTask::task_id_counter++) { | 46 std::move(task), |
44 } | 47 post_time, |
| 48 delay, |
| 49 nestability), |
| 50 task_id_(TestOrderablePendingTask::task_id_counter++) {} |
45 | 51 |
46 size_t TestOrderablePendingTask::task_id_counter = 0; | 52 size_t TestOrderablePendingTask::task_id_counter = 0; |
47 | 53 |
48 TestOrderablePendingTask::~TestOrderablePendingTask() { | 54 TestOrderablePendingTask::~TestOrderablePendingTask() { |
49 } | 55 } |
50 | 56 |
51 bool TestOrderablePendingTask::operator==( | 57 bool TestOrderablePendingTask::operator==( |
52 const TestOrderablePendingTask& other) const { | 58 const TestOrderablePendingTask& other) const { |
53 return task_id_ == other.task_id_; | 59 return task_id_ == other.task_id_; |
54 } | 60 } |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
92 | 98 |
93 // static | 99 // static |
94 base::TimeTicks OrderedSimpleTaskRunner::AbsoluteMaxNow() { | 100 base::TimeTicks OrderedSimpleTaskRunner::AbsoluteMaxNow() { |
95 return base::TimeTicks::FromInternalValue( | 101 return base::TimeTicks::FromInternalValue( |
96 std::numeric_limits<int64_t>::max()); | 102 std::numeric_limits<int64_t>::max()); |
97 } | 103 } |
98 | 104 |
99 // base::TestSimpleTaskRunner implementation | 105 // base::TestSimpleTaskRunner implementation |
100 bool OrderedSimpleTaskRunner::PostDelayedTask( | 106 bool OrderedSimpleTaskRunner::PostDelayedTask( |
101 const tracked_objects::Location& from_here, | 107 const tracked_objects::Location& from_here, |
102 const base::Closure& task, | 108 base::OnceClosure task, |
103 base::TimeDelta delay) { | 109 base::TimeDelta delay) { |
104 DCHECK(thread_checker_.CalledOnValidThread()); | 110 DCHECK(thread_checker_.CalledOnValidThread()); |
105 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, | 111 TestOrderablePendingTask pt(from_here, std::move(task), now_src_->NowTicks(), |
106 base::TestPendingTask::NESTABLE); | 112 delay, base::TestPendingTask::NESTABLE); |
107 | 113 |
108 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); | 114 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); |
109 pending_tasks_.insert(pt); | 115 pending_tasks_.insert(std::move(pt)); |
110 return true; | 116 return true; |
111 } | 117 } |
112 | 118 |
113 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( | 119 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( |
114 const tracked_objects::Location& from_here, | 120 const tracked_objects::Location& from_here, |
115 const base::Closure& task, | 121 base::OnceClosure task, |
116 base::TimeDelta delay) { | 122 base::TimeDelta delay) { |
117 DCHECK(thread_checker_.CalledOnValidThread()); | 123 DCHECK(thread_checker_.CalledOnValidThread()); |
118 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, | 124 TestOrderablePendingTask pt(from_here, std::move(task), now_src_->NowTicks(), |
119 base::TestPendingTask::NON_NESTABLE); | 125 delay, base::TestPendingTask::NON_NESTABLE); |
120 | 126 |
121 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); | 127 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); |
122 pending_tasks_.insert(pt); | 128 pending_tasks_.insert(std::move(pt)); |
123 return true; | 129 return true; |
124 } | 130 } |
125 | 131 |
126 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { | 132 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { |
127 DCHECK(thread_checker_.CalledOnValidThread()); | 133 DCHECK(thread_checker_.CalledOnValidThread()); |
128 return true; | 134 return true; |
129 } | 135 } |
130 | 136 |
131 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { | 137 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { |
132 return pending_tasks_.size(); | 138 return pending_tasks_.size(); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
215 break; | 221 break; |
216 } | 222 } |
217 | 223 |
218 std::set<TestOrderablePendingTask>::iterator task_to_run = | 224 std::set<TestOrderablePendingTask>::iterator task_to_run = |
219 pending_tasks_.begin(); | 225 pending_tasks_.begin(); |
220 { | 226 { |
221 TRACE_EVENT1("cc", | 227 TRACE_EVENT1("cc", |
222 "OrderedSimpleTaskRunner::RunPendingTasks running", | 228 "OrderedSimpleTaskRunner::RunPendingTasks running", |
223 "task", | 229 "task", |
224 task_to_run->AsValue()); | 230 task_to_run->AsValue()); |
225 task_to_run->task.Run(); | 231 std::move(task_to_run->task).Run(); |
226 } | 232 } |
227 | 233 |
228 pending_tasks_.erase(task_to_run); | 234 pending_tasks_.erase(task_to_run); |
229 } | 235 } |
230 | 236 |
231 return HasPendingTasks(); | 237 return HasPendingTasks(); |
232 } | 238 } |
233 | 239 |
234 bool OrderedSimpleTaskRunner::RunPendingTasks() { | 240 bool OrderedSimpleTaskRunner::RunPendingTasks() { |
235 return RunTasksWhile(TaskExistedInitially()); | 241 return RunTasksWhile(TaskExistedInitially()); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
302 base::Owned(new size_t(0))); | 308 base::Owned(new size_t(0))); |
303 } | 309 } |
304 | 310 |
305 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, | 311 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, |
306 size_t* tasks_run) { | 312 size_t* tasks_run) { |
307 return (*tasks_run)++ < max_tasks; | 313 return (*tasks_run)++ < max_tasks; |
308 } | 314 } |
309 | 315 |
310 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { | 316 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { |
311 // base::Bind takes a copy of pending_tasks_ | 317 // base::Bind takes a copy of pending_tasks_ |
| 318 std::set<size_t> pending_task_ids; |
| 319 for (const auto& pending_task : pending_tasks_) |
| 320 pending_task_ids.insert(pending_task.task_id()); |
| 321 |
312 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, | 322 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, |
313 base::Unretained(this), | 323 base::Unretained(this), std::move(pending_task_ids)); |
314 pending_tasks_); | |
315 } | 324 } |
316 | 325 |
317 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( | 326 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( |
318 const std::set<TestOrderablePendingTask>& existing_tasks) { | 327 const std::set<size_t>& existing_tasks) { |
319 return existing_tasks.find(*pending_tasks_.begin()) != existing_tasks.end(); | 328 return existing_tasks.find(pending_tasks_.begin()->task_id()) != |
| 329 existing_tasks.end(); |
320 } | 330 } |
321 | 331 |
322 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( | 332 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( |
323 base::TimeTicks stop_at) { | 333 base::TimeTicks stop_at) { |
324 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, | 334 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, |
325 base::Unretained(this), | 335 base::Unretained(this), |
326 stop_at); | 336 stop_at); |
327 } | 337 } |
328 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { | 338 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { |
329 return NextTaskTime() <= stop_at; | 339 return NextTaskTime() <= stop_at; |
330 } | 340 } |
331 | 341 |
332 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { | 342 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { |
333 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, | 343 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, |
334 base::Unretained(this)); | 344 base::Unretained(this)); |
335 } | 345 } |
336 | 346 |
337 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { | 347 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { |
338 base::TimeTicks next_task_time = NextTaskTime(); | 348 base::TimeTicks next_task_time = NextTaskTime(); |
339 if (now_src_->NowTicks() < next_task_time) { | 349 if (now_src_->NowTicks() < next_task_time) { |
340 now_src_->Advance(next_task_time - now_src_->NowTicks()); | 350 now_src_->Advance(next_task_time - now_src_->NowTicks()); |
341 } | 351 } |
342 return true; | 352 return true; |
343 } | 353 } |
344 | 354 |
345 } // namespace cc | 355 } // namespace cc |
OLD | NEW |