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 25 matching lines...) Expand all Loading... |
36 TestOrderablePendingTask::TestOrderablePendingTask( | 36 TestOrderablePendingTask::TestOrderablePendingTask( |
37 const tracked_objects::Location& location, | 37 const tracked_objects::Location& location, |
38 const base::Closure& task, | 38 const base::Closure& task, |
39 base::TimeTicks post_time, | 39 base::TimeTicks post_time, |
40 base::TimeDelta delay, | 40 base::TimeDelta delay, |
41 TestNestability nestability) | 41 TestNestability nestability) |
42 : base::TestPendingTask(location, task, post_time, delay, nestability), | 42 : base::TestPendingTask(location, task, post_time, delay, nestability), |
43 task_id_(TestOrderablePendingTask::task_id_counter++) { | 43 task_id_(TestOrderablePendingTask::task_id_counter++) { |
44 } | 44 } |
45 | 45 |
| 46 TestOrderablePendingTask::TestOrderablePendingTask(TestOrderablePendingTask&&) = |
| 47 default; |
| 48 |
| 49 TestOrderablePendingTask& TestOrderablePendingTask::operator=( |
| 50 TestOrderablePendingTask&&) = default; |
| 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 } |
55 | 61 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
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 const base::Closure& 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, task, now_src_->NowTicks(), delay, |
106 base::TestPendingTask::NESTABLE); | 112 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 const base::Closure& 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, task, now_src_->NowTicks(), delay, |
119 base::TestPendingTask::NON_NESTABLE); | 125 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 // It's safe to remove const and consume |task| here, since |task| is not |
| 232 // used for ordering the item. |
| 233 base::OnceClosure& task = |
| 234 const_cast<base::OnceClosure&>(task_to_run->task); |
| 235 std::move(task).Run(); |
226 } | 236 } |
227 | 237 |
228 pending_tasks_.erase(task_to_run); | 238 pending_tasks_.erase(task_to_run); |
229 } | 239 } |
230 | 240 |
231 return HasPendingTasks(); | 241 return HasPendingTasks(); |
232 } | 242 } |
233 | 243 |
234 bool OrderedSimpleTaskRunner::RunPendingTasks() { | 244 bool OrderedSimpleTaskRunner::RunPendingTasks() { |
235 return RunTasksWhile(TaskExistedInitially()); | 245 return RunTasksWhile(TaskExistedInitially()); |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 max_tasks, | 313 max_tasks, |
304 base::Owned(new size_t(0))); | 314 base::Owned(new size_t(0))); |
305 } | 315 } |
306 | 316 |
307 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, | 317 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, |
308 size_t* tasks_run) { | 318 size_t* tasks_run) { |
309 return (*tasks_run)++ < max_tasks; | 319 return (*tasks_run)++ < max_tasks; |
310 } | 320 } |
311 | 321 |
312 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { | 322 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { |
313 // base::Bind takes a copy of pending_tasks_ | 323 std::set<size_t> task_ids; |
| 324 for (const auto& task : pending_tasks_) |
| 325 task_ids.insert(task.task_id()); |
| 326 |
314 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, | 327 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, |
315 base::Unretained(this), | 328 base::Unretained(this), std::move(task_ids)); |
316 pending_tasks_); | |
317 } | 329 } |
318 | 330 |
319 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( | 331 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( |
320 const std::set<TestOrderablePendingTask>& existing_tasks) { | 332 const std::set<size_t>& existing_tasks) { |
321 return existing_tasks.find(*pending_tasks_.begin()) != existing_tasks.end(); | 333 return existing_tasks.find(pending_tasks_.begin()->task_id()) != |
| 334 existing_tasks.end(); |
322 } | 335 } |
323 | 336 |
324 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( | 337 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( |
325 base::TimeTicks stop_at) { | 338 base::TimeTicks stop_at) { |
326 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, | 339 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, |
327 base::Unretained(this), | 340 base::Unretained(this), |
328 stop_at); | 341 stop_at); |
329 } | 342 } |
330 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { | 343 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { |
331 return NextTaskTime() <= stop_at; | 344 return NextTaskTime() <= stop_at; |
332 } | 345 } |
333 | 346 |
334 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { | 347 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { |
335 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, | 348 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, |
336 base::Unretained(this)); | 349 base::Unretained(this)); |
337 } | 350 } |
338 | 351 |
339 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { | 352 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { |
340 base::TimeTicks next_task_time = NextTaskTime(); | 353 base::TimeTicks next_task_time = NextTaskTime(); |
341 if (now_src_->NowTicks() < next_task_time) { | 354 if (now_src_->NowTicks() < next_task_time) { |
342 now_src_->Advance(next_task_time - now_src_->NowTicks()); | 355 now_src_->Advance(next_task_time - now_src_->NowTicks()); |
343 } | 356 } |
344 return true; | 357 return true; |
345 } | 358 } |
346 | 359 |
347 } // namespace cc | 360 } // namespace cc |
OLD | NEW |