| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/test/ordered_simple_task_runner.h" | |
| 6 | |
| 7 #include <limits> | |
| 8 #include <set> | |
| 9 #include <sstream> | |
| 10 #include <string> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "base/auto_reset.h" | |
| 14 #include "base/strings/string_number_conversions.h" | |
| 15 #include "base/trace_event/trace_event.h" | |
| 16 #include "base/trace_event/trace_event_argument.h" | |
| 17 | |
| 18 #define TRACE_TASK(function, task) \ | |
| 19 TRACE_EVENT_INSTANT1( \ | |
| 20 "cc", function, TRACE_EVENT_SCOPE_THREAD, "task", task.AsValue()); | |
| 21 | |
| 22 #define TRACE_TASK_RUN(function, tag, task) | |
| 23 | |
| 24 namespace cc { | |
| 25 | |
| 26 // TestOrderablePendingTask implementation | |
| 27 TestOrderablePendingTask::TestOrderablePendingTask() | |
| 28 : base::TestPendingTask(), | |
| 29 task_id_(TestOrderablePendingTask::task_id_counter++) { | |
| 30 } | |
| 31 | |
| 32 TestOrderablePendingTask::TestOrderablePendingTask( | |
| 33 const tracked_objects::Location& location, | |
| 34 const base::Closure& task, | |
| 35 base::TimeTicks post_time, | |
| 36 base::TimeDelta delay, | |
| 37 TestNestability nestability) | |
| 38 : base::TestPendingTask(location, task, post_time, delay, nestability), | |
| 39 task_id_(TestOrderablePendingTask::task_id_counter++) { | |
| 40 } | |
| 41 | |
| 42 size_t TestOrderablePendingTask::task_id_counter = 0; | |
| 43 | |
| 44 TestOrderablePendingTask::~TestOrderablePendingTask() { | |
| 45 } | |
| 46 | |
| 47 bool TestOrderablePendingTask::operator==( | |
| 48 const TestOrderablePendingTask& other) const { | |
| 49 return task_id_ == other.task_id_; | |
| 50 } | |
| 51 | |
| 52 bool TestOrderablePendingTask::operator<( | |
| 53 const TestOrderablePendingTask& other) const { | |
| 54 if (*this == other) | |
| 55 return false; | |
| 56 | |
| 57 if (GetTimeToRun() == other.GetTimeToRun()) { | |
| 58 return task_id_ < other.task_id_; | |
| 59 } | |
| 60 return ShouldRunBefore(other); | |
| 61 } | |
| 62 | |
| 63 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | |
| 64 TestOrderablePendingTask::AsValue() const { | |
| 65 scoped_refptr<base::trace_event::TracedValue> state = | |
| 66 new base::trace_event::TracedValue(); | |
| 67 AsValueInto(state.get()); | |
| 68 return state; | |
| 69 } | |
| 70 | |
| 71 void TestOrderablePendingTask::AsValueInto( | |
| 72 base::trace_event::TracedValue* state) const { | |
| 73 state->SetInteger("id", task_id_); | |
| 74 state->SetInteger("run_at", GetTimeToRun().ToInternalValue()); | |
| 75 state->SetString("posted_from", location.ToString()); | |
| 76 } | |
| 77 | |
| 78 OrderedSimpleTaskRunner::OrderedSimpleTaskRunner() | |
| 79 : advance_now_(true), | |
| 80 now_src_(TestNowSource::Create(0)), | |
| 81 inside_run_tasks_until_(false) { | |
| 82 } | |
| 83 | |
| 84 OrderedSimpleTaskRunner::OrderedSimpleTaskRunner( | |
| 85 scoped_refptr<TestNowSource> now_src, | |
| 86 bool advance_now) | |
| 87 : advance_now_(advance_now), | |
| 88 now_src_(now_src), | |
| 89 max_tasks_(kAbsoluteMaxTasks), | |
| 90 inside_run_tasks_until_(false) { | |
| 91 } | |
| 92 | |
| 93 OrderedSimpleTaskRunner::~OrderedSimpleTaskRunner() {} | |
| 94 | |
| 95 // base::TestSimpleTaskRunner implementation | |
| 96 bool OrderedSimpleTaskRunner::PostDelayedTask( | |
| 97 const tracked_objects::Location& from_here, | |
| 98 const base::Closure& task, | |
| 99 base::TimeDelta delay) { | |
| 100 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 101 TestOrderablePendingTask pt( | |
| 102 from_here, task, now_src_->Now(), delay, base::TestPendingTask::NESTABLE); | |
| 103 | |
| 104 TRACE_TASK("OrderedSimpleTaskRunner::PostDelayedTask", pt); | |
| 105 pending_tasks_.insert(pt); | |
| 106 return true; | |
| 107 } | |
| 108 | |
| 109 bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask( | |
| 110 const tracked_objects::Location& from_here, | |
| 111 const base::Closure& task, | |
| 112 base::TimeDelta delay) { | |
| 113 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 114 TestOrderablePendingTask pt(from_here, | |
| 115 task, | |
| 116 now_src_->Now(), | |
| 117 delay, | |
| 118 base::TestPendingTask::NON_NESTABLE); | |
| 119 | |
| 120 TRACE_TASK("OrderedSimpleTaskRunner::PostNonNestableDelayedTask", pt); | |
| 121 pending_tasks_.insert(pt); | |
| 122 return true; | |
| 123 } | |
| 124 | |
| 125 bool OrderedSimpleTaskRunner::RunsTasksOnCurrentThread() const { | |
| 126 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 127 return true; | |
| 128 } | |
| 129 | |
| 130 size_t OrderedSimpleTaskRunner::NumPendingTasks() const { | |
| 131 return pending_tasks_.size(); | |
| 132 } | |
| 133 | |
| 134 bool OrderedSimpleTaskRunner::HasPendingTasks() const { | |
| 135 return pending_tasks_.size() > 0; | |
| 136 } | |
| 137 | |
| 138 base::TimeTicks OrderedSimpleTaskRunner::NextTaskTime() { | |
| 139 if (pending_tasks_.size() <= 0) { | |
| 140 return TestNowSource::kAbsoluteMaxNow; | |
| 141 } | |
| 142 | |
| 143 return pending_tasks_.begin()->GetTimeToRun(); | |
| 144 } | |
| 145 | |
| 146 base::TimeDelta OrderedSimpleTaskRunner::DelayToNextTaskTime() { | |
| 147 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 148 | |
| 149 if (pending_tasks_.size() <= 0) { | |
| 150 return TestNowSource::kAbsoluteMaxNow - base::TimeTicks(); | |
| 151 } | |
| 152 | |
| 153 base::TimeDelta delay = NextTaskTime() - now_src_->Now(); | |
| 154 if (delay > base::TimeDelta()) | |
| 155 return delay; | |
| 156 return base::TimeDelta(); | |
| 157 } | |
| 158 | |
| 159 const size_t OrderedSimpleTaskRunner::kAbsoluteMaxTasks = | |
| 160 std::numeric_limits<size_t>::max(); | |
| 161 | |
| 162 bool OrderedSimpleTaskRunner::RunTasksWhile( | |
| 163 base::Callback<bool(void)> condition) { | |
| 164 std::vector<base::Callback<bool(void)>> conditions(1); | |
| 165 conditions[0] = condition; | |
| 166 return RunTasksWhile(conditions); | |
| 167 } | |
| 168 | |
| 169 bool OrderedSimpleTaskRunner::RunTasksWhile( | |
| 170 const std::vector<base::Callback<bool(void)>>& conditions) { | |
| 171 TRACE_EVENT2("cc", | |
| 172 "OrderedSimpleTaskRunner::RunPendingTasks", | |
| 173 "this", | |
| 174 AsValue(), | |
| 175 "nested", | |
| 176 inside_run_tasks_until_); | |
| 177 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 178 | |
| 179 if (inside_run_tasks_until_) | |
| 180 return true; | |
| 181 | |
| 182 base::AutoReset<bool> reset_inside_run_tasks_until_(&inside_run_tasks_until_, | |
| 183 true); | |
| 184 | |
| 185 // Make a copy so we can append some extra run checks. | |
| 186 std::vector<base::Callback<bool(void)>> modifiable_conditions(conditions); | |
| 187 | |
| 188 // Provide a timeout base on number of tasks run so this doesn't loop | |
| 189 // forever. | |
| 190 modifiable_conditions.push_back(TaskRunCountBelow(max_tasks_)); | |
| 191 | |
| 192 // If to advance now or not | |
| 193 if (!advance_now_) { | |
| 194 modifiable_conditions.push_back(NowBefore(now_src_->Now())); | |
| 195 } else { | |
| 196 modifiable_conditions.push_back(AdvanceNow()); | |
| 197 } | |
| 198 | |
| 199 while (pending_tasks_.size() > 0) { | |
| 200 // Check if we should continue to run pending tasks. | |
| 201 bool condition_success = true; | |
| 202 for (std::vector<base::Callback<bool(void)>>::iterator it = | |
| 203 modifiable_conditions.begin(); | |
| 204 it != modifiable_conditions.end(); | |
| 205 it++) { | |
| 206 condition_success = it->Run(); | |
| 207 if (!condition_success) | |
| 208 break; | |
| 209 } | |
| 210 | |
| 211 // Conditions could modify the pending task length, so we need to recheck | |
| 212 // that there are tasks to run. | |
| 213 if (!condition_success || !HasPendingTasks()) { | |
| 214 break; | |
| 215 } | |
| 216 | |
| 217 std::set<TestOrderablePendingTask>::iterator task_to_run = | |
| 218 pending_tasks_.begin(); | |
| 219 { | |
| 220 TRACE_EVENT1("cc", | |
| 221 "OrderedSimpleTaskRunner::RunPendingTasks running", | |
| 222 "task", | |
| 223 task_to_run->AsValue()); | |
| 224 task_to_run->task.Run(); | |
| 225 } | |
| 226 | |
| 227 pending_tasks_.erase(task_to_run); | |
| 228 } | |
| 229 | |
| 230 return HasPendingTasks(); | |
| 231 } | |
| 232 | |
| 233 bool OrderedSimpleTaskRunner::RunPendingTasks() { | |
| 234 return RunTasksWhile(TaskExistedInitially()); | |
| 235 } | |
| 236 | |
| 237 bool OrderedSimpleTaskRunner::RunUntilIdle() { | |
| 238 return RunTasksWhile(std::vector<base::Callback<bool(void)>>()); | |
| 239 } | |
| 240 | |
| 241 bool OrderedSimpleTaskRunner::RunUntilTime(base::TimeTicks time) { | |
| 242 // If we are not auto advancing, force now forward to the time. | |
| 243 if (!advance_now_ && now_src_->Now() < time) | |
| 244 now_src_->SetNow(time); | |
| 245 | |
| 246 // Run tasks | |
| 247 bool result = RunTasksWhile(NowBefore(time)); | |
| 248 | |
| 249 // If the next task is after the stopping time and auto-advancing now, then | |
| 250 // force time to be the stopping time. | |
| 251 if (!result && advance_now_ && now_src_->Now() < time) { | |
| 252 now_src_->SetNow(time); | |
| 253 } | |
| 254 | |
| 255 return result; | |
| 256 } | |
| 257 | |
| 258 bool OrderedSimpleTaskRunner::RunForPeriod(base::TimeDelta period) { | |
| 259 return RunUntilTime(now_src_->Now() + period); | |
| 260 } | |
| 261 | |
| 262 // base::trace_event tracing functionality | |
| 263 scoped_refptr<base::trace_event::ConvertableToTraceFormat> | |
| 264 OrderedSimpleTaskRunner::AsValue() const { | |
| 265 scoped_refptr<base::trace_event::TracedValue> state = | |
| 266 new base::trace_event::TracedValue(); | |
| 267 AsValueInto(state.get()); | |
| 268 return state; | |
| 269 } | |
| 270 | |
| 271 void OrderedSimpleTaskRunner::AsValueInto( | |
| 272 base::trace_event::TracedValue* state) const { | |
| 273 state->SetInteger("pending_tasks", pending_tasks_.size()); | |
| 274 | |
| 275 state->BeginArray("tasks"); | |
| 276 for (std::set<TestOrderablePendingTask>::const_iterator it = | |
| 277 pending_tasks_.begin(); | |
| 278 it != pending_tasks_.end(); | |
| 279 ++it) { | |
| 280 state->BeginDictionary(); | |
| 281 it->AsValueInto(state); | |
| 282 state->EndDictionary(); | |
| 283 } | |
| 284 state->EndArray(); | |
| 285 | |
| 286 state->BeginDictionary("now_src"); | |
| 287 now_src_->AsValueInto(state); | |
| 288 state->EndDictionary(); | |
| 289 } | |
| 290 | |
| 291 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskRunCountBelow( | |
| 292 size_t max_tasks) { | |
| 293 return base::Bind(&OrderedSimpleTaskRunner::TaskRunCountBelowCallback, | |
| 294 max_tasks, | |
| 295 base::Owned(new size_t(0))); | |
| 296 } | |
| 297 | |
| 298 bool OrderedSimpleTaskRunner::TaskRunCountBelowCallback(size_t max_tasks, | |
| 299 size_t* tasks_run) { | |
| 300 return (*tasks_run)++ < max_tasks; | |
| 301 } | |
| 302 | |
| 303 base::Callback<bool(void)> OrderedSimpleTaskRunner::TaskExistedInitially() { | |
| 304 // base::Bind takes a copy of pending_tasks_ | |
| 305 return base::Bind(&OrderedSimpleTaskRunner::TaskExistedInitiallyCallback, | |
| 306 base::Unretained(this), | |
| 307 pending_tasks_); | |
| 308 } | |
| 309 | |
| 310 bool OrderedSimpleTaskRunner::TaskExistedInitiallyCallback( | |
| 311 const std::set<TestOrderablePendingTask>& existing_tasks) { | |
| 312 return existing_tasks.find(*pending_tasks_.begin()) != existing_tasks.end(); | |
| 313 } | |
| 314 | |
| 315 base::Callback<bool(void)> OrderedSimpleTaskRunner::NowBefore( | |
| 316 base::TimeTicks stop_at) { | |
| 317 return base::Bind(&OrderedSimpleTaskRunner::NowBeforeCallback, | |
| 318 base::Unretained(this), | |
| 319 stop_at); | |
| 320 } | |
| 321 bool OrderedSimpleTaskRunner::NowBeforeCallback(base::TimeTicks stop_at) { | |
| 322 return NextTaskTime() <= stop_at; | |
| 323 } | |
| 324 | |
| 325 base::Callback<bool(void)> OrderedSimpleTaskRunner::AdvanceNow() { | |
| 326 return base::Bind(&OrderedSimpleTaskRunner::AdvanceNowCallback, | |
| 327 base::Unretained(this)); | |
| 328 } | |
| 329 | |
| 330 bool OrderedSimpleTaskRunner::AdvanceNowCallback() { | |
| 331 base::TimeTicks next_task_time = NextTaskTime(); | |
| 332 if (now_src_->Now() < next_task_time) { | |
| 333 now_src_->SetNow(next_task_time); | |
| 334 } | |
| 335 return true; | |
| 336 } | |
| 337 | |
| 338 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
