OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "components/scheduler/child/task_queue_impl.h" | 5 #include "components/scheduler/child/task_queue_impl.h" |
6 | 6 |
7 #include "components/scheduler/child/task_queue_manager.h" | 7 #include "components/scheduler/child/task_queue_manager.h" |
8 | 8 |
9 namespace scheduler { | 9 namespace scheduler { |
10 namespace internal { | 10 namespace internal { |
11 | 11 |
12 TaskQueueImpl::TaskQueueImpl( | 12 TaskQueueImpl::TaskQueueImpl( |
13 TaskQueueManager* task_queue_manager, | 13 TaskQueueManager* task_queue_manager, |
14 const Spec& spec, | 14 const Spec& spec, |
15 const char* disabled_by_default_tracing_category, | 15 const char* disabled_by_default_tracing_category, |
16 const char* disabled_by_default_verbose_tracing_category) | 16 const char* disabled_by_default_verbose_tracing_category) |
17 : thread_id_(base::PlatformThread::CurrentId()), | 17 : thread_id_(base::PlatformThread::CurrentId()), |
18 task_queue_manager_(task_queue_manager), | 18 task_queue_manager_(task_queue_manager), |
19 pump_policy_(spec.pump_policy), | 19 pump_policy_(spec.pump_policy), |
20 delayed_task_sequence_number_(0), | |
21 name_(spec.name), | 20 name_(spec.name), |
22 disabled_by_default_tracing_category_( | 21 disabled_by_default_tracing_category_( |
23 disabled_by_default_tracing_category), | 22 disabled_by_default_tracing_category), |
24 disabled_by_default_verbose_tracing_category_( | 23 disabled_by_default_verbose_tracing_category_( |
25 disabled_by_default_verbose_tracing_category), | 24 disabled_by_default_verbose_tracing_category), |
26 wakeup_policy_(spec.wakeup_policy), | 25 wakeup_policy_(spec.wakeup_policy), |
27 set_index_(0), | 26 set_index_(0), |
28 should_monitor_quiescence_(spec.should_monitor_quiescence), | 27 should_monitor_quiescence_(spec.should_monitor_quiescence), |
29 should_notify_observers_(spec.should_notify_observers) {} | 28 should_notify_observers_(spec.should_notify_observers) {} |
30 | 29 |
31 TaskQueueImpl::~TaskQueueImpl() {} | 30 TaskQueueImpl::~TaskQueueImpl() {} |
32 | 31 |
| 32 TaskQueueImpl::Task::Task() |
| 33 : PendingTask(tracked_objects::Location(), |
| 34 base::Closure(), |
| 35 base::TimeTicks(), |
| 36 true), |
| 37 #ifndef NDEBUG |
| 38 enqueue_order_set_(false), |
| 39 #endif |
| 40 enqueue_order_(0) { |
| 41 sequence_num = 0; |
| 42 } |
| 43 |
| 44 TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from, |
| 45 const base::Closure& task, |
| 46 int sequence_number, |
| 47 bool nestable) |
| 48 : PendingTask(posted_from, task, base::TimeTicks(), nestable), |
| 49 #ifndef NDEBUG |
| 50 enqueue_order_set_(false), |
| 51 #endif |
| 52 enqueue_order_(0) { |
| 53 sequence_num = sequence_number; |
| 54 } |
| 55 |
33 void TaskQueueImpl::WillDeleteTaskQueueManager() { | 56 void TaskQueueImpl::WillDeleteTaskQueueManager() { |
34 base::AutoLock lock(lock_); | 57 base::AutoLock lock(lock_); |
35 task_queue_manager_ = nullptr; | 58 task_queue_manager_ = nullptr; |
36 delayed_task_queue_ = base::DelayedTaskQueue(); | 59 delayed_task_queue_ = std::priority_queue<Task>(); |
37 incoming_queue_ = base::TaskQueue(); | 60 incoming_queue_ = std::queue<Task>(); |
38 work_queue_ = base::TaskQueue(); | 61 work_queue_ = std::queue<Task>(); |
39 } | 62 } |
40 | 63 |
41 bool TaskQueueImpl::RunsTasksOnCurrentThread() const { | 64 bool TaskQueueImpl::RunsTasksOnCurrentThread() const { |
42 base::AutoLock lock(lock_); | 65 base::AutoLock lock(lock_); |
43 return base::PlatformThread::CurrentId() == thread_id_; | 66 return base::PlatformThread::CurrentId() == thread_id_; |
44 } | 67 } |
45 | 68 |
46 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here, | 69 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here, |
47 const base::Closure& task, | 70 const base::Closure& task, |
48 base::TimeDelta delay) { | 71 base::TimeDelta delay) { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 } | 108 } |
86 | 109 |
87 bool TaskQueueImpl::PostDelayedTaskLocked( | 110 bool TaskQueueImpl::PostDelayedTaskLocked( |
88 LazyNow* lazy_now, | 111 LazyNow* lazy_now, |
89 const tracked_objects::Location& from_here, | 112 const tracked_objects::Location& from_here, |
90 const base::Closure& task, | 113 const base::Closure& task, |
91 base::TimeTicks desired_run_time, | 114 base::TimeTicks desired_run_time, |
92 TaskType task_type) { | 115 TaskType task_type) { |
93 lock_.AssertAcquired(); | 116 lock_.AssertAcquired(); |
94 DCHECK(task_queue_manager_); | 117 DCHECK(task_queue_manager_); |
95 | 118 Task pending_task(from_here, task, |
96 base::PendingTask pending_task(from_here, task, base::TimeTicks(), | 119 task_queue_manager_->GetNextSequenceNumber(), |
97 task_type != TaskType::NON_NESTABLE); | 120 task_type != TaskType::NON_NESTABLE); |
98 task_queue_manager_->DidQueueTask(pending_task); | 121 task_queue_manager_->DidQueueTask(pending_task); |
99 | 122 |
100 if (!desired_run_time.is_null()) { | 123 if (!desired_run_time.is_null()) { |
101 pending_task.delayed_run_time = std::max(lazy_now->Now(), desired_run_time); | 124 pending_task.delayed_run_time = std::max(lazy_now->Now(), desired_run_time); |
102 pending_task.sequence_num = delayed_task_sequence_number_++; | 125 // TODO(alexclarke): consider emplace() when C++11 library features allowed. |
103 delayed_task_queue_.push(pending_task); | 126 delayed_task_queue_.push(pending_task); |
104 TraceQueueSize(true); | 127 TraceQueueSize(true); |
105 // If we changed the topmost task, then it is time to reschedule. | 128 // If we changed the topmost task, then it is time to reschedule. |
106 if (delayed_task_queue_.top().task.Equals(pending_task.task)) | 129 if (delayed_task_queue_.top().task.Equals(pending_task.task)) |
107 ScheduleDelayedWorkLocked(lazy_now); | 130 ScheduleDelayedWorkLocked(lazy_now); |
108 return true; | 131 return true; |
109 } | 132 } |
110 EnqueueTaskLocked(pending_task); | 133 pending_task.set_enqueue_order(pending_task.sequence_num); |
| 134 EnqueueTaskLocked(pending_task, EnqueueOrderPolicy::DONT_SET_ENQUEUE_ORDER); |
111 return true; | 135 return true; |
112 } | 136 } |
113 | 137 |
114 void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue() { | 138 void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue() { |
115 DCHECK(main_thread_checker_.CalledOnValidThread()); | 139 DCHECK(main_thread_checker_.CalledOnValidThread()); |
116 base::AutoLock lock(lock_); | 140 base::AutoLock lock(lock_); |
117 if (!task_queue_manager_) | 141 if (!task_queue_manager_) |
118 return; | 142 return; |
119 | 143 |
120 LazyNow lazy_now(task_queue_manager_); | 144 LazyNow lazy_now(task_queue_manager_); |
121 MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now); | 145 MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now); |
122 } | 146 } |
123 | 147 |
124 void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueueLocked( | 148 void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueueLocked( |
125 LazyNow* lazy_now) { | 149 LazyNow* lazy_now) { |
126 lock_.AssertAcquired(); | 150 lock_.AssertAcquired(); |
127 // Enqueue all delayed tasks that should be running now. | 151 // Enqueue all delayed tasks that should be running now. |
128 while (!delayed_task_queue_.empty() && | 152 while (!delayed_task_queue_.empty() && |
129 delayed_task_queue_.top().delayed_run_time <= lazy_now->Now()) { | 153 delayed_task_queue_.top().delayed_run_time <= lazy_now->Now()) { |
130 in_flight_kick_delayed_tasks_.erase( | 154 in_flight_kick_delayed_tasks_.erase( |
131 delayed_task_queue_.top().delayed_run_time); | 155 delayed_task_queue_.top().delayed_run_time); |
132 EnqueueTaskLocked(delayed_task_queue_.top()); | 156 // TODO(alexclarke): consider std::move() when allowed. |
| 157 EnqueueTaskLocked(delayed_task_queue_.top(), |
| 158 EnqueueOrderPolicy::SET_ENQUEUE_ORDER); |
133 delayed_task_queue_.pop(); | 159 delayed_task_queue_.pop(); |
134 } | 160 } |
135 TraceQueueSize(true); | 161 TraceQueueSize(true); |
136 ScheduleDelayedWorkLocked(lazy_now); | 162 ScheduleDelayedWorkLocked(lazy_now); |
137 } | 163 } |
138 | 164 |
139 void TaskQueueImpl::ScheduleDelayedWorkLocked(LazyNow* lazy_now) { | 165 void TaskQueueImpl::ScheduleDelayedWorkLocked(LazyNow* lazy_now) { |
140 lock_.AssertAcquired(); | 166 lock_.AssertAcquired(); |
141 // Any remaining tasks are in the future, so queue a task to kick them. | 167 // Any remaining tasks are in the future, so queue a task to kick them. |
142 if (!delayed_task_queue_.empty()) { | 168 if (!delayed_task_queue_.empty()) { |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
174 { | 200 { |
175 base::AutoLock lock(lock_); | 201 base::AutoLock lock(lock_); |
176 if (incoming_queue_.empty()) { | 202 if (incoming_queue_.empty()) { |
177 return QueueState::EMPTY; | 203 return QueueState::EMPTY; |
178 } else { | 204 } else { |
179 return QueueState::NEEDS_PUMPING; | 205 return QueueState::NEEDS_PUMPING; |
180 } | 206 } |
181 } | 207 } |
182 } | 208 } |
183 | 209 |
184 bool TaskQueueImpl::TaskIsOlderThanQueuedTasks(const base::PendingTask* task) { | 210 bool TaskQueueImpl::TaskIsOlderThanQueuedTasks(const Task* task) { |
185 lock_.AssertAcquired(); | 211 lock_.AssertAcquired(); |
186 // A null task is passed when UpdateQueue is called before any task is run. | 212 // A null task is passed when UpdateQueue is called before any task is run. |
187 // In this case we don't want to pump an after_wakeup queue, so return true | 213 // In this case we don't want to pump an after_wakeup queue, so return true |
188 // here. | 214 // here. |
189 if (!task) | 215 if (!task) |
190 return true; | 216 return true; |
191 | 217 |
192 // Return false if there are no task in the incoming queue. | 218 // Return false if there are no task in the incoming queue. |
193 if (incoming_queue_.empty()) | 219 if (incoming_queue_.empty()) |
194 return false; | 220 return false; |
195 | 221 |
196 base::PendingTask oldest_queued_task = incoming_queue_.front(); | 222 const TaskQueueImpl::Task& oldest_queued_task = incoming_queue_.front(); |
197 DCHECK(oldest_queued_task.delayed_run_time.is_null()); | 223 return task->enqueue_order() < oldest_queued_task.enqueue_order(); |
198 DCHECK(task->delayed_run_time.is_null()); | |
199 | |
200 // Note: the comparison is correct due to the fact that the PendingTask | |
201 // operator inverts its comparison operation in order to work well in a heap | |
202 // based priority queue. | |
203 return oldest_queued_task < *task; | |
204 } | 224 } |
205 | 225 |
206 bool TaskQueueImpl::ShouldAutoPumpQueueLocked( | 226 bool TaskQueueImpl::ShouldAutoPumpQueueLocked(bool should_trigger_wakeup, |
207 bool should_trigger_wakeup, | 227 const Task* previous_task) { |
208 const base::PendingTask* previous_task) { | |
209 lock_.AssertAcquired(); | 228 lock_.AssertAcquired(); |
210 if (pump_policy_ == PumpPolicy::MANUAL) | 229 if (pump_policy_ == PumpPolicy::MANUAL) |
211 return false; | 230 return false; |
212 if (pump_policy_ == PumpPolicy::AFTER_WAKEUP && | 231 if (pump_policy_ == PumpPolicy::AFTER_WAKEUP && |
213 (!should_trigger_wakeup || TaskIsOlderThanQueuedTasks(previous_task))) | 232 (!should_trigger_wakeup || TaskIsOlderThanQueuedTasks(previous_task))) |
214 return false; | 233 return false; |
215 if (incoming_queue_.empty()) | 234 if (incoming_queue_.empty()) |
216 return false; | 235 return false; |
217 return true; | 236 return true; |
218 } | 237 } |
219 | 238 |
220 bool TaskQueueImpl::NextPendingDelayedTaskRunTime( | 239 bool TaskQueueImpl::NextPendingDelayedTaskRunTime( |
221 base::TimeTicks* next_pending_delayed_task) { | 240 base::TimeTicks* next_pending_delayed_task) { |
222 base::AutoLock lock(lock_); | 241 base::AutoLock lock(lock_); |
223 if (delayed_task_queue_.empty()) | 242 if (delayed_task_queue_.empty()) |
224 return false; | 243 return false; |
225 *next_pending_delayed_task = delayed_task_queue_.top().delayed_run_time; | 244 *next_pending_delayed_task = delayed_task_queue_.top().delayed_run_time; |
226 return true; | 245 return true; |
227 } | 246 } |
228 | 247 |
229 void TaskQueueImpl::UpdateWorkQueue(LazyNow* lazy_now, | 248 void TaskQueueImpl::UpdateWorkQueue(LazyNow* lazy_now, |
230 bool should_trigger_wakeup, | 249 bool should_trigger_wakeup, |
231 const base::PendingTask* previous_task) { | 250 const Task* previous_task) { |
232 DCHECK(work_queue_.empty()); | 251 DCHECK(work_queue_.empty()); |
233 base::AutoLock lock(lock_); | 252 base::AutoLock lock(lock_); |
234 if (!ShouldAutoPumpQueueLocked(should_trigger_wakeup, previous_task)) | 253 if (!ShouldAutoPumpQueueLocked(should_trigger_wakeup, previous_task)) |
235 return; | 254 return; |
236 MoveReadyDelayedTasksToIncomingQueueLocked(lazy_now); | 255 MoveReadyDelayedTasksToIncomingQueueLocked(lazy_now); |
237 work_queue_.Swap(&incoming_queue_); | 256 std::swap(work_queue_, incoming_queue_); |
238 // |incoming_queue_| is now empty so TaskQueueManager::UpdateQueues no | 257 // |incoming_queue_| is now empty so TaskQueueManager::UpdateQueues no |
239 // longer needs to consider this queue for reloading. | 258 // longer needs to consider this queue for reloading. |
240 task_queue_manager_->UnregisterAsUpdatableTaskQueue(this); | 259 task_queue_manager_->UnregisterAsUpdatableTaskQueue(this); |
241 if (!work_queue_.empty()) { | 260 if (!work_queue_.empty()) { |
242 DCHECK(task_queue_manager_); | 261 DCHECK(task_queue_manager_); |
243 task_queue_manager_->selector_.GetTaskQueueSets()->OnPushQueue(this); | 262 task_queue_manager_->selector_.GetTaskQueueSets()->OnPushQueue(this); |
244 TraceQueueSize(true); | 263 TraceQueueSize(true); |
245 } | 264 } |
246 } | 265 } |
247 | 266 |
248 base::PendingTask TaskQueueImpl::TakeTaskFromWorkQueue() { | 267 TaskQueueImpl::Task TaskQueueImpl::TakeTaskFromWorkQueue() { |
249 base::PendingTask pending_task = work_queue_.front(); | 268 // TODO(alexclarke): consider std::move() when allowed. |
| 269 Task pending_task = work_queue_.front(); |
250 work_queue_.pop(); | 270 work_queue_.pop(); |
251 DCHECK(task_queue_manager_); | 271 DCHECK(task_queue_manager_); |
252 task_queue_manager_->selector_.GetTaskQueueSets()->OnPopQueue(this); | 272 task_queue_manager_->selector_.GetTaskQueueSets()->OnPopQueue(this); |
253 TraceQueueSize(false); | 273 TraceQueueSize(false); |
254 return pending_task; | 274 return pending_task; |
255 } | 275 } |
256 | 276 |
257 void TaskQueueImpl::TraceQueueSize(bool is_locked) const { | 277 void TaskQueueImpl::TraceQueueSize(bool is_locked) const { |
258 bool is_tracing; | 278 bool is_tracing; |
259 TRACE_EVENT_CATEGORY_GROUP_ENABLED(disabled_by_default_tracing_category_, | 279 TRACE_EVENT_CATEGORY_GROUP_ENABLED(disabled_by_default_tracing_category_, |
260 &is_tracing); | 280 &is_tracing); |
261 if (!is_tracing) | 281 if (!is_tracing) |
262 return; | 282 return; |
263 if (!is_locked) | 283 if (!is_locked) |
264 lock_.Acquire(); | 284 lock_.Acquire(); |
265 else | 285 else |
266 lock_.AssertAcquired(); | 286 lock_.AssertAcquired(); |
267 TRACE_COUNTER1( | 287 TRACE_COUNTER1( |
268 disabled_by_default_tracing_category_, GetName(), | 288 disabled_by_default_tracing_category_, GetName(), |
269 incoming_queue_.size() + work_queue_.size() + delayed_task_queue_.size()); | 289 incoming_queue_.size() + work_queue_.size() + delayed_task_queue_.size()); |
270 if (!is_locked) | 290 if (!is_locked) |
271 lock_.Release(); | 291 lock_.Release(); |
272 } | 292 } |
273 | 293 |
274 void TaskQueueImpl::EnqueueTaskLocked(const base::PendingTask& pending_task) { | 294 void TaskQueueImpl::EnqueueTaskLocked(const Task& pending_task, |
| 295 EnqueueOrderPolicy enqueue_order_policy) { |
275 lock_.AssertAcquired(); | 296 lock_.AssertAcquired(); |
276 if (!task_queue_manager_) | 297 if (!task_queue_manager_) |
277 return; | 298 return; |
278 if (incoming_queue_.empty()) | 299 if (incoming_queue_.empty()) |
279 task_queue_manager_->RegisterAsUpdatableTaskQueue(this); | 300 task_queue_manager_->RegisterAsUpdatableTaskQueue(this); |
280 if (pump_policy_ == PumpPolicy::AUTO && incoming_queue_.empty()) | 301 if (pump_policy_ == PumpPolicy::AUTO && incoming_queue_.empty()) |
281 task_queue_manager_->MaybePostDoWorkOnMainRunner(); | 302 task_queue_manager_->MaybePostDoWorkOnMainRunner(); |
| 303 // TODO(alexclarke): consider std::move() when allowed. |
282 incoming_queue_.push(pending_task); | 304 incoming_queue_.push(pending_task); |
283 incoming_queue_.back().sequence_num = | 305 if (enqueue_order_policy == EnqueueOrderPolicy::SET_ENQUEUE_ORDER) { |
284 task_queue_manager_->GetNextSequenceNumber(); | 306 incoming_queue_.back().set_enqueue_order( |
285 | 307 task_queue_manager_->GetNextSequenceNumber()); |
286 if (!pending_task.delayed_run_time.is_null()) { | |
287 // Clear the delayed run time because we've already applied the delay | |
288 // before getting here. | |
289 incoming_queue_.back().delayed_run_time = base::TimeTicks(); | |
290 } | 308 } |
291 TraceQueueSize(true); | 309 TraceQueueSize(true); |
292 } | 310 } |
293 | 311 |
294 void TaskQueueImpl::SetPumpPolicy(PumpPolicy pump_policy) { | 312 void TaskQueueImpl::SetPumpPolicy(PumpPolicy pump_policy) { |
295 base::AutoLock lock(lock_); | 313 base::AutoLock lock(lock_); |
296 if (pump_policy == PumpPolicy::AUTO && pump_policy_ != PumpPolicy::AUTO) { | 314 if (pump_policy == PumpPolicy::AUTO && pump_policy_ != PumpPolicy::AUTO) { |
297 PumpQueueLocked(); | 315 PumpQueueLocked(); |
298 } | 316 } |
299 pump_policy_ = pump_policy; | 317 pump_policy_ = pump_policy; |
300 } | 318 } |
301 | 319 |
302 void TaskQueueImpl::PumpQueueLocked() { | 320 void TaskQueueImpl::PumpQueueLocked() { |
303 lock_.AssertAcquired(); | 321 lock_.AssertAcquired(); |
304 if (!task_queue_manager_) | 322 if (!task_queue_manager_) |
305 return; | 323 return; |
306 | 324 |
307 LazyNow lazy_now(task_queue_manager_); | 325 LazyNow lazy_now(task_queue_manager_); |
308 MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now); | 326 MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now); |
309 | 327 |
310 bool was_empty = work_queue_.empty(); | 328 bool was_empty = work_queue_.empty(); |
311 while (!incoming_queue_.empty()) { | 329 while (!incoming_queue_.empty()) { |
| 330 // TODO(alexclarke): consider std::move() when allowed. |
312 work_queue_.push(incoming_queue_.front()); | 331 work_queue_.push(incoming_queue_.front()); |
313 incoming_queue_.pop(); | 332 incoming_queue_.pop(); |
314 } | 333 } |
315 // |incoming_queue_| is now empty so TaskQueueManager::UpdateQueues no longer | 334 // |incoming_queue_| is now empty so TaskQueueManager::UpdateQueues no longer |
316 // needs to consider this queue for reloading. | 335 // needs to consider this queue for reloading. |
317 task_queue_manager_->UnregisterAsUpdatableTaskQueue(this); | 336 task_queue_manager_->UnregisterAsUpdatableTaskQueue(this); |
318 if (!work_queue_.empty()) { | 337 if (!work_queue_.empty()) { |
319 if (was_empty) | 338 if (was_empty) |
320 task_queue_manager_->selector_.GetTaskQueueSets()->OnPushQueue(this); | 339 task_queue_manager_->selector_.GetTaskQueueSets()->OnPushQueue(this); |
321 task_queue_manager_->MaybePostDoWorkOnMainRunner(); | 340 task_queue_manager_->MaybePostDoWorkOnMainRunner(); |
322 } | 341 } |
323 } | 342 } |
324 | 343 |
325 void TaskQueueImpl::PumpQueue() { | 344 void TaskQueueImpl::PumpQueue() { |
326 base::AutoLock lock(lock_); | 345 base::AutoLock lock(lock_); |
327 PumpQueueLocked(); | 346 PumpQueueLocked(); |
328 } | 347 } |
329 | 348 |
330 const char* TaskQueueImpl::GetName() const { | 349 const char* TaskQueueImpl::GetName() const { |
331 return name_; | 350 return name_; |
332 } | 351 } |
333 | 352 |
334 bool TaskQueueImpl::GetWorkQueueFrontTaskAge(int* age) const { | 353 bool TaskQueueImpl::GetWorkQueueFrontTaskEnqueueOrder( |
| 354 int* enqueue_order) const { |
335 if (work_queue_.empty()) | 355 if (work_queue_.empty()) |
336 return false; | 356 return false; |
337 *age = work_queue_.front().sequence_num; | 357 *enqueue_order = work_queue_.front().enqueue_order(); |
338 return true; | 358 return true; |
339 } | 359 } |
340 | 360 |
341 void TaskQueueImpl::PushTaskOntoWorkQueueForTest( | 361 void TaskQueueImpl::PushTaskOntoWorkQueueForTest(const Task& task) { |
342 const base::PendingTask& task) { | |
343 work_queue_.push(task); | 362 work_queue_.push(task); |
344 } | 363 } |
345 | 364 |
346 void TaskQueueImpl::PopTaskFromWorkQueueForTest() { | 365 void TaskQueueImpl::PopTaskFromWorkQueueForTest() { |
347 work_queue_.pop(); | 366 work_queue_.pop(); |
348 } | 367 } |
349 | 368 |
350 void TaskQueueImpl::SetQueuePriority(QueuePriority priority) { | 369 void TaskQueueImpl::SetQueuePriority(QueuePriority priority) { |
351 DCHECK(main_thread_checker_.CalledOnValidThread()); | 370 DCHECK(main_thread_checker_.CalledOnValidThread()); |
352 if (!task_queue_manager_) | 371 if (!task_queue_manager_) |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
426 state->BeginArray("delayed_task_queue"); | 445 state->BeginArray("delayed_task_queue"); |
427 QueueAsValueInto(delayed_task_queue_, state); | 446 QueueAsValueInto(delayed_task_queue_, state); |
428 state->EndArray(); | 447 state->EndArray(); |
429 } | 448 } |
430 state->SetString("priority", | 449 state->SetString("priority", |
431 PriorityToString(static_cast<QueuePriority>(set_index_))); | 450 PriorityToString(static_cast<QueuePriority>(set_index_))); |
432 state->EndDictionary(); | 451 state->EndDictionary(); |
433 } | 452 } |
434 | 453 |
435 // static | 454 // static |
436 void TaskQueueImpl::QueueAsValueInto(const base::TaskQueue& queue, | 455 void TaskQueueImpl::QueueAsValueInto(const std::queue<Task>& queue, |
437 base::trace_event::TracedValue* state) { | 456 base::trace_event::TracedValue* state) { |
438 base::TaskQueue queue_copy(queue); | 457 std::queue<Task> queue_copy(queue); |
439 while (!queue_copy.empty()) { | 458 while (!queue_copy.empty()) { |
440 TaskAsValueInto(queue_copy.front(), state); | 459 TaskAsValueInto(queue_copy.front(), state); |
441 queue_copy.pop(); | 460 queue_copy.pop(); |
442 } | 461 } |
443 } | 462 } |
444 | 463 |
445 // static | 464 // static |
446 void TaskQueueImpl::QueueAsValueInto(const base::DelayedTaskQueue& queue, | 465 void TaskQueueImpl::QueueAsValueInto(const std::priority_queue<Task>& queue, |
447 base::trace_event::TracedValue* state) { | 466 base::trace_event::TracedValue* state) { |
448 base::DelayedTaskQueue queue_copy(queue); | 467 std::priority_queue<Task> queue_copy(queue); |
449 while (!queue_copy.empty()) { | 468 while (!queue_copy.empty()) { |
450 TaskAsValueInto(queue_copy.top(), state); | 469 TaskAsValueInto(queue_copy.top(), state); |
451 queue_copy.pop(); | 470 queue_copy.pop(); |
452 } | 471 } |
453 } | 472 } |
454 | 473 |
455 // static | 474 // static |
456 void TaskQueueImpl::TaskAsValueInto(const base::PendingTask& task, | 475 void TaskQueueImpl::TaskAsValueInto(const Task& task, |
457 base::trace_event::TracedValue* state) { | 476 base::trace_event::TracedValue* state) { |
458 state->BeginDictionary(); | 477 state->BeginDictionary(); |
459 state->SetString("posted_from", task.posted_from.ToString()); | 478 state->SetString("posted_from", task.posted_from.ToString()); |
| 479 state->SetInteger("enqueue_order", task.enqueue_order()); |
460 state->SetInteger("sequence_num", task.sequence_num); | 480 state->SetInteger("sequence_num", task.sequence_num); |
461 state->SetBoolean("nestable", task.nestable); | 481 state->SetBoolean("nestable", task.nestable); |
462 state->SetBoolean("is_high_res", task.is_high_res); | 482 state->SetBoolean("is_high_res", task.is_high_res); |
463 state->SetDouble( | 483 state->SetDouble( |
464 "delayed_run_time", | 484 "delayed_run_time", |
465 (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L); | 485 (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L); |
466 state->EndDictionary(); | 486 state->EndDictionary(); |
467 } | 487 } |
468 | 488 |
469 } // namespace internal | 489 } // namespace internal |
470 } // namespace scheduler | 490 } // namespace scheduler |
OLD | NEW |