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 <limits> | 7 #include <limits> |
8 #include <set> | 8 #include <set> |
9 #include <sstream> | 9 #include <sstream> |
10 #include <string> | 10 #include <string> |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
68 return state; | 68 return state; |
69 } | 69 } |
70 | 70 |
71 void TestOrderablePendingTask::AsValueInto( | 71 void TestOrderablePendingTask::AsValueInto( |
72 base::trace_event::TracedValue* state) const { | 72 base::trace_event::TracedValue* state) const { |
73 state->SetInteger("id", task_id_); | 73 state->SetInteger("id", task_id_); |
74 state->SetInteger("run_at", GetTimeToRun().ToInternalValue()); | 74 state->SetInteger("run_at", GetTimeToRun().ToInternalValue()); |
75 state->SetString("posted_from", location.ToString()); | 75 state->SetString("posted_from", location.ToString()); |
76 } | 76 } |
77 | 77 |
78 OrderedSimpleTaskRunner::OrderedSimpleTaskRunner() | |
79 : advance_now_(true), | |
80 now_src_(TestNowSource::Create(0)), | |
81 max_tasks_(kAbsoluteMaxTasks), | |
82 inside_run_tasks_until_(false) { | |
83 } | |
84 | |
85 OrderedSimpleTaskRunner::OrderedSimpleTaskRunner( | 78 OrderedSimpleTaskRunner::OrderedSimpleTaskRunner( |
86 scoped_refptr<TestNowSource> now_src, | 79 base::SimpleTestTickClock* now_src, |
87 bool advance_now) | 80 bool advance_now) |
88 : advance_now_(advance_now), | 81 : advance_now_(advance_now), |
89 now_src_(now_src), | 82 now_src_(now_src), |
90 max_tasks_(kAbsoluteMaxTasks), | 83 max_tasks_(kAbsoluteMaxTasks), |
91 inside_run_tasks_until_(false) { | 84 inside_run_tasks_until_(false) { |
92 } | 85 } |
93 | 86 |
94 OrderedSimpleTaskRunner::~OrderedSimpleTaskRunner() {} | 87 OrderedSimpleTaskRunner::~OrderedSimpleTaskRunner() {} |
95 | 88 |
89 base::TimeTicks OrderedSimpleTaskRunner::AbsoluteMaxNow() { | |
90 return base::TimeTicks::FromInternalValue( | |
91 std::numeric_limits<int64_t>::max()); | |
92 } | |
93 | |
96 // base::TestSimpleTaskRunner implementation | 94 // base::TestSimpleTaskRunner implementation |
97 bool OrderedSimpleTaskRunner::PostDelayedTask( | 95 bool OrderedSimpleTaskRunner::PostDelayedTask( |
98 const tracked_objects::Location& from_here, | 96 const tracked_objects::Location& from_here, |
99 const base::Closure& task, | 97 const base::Closure& task, |
100 base::TimeDelta delay) { | 98 base::TimeDelta delay) { |
101 DCHECK(thread_checker_.CalledOnValidThread()); | 99 DCHECK(thread_checker_.CalledOnValidThread()); |
102 TestOrderablePendingTask pt( | 100 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, |
103 from_here, task, now_src_->Now(), delay, base::TestPendingTask::NESTABLE); | 101 base::TestPendingTask::NESTABLE); |
104 | 102 |
105 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); | 103 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); |
106 pending_tasks_.insert(pt); | 104 pending_tasks_.insert(pt); |
107 return true; | 105 return true; |
108 } | 106 } |
109 | 107 |
110 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( | 108 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( |
111 const tracked_objects::Location& from_here, | 109 const tracked_objects::Location& from_here, |
112 const base::Closure& task, | 110 const base::Closure& task, |
113 base::TimeDelta delay) { | 111 base::TimeDelta delay) { |
114 DCHECK(thread_checker_.CalledOnValidThread()); | 112 DCHECK(thread_checker_.CalledOnValidThread()); |
115 TestOrderablePendingTask pt(from_here, | 113 TestOrderablePendingTask pt(from_here, task, now_src_->NowTicks(), delay, |
116 task, | |
117 now_src_->Now(), | |
118 delay, | |
119 base::TestPendingTask::NON_NESTABLE); | 114 base::TestPendingTask::NON_NESTABLE); |
120 | 115 |
121 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); | 116 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); |
122 pending_tasks_.insert(pt); | 117 pending_tasks_.insert(pt); |
123 return true; | 118 return true; |
124 } | 119 } |
125 | 120 |
126 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { | 121 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { |
127 DCHECK(thread_checker_.CalledOnValidThread()); | 122 DCHECK(thread_checker_.CalledOnValidThread()); |
128 return true; | 123 return true; |
129 } | 124 } |
130 | 125 |
131 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { | 126 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { |
132 return pending_tasks_.size(); | 127 return pending_tasks_.size(); |
133 } | 128 } |
134 | 129 |
135 bool OrderedSimpleTaskRunner::HasPendingTasks() const { | 130 bool OrderedSimpleTaskRunner::HasPendingTasks() const { |
136 return pending_tasks_.size() > 0; | 131 return pending_tasks_.size() > 0; |
137 } | 132 } |
138 | 133 |
139 base::TimeTicks OrderedSimpleTaskRunner::NextTaskTime() { | 134 base::TimeTicks OrderedSimpleTaskRunner::NextTaskTime() { |
140 if (pending_tasks_.size() <= 0) { | 135 if (pending_tasks_.size() <= 0) { |
141 return TestNowSource::kAbsoluteMaxNow; | 136 return AbsoluteMaxNow(); |
142 } | 137 } |
143 | 138 |
144 return pending_tasks_.begin()->GetTimeToRun(); | 139 return pending_tasks_.begin()->GetTimeToRun(); |
145 } | 140 } |
146 | 141 |
147 base::TimeDelta OrderedSimpleTaskRunner::DelayToNextTaskTime() { | 142 base::TimeDelta OrderedSimpleTaskRunner::DelayToNextTaskTime() { |
148 DCHECK(thread_checker_.CalledOnValidThread()); | 143 DCHECK(thread_checker_.CalledOnValidThread()); |
149 | 144 |
150 if (pending_tasks_.size() <= 0) { | 145 if (pending_tasks_.size() <= 0) { |
151 return TestNowSource::kAbsoluteMaxNow - base::TimeTicks(); | 146 return AbsoluteMaxNow() - base::TimeTicks(); |
152 } | 147 } |
153 | 148 |
154 base::TimeDelta delay = NextTaskTime() - now_src_->Now(); | 149 base::TimeDelta delay = NextTaskTime() - now_src_->NowTicks(); |
155 if (delay > base::TimeDelta()) | 150 if (delay > base::TimeDelta()) |
156 return delay; | 151 return delay; |
157 return base::TimeDelta(); | 152 return base::TimeDelta(); |
158 } | 153 } |
159 | 154 |
160 const size_t OrderedSimpleTaskRunner::kAbsoluteMaxTasks = | 155 const size_t OrderedSimpleTaskRunner::kAbsoluteMaxTasks = |
161 std::numeric_limits<size_t>::max(); | 156 std::numeric_limits<size_t>::max(); |
162 | 157 |
163 bool OrderedSimpleTaskRunner::RunTasksWhile( | 158 bool OrderedSimpleTaskRunner::RunTasksWhile( |
164 base::Callback<bool(void)> condition) { | 159 base::Callback<bool(void)> condition) { |
(...skipping 20 matching lines...) Expand all Loading... | |
185 | 180 |
186 // Make a copy so we can append some extra run checks. | 181 // Make a copy so we can append some extra run checks. |
187 std::vector<base::Callback<bool(void)>> modifiable_conditions(conditions); | 182 std::vector<base::Callback<bool(void)>> modifiable_conditions(conditions); |
188 | 183 |
189 // Provide a timeout base on number of tasks run so this doesn't loop | 184 // Provide a timeout base on number of tasks run so this doesn't loop |
190 // forever. | 185 // forever. |
191 modifiable_conditions.push_back(TaskRunCountBelow(max_tasks_)); | 186 modifiable_conditions.push_back(TaskRunCountBelow(max_tasks_)); |
192 | 187 |
193 // If to advance now or not | 188 // If to advance now or not |
194 if (!advance_now_) { | 189 if (!advance_now_) { |
195 modifiable_conditions.push_back(NowBefore(now_src_->Now())); | 190 modifiable_conditions.push_back(NowBefore(now_src_->NowTicks())); |
196 } else { | 191 } else { |
197 modifiable_conditions.push_back(AdvanceNow()); | 192 modifiable_conditions.push_back(AdvanceNow()); |
198 } | 193 } |
199 | 194 |
200 while (pending_tasks_.size() > 0) { | 195 while (pending_tasks_.size() > 0) { |
201 // Check if we should continue to run pending tasks. | 196 // Check if we should continue to run pending tasks. |
202 bool condition_success = true; | 197 bool condition_success = true; |
203 for (std::vector<base::Callback<bool(void)>>::iterator it = | 198 for (std::vector<base::Callback<bool(void)>>::iterator it = |
204 modifiable_conditions.begin(); | 199 modifiable_conditions.begin(); |
205 it != modifiable_conditions.end(); | 200 it != modifiable_conditions.end(); |
(...skipping 28 matching lines...) Expand all Loading... | |
234 bool OrderedSimpleTaskRunner::RunPendingTasks() { | 229 bool OrderedSimpleTaskRunner::RunPendingTasks() { |
235 return RunTasksWhile(TaskExistedInitially()); | 230 return RunTasksWhile(TaskExistedInitially()); |
236 } | 231 } |
237 | 232 |
238 bool OrderedSimpleTaskRunner::RunUntilIdle() { | 233 bool OrderedSimpleTaskRunner::RunUntilIdle() { |
239 return RunTasksWhile(std::vector<base::Callback<bool(void)>>()); | 234 return RunTasksWhile(std::vector<base::Callback<bool(void)>>()); |
240 } | 235 } |
241 | 236 |
242 bool OrderedSimpleTaskRunner::RunUntilTime(base::TimeTicks time) { | 237 bool OrderedSimpleTaskRunner::RunUntilTime(base::TimeTicks time) { |
243 // If we are not auto advancing, force now forward to the time. | 238 // If we are not auto advancing, force now forward to the time. |
244 if (!advance_now_ && now_src_->Now() < time) | 239 if (!advance_now_ && now_src_->NowTicks() < time) |
245 now_src_->SetNow(time); | 240 now_src_->Advance(time - now_src_->NowTicks()); |
246 | 241 |
247 // Run tasks | 242 // Run tasks |
248 bool result = RunTasksWhile(NowBefore(time)); | 243 bool result = RunTasksWhile(NowBefore(time)); |
249 | 244 |
250 // If the next task is after the stopping time and auto-advancing now, then | 245 // If the next task is after the stopping time and auto-advancing now, then |
251 // force time to be the stopping time. | 246 // force time to be the stopping time. |
252 if (!result && advance_now_ && now_src_->Now() < time) { | 247 if (!result && advance_now_ && now_src_->NowTicks() < time) { |
253 now_src_->SetNow(time); | 248 now_src_->Advance(time - now_src_->NowTicks()); |
254 } | 249 } |
255 | 250 |
256 return result; | 251 return result; |
257 } | 252 } |
258 | 253 |
259 bool OrderedSimpleTaskRunner::RunForPeriod(base::TimeDelta period) { | 254 bool OrderedSimpleTaskRunner::RunForPeriod(base::TimeDelta period) { |
260 return RunUntilTime(now_src_->Now() + period); | 255 return RunUntilTime(now_src_->NowTicks() + period); |
261 } | 256 } |
262 | 257 |
263 // base::trace_event tracing functionality | 258 // base::trace_event tracing functionality |
264 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | 259 scoped_refptr<base::trace_event::ConvertableToTraceFormat> |
265 OrderedSimpleTaskRunner::AsValue() const { | 260 OrderedSimpleTaskRunner::AsValue() const { |
266 scoped_refptr<base::trace_event::TracedValue> state = | 261 scoped_refptr<base::trace_event::TracedValue> state = |
267 new base::trace_event::TracedValue(); | 262 new base::trace_event::TracedValue(); |
268 AsValueInto(state.get()); | 263 AsValueInto(state.get()); |
269 return state; | 264 return state; |
270 } | 265 } |
271 | 266 |
272 void OrderedSimpleTaskRunner::AsValueInto( | 267 void OrderedSimpleTaskRunner::AsValueInto( |
273 base::trace_event::TracedValue* state) const { | 268 base::trace_event::TracedValue* state) const { |
274 state->SetInteger("pending_tasks", pending_tasks_.size()); | 269 state->SetInteger("pending_tasks", pending_tasks_.size()); |
275 | 270 |
276 state->BeginArray("tasks"); | 271 state->BeginArray("tasks"); |
277 for (std::set<TestOrderablePendingTask>::const_iterator it = | 272 for (std::set<TestOrderablePendingTask>::const_iterator it = |
278 pending_tasks_.begin(); | 273 pending_tasks_.begin(); |
279 it != pending_tasks_.end(); | 274 it != pending_tasks_.end(); |
280 ++it) { | 275 ++it) { |
281 state->BeginDictionary(); | 276 state->BeginDictionary(); |
282 it->AsValueInto(state); | 277 it->AsValueInto(state); |
283 state->EndDictionary(); | 278 state->EndDictionary(); |
284 } | 279 } |
285 state->EndArray(); | 280 state->EndArray(); |
286 | 281 |
287 state->BeginDictionary("now_src"); | 282 state->BeginDictionary("now_src"); |
288 now_src_->AsValueInto(state); | 283 state->SetInteger("now_in_microseconds", |
Sami
2015/06/08 13:59:02
The internal value is not really defined to be in
Ankur Verma
2015/06/09 07:53:47
This was replayed from TestNowSource.
base::TimeTi
Sami
2015/06/09 10:16:02
Oh right, with TimeTicks we usually do this:
Ankur Verma
2015/06/09 13:53:43
Done.
| |
284 (now_src_->NowTicks()).ToInternalValue()); | |
289 state->EndDictionary(); | 285 state->EndDictionary(); |
290 | 286 |
291 state->SetBoolean("advance_now", advance_now_); | 287 state->SetBoolean("advance_now", advance_now_); |
292 state->SetBoolean("inside_run_tasks_until", inside_run_tasks_until_); | 288 state->SetBoolean("inside_run_tasks_until", inside_run_tasks_until_); |
293 state->SetString("max_tasks", base::SizeTToString(max_tasks_)); | 289 state->SetString("max_tasks", base::SizeTToString(max_tasks_)); |
294 } | 290 } |
295 | 291 |
296 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskRunCountBelow( | 292 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskRunCountBelow( |
297 size_t max_tasks) { | 293 size_t max_tasks) { |
298 return base::Bind(&OrderedSimpleTaskRunner::TaskRunCountBelowCallback, | 294 return base::Bind(&OrderedSimpleTaskRunner::TaskRunCountBelowCallback, |
(...skipping 28 matching lines...) Expand all Loading... | |
327 return NextTaskTime() <= stop_at; | 323 return NextTaskTime() <= stop_at; |
328 } | 324 } |
329 | 325 |
330 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { | 326 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { |
331 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, | 327 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, |
332 base::Unretained(this)); | 328 base::Unretained(this)); |
333 } | 329 } |
334 | 330 |
335 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { | 331 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { |
336 base::TimeTicks next_task_time = NextTaskTime(); | 332 base::TimeTicks next_task_time = NextTaskTime(); |
337 if (now_src_->Now() < next_task_time) { | 333 if (now_src_->NowTicks() < next_task_time) { |
338 now_src_->SetNow(next_task_time); | 334 now_src_->Advance(next_task_time - now_src_->NowTicks()); |
339 } | 335 } |
340 return true; | 336 return true; |
341 } | 337 } |
342 | 338 |
343 } // namespace cc | 339 } // namespace cc |
OLD | NEW |