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 | |
46 size_t TestOrderablePendingTask::task_id_counter = 0; | 49 size_t TestOrderablePendingTask::task_id_counter = 0; |
47 | 50 |
48 TestOrderablePendingTask::~TestOrderablePendingTask() { | 51 TestOrderablePendingTask::~TestOrderablePendingTask() { |
49 } | 52 } |
50 | 53 |
51 bool TestOrderablePendingTask::operator==( | 54 bool TestOrderablePendingTask::operator==( |
52 const TestOrderablePendingTask& other) const { | 55 const TestOrderablePendingTask& other) const { |
53 return task_id_ == other.task_id_; | 56 return task_id_ == other.task_id_; |
54 } | 57 } |
55 | 58 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
99 // base::TestSimpleTaskRunner implementation | 102 // base::TestSimpleTaskRunner implementation |
100 bool OrderedSimpleTaskRunner::PostDelayedTask( | 103 bool OrderedSimpleTaskRunner::PostDelayedTask( |
101 const tracked_objects::Location& from_here, | 104 const tracked_objects::Location& from_here, |
102 const base::Closure& task, | 105 const base::Closure& task, |
103 base::TimeDelta delay) { | 106 base::TimeDelta delay) { |
104 DCHECK(thread_checker_.CalledOnValidThread()); | 107 DCHECK(thread_checker_.CalledOnValidThread()); |
105 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, | 108 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, |
106 base::TestPendingTask::NESTABLE); | 109 base::TestPendingTask::NESTABLE); |
107 | 110 |
108 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); | 111 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); |
109 pending_tasks_.insert(pt); | 112 pending_tasks_.insert(std::move(pt)); |
110 return true; | 113 return true; |
111 } | 114 } |
112 | 115 |
113 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( | 116 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( |
114 const tracked_objects::Location& from_here, | 117 const tracked_objects::Location& from_here, |
115 const base::Closure& task, | 118 const base::Closure& task, |
116 base::TimeDelta delay) { | 119 base::TimeDelta delay) { |
117 DCHECK(thread_checker_.CalledOnValidThread()); | 120 DCHECK(thread_checker_.CalledOnValidThread()); |
118 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, | 121 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, |
119 base::TestPendingTask::NON_NESTABLE); | 122 base::TestPendingTask::NON_NESTABLE); |
120 | 123 |
121 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); | 124 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); |
122 pending_tasks_.insert(pt); | 125 pending_tasks_.insert(std::move(pt)); |
123 return true; | 126 return true; |
124 } | 127 } |
125 | 128 |
126 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { | 129 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { |
127 DCHECK(thread_checker_.CalledOnValidThread()); | 130 DCHECK(thread_checker_.CalledOnValidThread()); |
128 return true; | 131 return true; |
129 } | 132 } |
130 | 133 |
131 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { | 134 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { |
132 return pending_tasks_.size(); | 135 return pending_tasks_.size(); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
215 break; | 218 break; |
216 } | 219 } |
217 | 220 |
218 std::set<TestOrderablePendingTask>::iterator task_to_run = | 221 std::set<TestOrderablePendingTask>::iterator task_to_run = |
219 pending_tasks_.begin(); | 222 pending_tasks_.begin(); |
220 { | 223 { |
221 TRACE_EVENT1("cc", | 224 TRACE_EVENT1("cc", |
222 "OrderedSimpleTaskRunner::RunPendingTasks running", | 225 "OrderedSimpleTaskRunner::RunPendingTasks running", |
223 "task", | 226 "task", |
224 task_to_run->AsValue()); | 227 task_to_run->AsValue()); |
225 task_to_run->task.Run(); | 228 base::OnceClosure& task = |
229 const_cast<base::OnceClosure&>(task_to_run->task); | |
230 std::move(task).Run(); | |
226 } | 231 } |
227 | 232 |
228 pending_tasks_.erase(task_to_run); | 233 pending_tasks_.erase(task_to_run); |
danakj
2016/10/20 20:07:46
Is it for sure valid to erase an iterator when you
tzik
2016/10/27 08:20:49
Hmm. I think it's practically safe, since the task
danakj
2016/10/27 21:15:21
ok can you leave a comment saying why this is okay
tzik
2017/01/23 10:45:51
Done.
| |
229 } | 234 } |
230 | 235 |
231 return HasPendingTasks(); | 236 return HasPendingTasks(); |
232 } | 237 } |
233 | 238 |
234 bool OrderedSimpleTaskRunner::RunPendingTasks() { | 239 bool OrderedSimpleTaskRunner::RunPendingTasks() { |
235 return RunTasksWhile(TaskExistedInitially()); | 240 return RunTasksWhile(TaskExistedInitially()); |
236 } | 241 } |
237 | 242 |
238 bool OrderedSimpleTaskRunner::RunUntilIdle() { | 243 bool OrderedSimpleTaskRunner::RunUntilIdle() { |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
301 max_tasks, | 306 max_tasks, |
302 base::Owned(new size_t(0))); | 307 base::Owned(new size_t(0))); |
303 } | 308 } |
304 | 309 |
305 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, | 310 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, |
306 size_t* tasks_run) { | 311 size_t* tasks_run) { |
307 return (*tasks_run)++ < max_tasks; | 312 return (*tasks_run)++ < max_tasks; |
308 } | 313 } |
309 | 314 |
310 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { | 315 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { |
311 // base::Bind takes a copy of pending_tasks_ | 316 std::set<size_t> task_ids; |
317 for (const auto& task : pending_tasks_) | |
318 task_ids.insert(task.task_id()); | |
319 | |
312 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, | 320 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, |
313 base::Unretained(this), | 321 base::Unretained(this), std::move(task_ids)); |
314 pending_tasks_); | |
315 } | 322 } |
316 | 323 |
317 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( | 324 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( |
318 const std::set<TestOrderablePendingTask>& existing_tasks) { | 325 const std::set<size_t>& existing_tasks) { |
319 return existing_tasks.find(*pending_tasks_.begin()) != existing_tasks.end(); | 326 return existing_tasks.find(pending_tasks_.begin()->task_id()) != |
327 existing_tasks.end(); | |
320 } | 328 } |
321 | 329 |
322 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( | 330 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( |
323 base::TimeTicks stop_at) { | 331 base::TimeTicks stop_at) { |
324 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, | 332 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, |
325 base::Unretained(this), | 333 base::Unretained(this), |
326 stop_at); | 334 stop_at); |
327 } | 335 } |
328 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { | 336 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { |
329 return NextTaskTime() <= stop_at; | 337 return NextTaskTime() <= stop_at; |
330 } | 338 } |
331 | 339 |
332 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { | 340 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { |
333 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, | 341 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, |
334 base::Unretained(this)); | 342 base::Unretained(this)); |
335 } | 343 } |
336 | 344 |
337 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { | 345 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { |
338 base::TimeTicks next_task_time = NextTaskTime(); | 346 base::TimeTicks next_task_time = NextTaskTime(); |
339 if (now_src_->NowTicks() < next_task_time) { | 347 if (now_src_->NowTicks() < next_task_time) { |
340 now_src_->Advance(next_task_time - now_src_->NowTicks()); | 348 now_src_->Advance(next_task_time - now_src_->NowTicks()); |
341 } | 349 } |
342 return true; | 350 return true; |
343 } | 351 } |
344 | 352 |
345 } // namespace cc | 353 } // namespace cc |
OLD | NEW |