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/base/task_queue_impl.h" | 5 #include "components/scheduler/base/task_queue_impl.h" |
6 | 6 |
7 #include "components/scheduler/base/task_queue_manager.h" | 7 #include "components/scheduler/base/task_queue_manager.h" |
8 #include "components/scheduler/base/task_queue_manager_delegate.h" | 8 #include "components/scheduler/base/task_queue_manager_delegate.h" |
9 #include "components/scheduler/base/time_domain.h" | |
9 | 10 |
10 namespace scheduler { | 11 namespace scheduler { |
11 namespace internal { | 12 namespace internal { |
12 | 13 |
13 TaskQueueImpl::TaskQueueImpl( | 14 TaskQueueImpl::TaskQueueImpl( |
14 TaskQueueManager* task_queue_manager, | 15 TaskQueueManager* task_queue_manager, |
16 const scoped_refptr<TimeDomain>& time_domain, | |
15 const Spec& spec, | 17 const Spec& spec, |
16 const char* disabled_by_default_tracing_category, | 18 const char* disabled_by_default_tracing_category, |
17 const char* disabled_by_default_verbose_tracing_category) | 19 const char* disabled_by_default_verbose_tracing_category) |
18 : thread_id_(base::PlatformThread::CurrentId()), | 20 : thread_id_(base::PlatformThread::CurrentId()), |
19 any_thread_(task_queue_manager, spec.pump_policy), | 21 any_thread_(task_queue_manager, spec.pump_policy, time_domain), |
20 name_(spec.name), | 22 name_(spec.name), |
21 disabled_by_default_tracing_category_( | 23 disabled_by_default_tracing_category_( |
22 disabled_by_default_tracing_category), | 24 disabled_by_default_tracing_category), |
23 disabled_by_default_verbose_tracing_category_( | 25 disabled_by_default_verbose_tracing_category_( |
24 disabled_by_default_verbose_tracing_category), | 26 disabled_by_default_verbose_tracing_category), |
25 main_thread_only_(task_queue_manager), | 27 main_thread_only_(task_queue_manager), |
26 wakeup_policy_(spec.wakeup_policy), | 28 wakeup_policy_(spec.wakeup_policy), |
27 should_monitor_quiescence_(spec.should_monitor_quiescence), | 29 should_monitor_quiescence_(spec.should_monitor_quiescence), |
28 should_notify_observers_(spec.should_notify_observers) {} | 30 should_notify_observers_(spec.should_notify_observers) { |
31 DCHECK(time_domain.get()); | |
32 } | |
29 | 33 |
30 TaskQueueImpl::~TaskQueueImpl() {} | 34 TaskQueueImpl::~TaskQueueImpl() {} |
31 | 35 |
32 TaskQueueImpl::Task::Task() | 36 TaskQueueImpl::Task::Task() |
33 : PendingTask(tracked_objects::Location(), | 37 : PendingTask(tracked_objects::Location(), |
34 base::Closure(), | 38 base::Closure(), |
35 base::TimeTicks(), | 39 base::TimeTicks(), |
36 true), | 40 true), |
37 #ifndef NDEBUG | 41 #ifndef NDEBUG |
38 enqueue_order_set_(false), | 42 enqueue_order_set_(false), |
39 #endif | 43 #endif |
40 enqueue_order_(0) { | 44 enqueue_order_(0) { |
41 sequence_num = 0; | 45 sequence_num = 0; |
42 } | 46 } |
43 | 47 |
44 TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from, | 48 TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from, |
45 const base::Closure& task, | 49 const base::Closure& task, |
46 int sequence_number, | 50 int sequence_number, |
47 bool nestable) | 51 bool nestable) |
48 : PendingTask(posted_from, task, base::TimeTicks(), nestable), | 52 : PendingTask(posted_from, task, base::TimeTicks(), nestable), |
49 #ifndef NDEBUG | 53 #ifndef NDEBUG |
50 enqueue_order_set_(false), | 54 enqueue_order_set_(false), |
51 #endif | 55 #endif |
52 enqueue_order_(0) { | 56 enqueue_order_(0) { |
53 sequence_num = sequence_number; | 57 sequence_num = sequence_number; |
54 } | 58 } |
55 | 59 |
56 TaskQueueImpl::AnyThread::AnyThread(TaskQueueManager* task_queue_manager, | 60 TaskQueueImpl::AnyThread::AnyThread( |
57 PumpPolicy pump_policy) | 61 TaskQueueManager* task_queue_manager, |
58 : task_queue_manager(task_queue_manager), pump_policy(pump_policy) {} | 62 PumpPolicy pump_policy, |
63 const scoped_refptr<TimeDomain>& time_domain) | |
64 : task_queue_manager(task_queue_manager), | |
65 pump_policy(pump_policy), | |
66 time_domain(time_domain) {} | |
59 | 67 |
60 TaskQueueImpl::AnyThread::~AnyThread() {} | 68 TaskQueueImpl::AnyThread::~AnyThread() {} |
61 | 69 |
62 TaskQueueImpl::MainThreadOnly::MainThreadOnly( | 70 TaskQueueImpl::MainThreadOnly::MainThreadOnly( |
63 TaskQueueManager* task_queue_manager) | 71 TaskQueueManager* task_queue_manager) |
64 : task_queue_manager(task_queue_manager), | 72 : task_queue_manager(task_queue_manager), |
65 set_index(0) {} | 73 set_index(0) {} |
66 | 74 |
67 TaskQueueImpl::MainThreadOnly::~MainThreadOnly() {} | 75 TaskQueueImpl::MainThreadOnly::~MainThreadOnly() {} |
68 | 76 |
69 void TaskQueueImpl::UnregisterTaskQueue() { | 77 void TaskQueueImpl::UnregisterTaskQueue() { |
70 base::AutoLock lock(any_thread_lock_); | 78 base::AutoLock lock(any_thread_lock_); |
71 if (!any_thread().task_queue_manager) | 79 if (!any_thread().task_queue_manager) |
72 return; | 80 return; |
81 any_thread().time_domain->UnregisterQueue(this); | |
82 any_thread().time_domain = scoped_refptr<TimeDomain>(); | |
Sami
2015/11/18 18:36:24
IIRC you can do = nullptr.
| |
73 any_thread().task_queue_manager->UnregisterTaskQueue(this); | 83 any_thread().task_queue_manager->UnregisterTaskQueue(this); |
74 | 84 |
75 any_thread().task_queue_manager = nullptr; | 85 any_thread().task_queue_manager = nullptr; |
76 main_thread_only().task_queue_manager = nullptr; | 86 main_thread_only().task_queue_manager = nullptr; |
77 any_thread().delayed_task_queue = std::priority_queue<Task>(); | 87 any_thread().delayed_task_queue = std::priority_queue<Task>(); |
78 any_thread().incoming_queue = std::queue<Task>(); | 88 any_thread().incoming_queue = std::queue<Task>(); |
79 main_thread_only().work_queue = std::queue<Task>(); | 89 main_thread_only().work_queue = std::queue<Task>(); |
80 } | 90 } |
81 | 91 |
82 bool TaskQueueImpl::RunsTasksOnCurrentThread() const { | 92 bool TaskQueueImpl::RunsTasksOnCurrentThread() const { |
(...skipping 14 matching lines...) Expand all Loading... | |
97 return PostDelayedTaskImpl(from_here, task, delay, TaskType::NON_NESTABLE); | 107 return PostDelayedTaskImpl(from_here, task, delay, TaskType::NON_NESTABLE); |
98 } | 108 } |
99 | 109 |
100 bool TaskQueueImpl::PostDelayedTaskAt( | 110 bool TaskQueueImpl::PostDelayedTaskAt( |
101 const tracked_objects::Location& from_here, | 111 const tracked_objects::Location& from_here, |
102 const base::Closure& task, | 112 const base::Closure& task, |
103 base::TimeTicks desired_run_time) { | 113 base::TimeTicks desired_run_time) { |
104 base::AutoLock lock(any_thread_lock_); | 114 base::AutoLock lock(any_thread_lock_); |
105 if (!any_thread().task_queue_manager) | 115 if (!any_thread().task_queue_manager) |
106 return false; | 116 return false; |
107 LazyNow lazy_now(any_thread().task_queue_manager->delegate().get()); | 117 LazyNow lazy_now(any_thread().time_domain->GetLazyNow()); |
108 return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time, | 118 return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time, |
109 TaskType::NORMAL); | 119 TaskType::NORMAL); |
110 } | 120 } |
111 | 121 |
112 bool TaskQueueImpl::PostDelayedTaskImpl( | 122 bool TaskQueueImpl::PostDelayedTaskImpl( |
113 const tracked_objects::Location& from_here, | 123 const tracked_objects::Location& from_here, |
114 const base::Closure& task, | 124 const base::Closure& task, |
115 base::TimeDelta delay, | 125 base::TimeDelta delay, |
116 TaskType task_type) { | 126 TaskType task_type) { |
117 base::AutoLock lock(any_thread_lock_); | 127 base::AutoLock lock(any_thread_lock_); |
118 if (!any_thread().task_queue_manager) | 128 if (!any_thread().task_queue_manager) |
119 return false; | 129 return false; |
120 LazyNow lazy_now(any_thread().task_queue_manager->delegate().get()); | 130 LazyNow lazy_now(any_thread().time_domain->GetLazyNow()); |
121 base::TimeTicks desired_run_time; | 131 base::TimeTicks desired_run_time; |
122 if (delay > base::TimeDelta()) | 132 if (delay > base::TimeDelta()) |
123 desired_run_time = lazy_now.Now() + delay; | 133 desired_run_time = lazy_now.Now() + delay; |
124 return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time, | 134 return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time, |
125 task_type); | 135 task_type); |
126 } | 136 } |
127 | 137 |
128 bool TaskQueueImpl::PostDelayedTaskLocked( | 138 bool TaskQueueImpl::PostDelayedTaskLocked( |
129 LazyNow* lazy_now, | 139 LazyNow* lazy_now, |
130 const tracked_objects::Location& from_here, | 140 const tracked_objects::Location& from_here, |
131 const base::Closure& task, | 141 const base::Closure& task, |
132 base::TimeTicks desired_run_time, | 142 base::TimeTicks desired_run_time, |
133 TaskType task_type) { | 143 TaskType task_type) { |
134 DCHECK(any_thread().task_queue_manager); | 144 DCHECK(any_thread().task_queue_manager); |
135 Task pending_task(from_here, task, | 145 Task pending_task(from_here, task, |
136 any_thread().task_queue_manager->GetNextSequenceNumber(), | 146 any_thread().task_queue_manager->GetNextSequenceNumber(), |
137 task_type != TaskType::NON_NESTABLE); | 147 task_type != TaskType::NON_NESTABLE); |
138 any_thread().task_queue_manager->DidQueueTask(pending_task); | 148 any_thread().task_queue_manager->DidQueueTask(pending_task); |
139 | 149 |
140 if (!desired_run_time.is_null()) { | 150 if (!desired_run_time.is_null()) { |
141 pending_task.delayed_run_time = std::max(lazy_now->Now(), desired_run_time); | 151 pending_task.delayed_run_time = std::max(lazy_now->Now(), desired_run_time); |
142 // TODO(alexclarke): consider emplace() when C++11 library features allowed. | 152 // TODO(alexclarke): consider emplace() when C++11 library features allowed. |
143 any_thread().delayed_task_queue.push(pending_task); | 153 any_thread().delayed_task_queue.push(pending_task); |
144 TraceQueueSize(true); | 154 TraceQueueSize(true); |
145 // Schedule a later call to MoveReadyDelayedTasksToIncomingQueue. | 155 // Schedule a later call to MoveReadyDelayedTasksToIncomingQueue. |
146 any_thread().task_queue_manager->ScheduleDelayedWork(this, desired_run_time, | 156 any_thread().time_domain->ScheduleDelayedWork(this, desired_run_time, |
147 lazy_now); | 157 lazy_now); |
148 return true; | 158 return true; |
149 } | 159 } |
150 pending_task.set_enqueue_order(pending_task.sequence_num); | 160 pending_task.set_enqueue_order(pending_task.sequence_num); |
151 EnqueueTaskLocked(pending_task); | 161 EnqueueTaskLocked(pending_task); |
152 return true; | 162 return true; |
153 } | 163 } |
154 | 164 |
155 void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue(LazyNow* lazy_now) { | 165 void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue(LazyNow* lazy_now) { |
156 base::AutoLock lock(any_thread_lock_); | 166 base::AutoLock lock(any_thread_lock_); |
157 if (!any_thread().task_queue_manager) | 167 if (!any_thread().task_queue_manager) |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
235 void TaskQueueImpl::UpdateWorkQueue(LazyNow* lazy_now, | 245 void TaskQueueImpl::UpdateWorkQueue(LazyNow* lazy_now, |
236 bool should_trigger_wakeup, | 246 bool should_trigger_wakeup, |
237 const Task* previous_task) { | 247 const Task* previous_task) { |
238 DCHECK(main_thread_only().work_queue.empty()); | 248 DCHECK(main_thread_only().work_queue.empty()); |
239 base::AutoLock lock(any_thread_lock_); | 249 base::AutoLock lock(any_thread_lock_); |
240 if (!ShouldAutoPumpQueueLocked(should_trigger_wakeup, previous_task)) | 250 if (!ShouldAutoPumpQueueLocked(should_trigger_wakeup, previous_task)) |
241 return; | 251 return; |
242 MoveReadyDelayedTasksToIncomingQueueLocked(lazy_now); | 252 MoveReadyDelayedTasksToIncomingQueueLocked(lazy_now); |
243 std::swap(main_thread_only().work_queue, any_thread().incoming_queue); | 253 std::swap(main_thread_only().work_queue, any_thread().incoming_queue); |
244 // |any_thread().incoming_queue| is now empty so | 254 // |any_thread().incoming_queue| is now empty so |
245 // TaskQueueManager::UpdateQueues no longer needs to consider | 255 // TaskQueueManager::UpdateQueues no longer needs to consider |
Sami
2015/11/18 18:36:24
nit: function name is out of date.
alex clarke (OOO till 29th)
2015/11/19 12:20:12
Done.
| |
246 // this queue for reloading. | 256 // this queue for reloading. |
247 any_thread().task_queue_manager->UnregisterAsUpdatableTaskQueue(this); | 257 any_thread().time_domain->UnregisterAsUpdatableTaskQueue(this); |
248 if (!main_thread_only().work_queue.empty()) { | 258 if (!main_thread_only().work_queue.empty()) { |
249 DCHECK(any_thread().task_queue_manager); | 259 DCHECK(any_thread().task_queue_manager); |
250 any_thread().task_queue_manager->selector_.GetTaskQueueSets()->OnPushQueue( | 260 any_thread().task_queue_manager->selector_.GetTaskQueueSets()->OnPushQueue( |
251 this); | 261 this); |
252 TraceQueueSize(true); | 262 TraceQueueSize(true); |
253 } | 263 } |
254 } | 264 } |
255 | 265 |
256 TaskQueueImpl::Task TaskQueueImpl::TakeTaskFromWorkQueue() { | 266 TaskQueueImpl::Task TaskQueueImpl::TakeTaskFromWorkQueue() { |
257 // TODO(alexclarke): consider std::move() when allowed. | 267 // TODO(alexclarke): consider std::move() when allowed. |
(...skipping 22 matching lines...) Expand all Loading... | |
280 main_thread_only().work_queue.size() + | 290 main_thread_only().work_queue.size() + |
281 any_thread().delayed_task_queue.size()); | 291 any_thread().delayed_task_queue.size()); |
282 if (!is_locked) | 292 if (!is_locked) |
283 any_thread_lock_.Release(); | 293 any_thread_lock_.Release(); |
284 } | 294 } |
285 | 295 |
286 void TaskQueueImpl::EnqueueTaskLocked(const Task& pending_task) { | 296 void TaskQueueImpl::EnqueueTaskLocked(const Task& pending_task) { |
287 if (!any_thread().task_queue_manager) | 297 if (!any_thread().task_queue_manager) |
288 return; | 298 return; |
289 if (any_thread().incoming_queue.empty()) | 299 if (any_thread().incoming_queue.empty()) |
290 any_thread().task_queue_manager->RegisterAsUpdatableTaskQueue(this); | 300 any_thread().time_domain->RegisterAsUpdatableTaskQueue(this); |
291 if (any_thread().pump_policy == PumpPolicy::AUTO && | 301 if (any_thread().pump_policy == PumpPolicy::AUTO && |
292 any_thread().incoming_queue.empty()) { | 302 any_thread().incoming_queue.empty()) { |
293 any_thread().task_queue_manager->MaybePostDoWorkOnMainRunner(); | 303 any_thread().task_queue_manager->MaybePostDoWorkOnMainRunner(); |
294 } | 304 } |
295 // TODO(alexclarke): consider std::move() when allowed. | 305 // TODO(alexclarke): consider std::move() when allowed. |
296 any_thread().incoming_queue.push(pending_task); | 306 any_thread().incoming_queue.push(pending_task); |
297 TraceQueueSize(true); | 307 TraceQueueSize(true); |
298 } | 308 } |
299 | 309 |
300 void TaskQueueImpl::EnqueueDelayedTaskLocked(const Task& pending_task) { | 310 void TaskQueueImpl::EnqueueDelayedTaskLocked(const Task& pending_task) { |
301 if (!any_thread().task_queue_manager) | 311 if (!any_thread().task_queue_manager) |
302 return; | 312 return; |
303 if (any_thread().incoming_queue.empty()) | 313 if (any_thread().incoming_queue.empty()) |
304 any_thread().task_queue_manager->RegisterAsUpdatableTaskQueue(this); | 314 any_thread().time_domain->RegisterAsUpdatableTaskQueue(this); |
305 // TODO(alexclarke): consider std::move() when allowed. | 315 // TODO(alexclarke): consider std::move() when allowed. |
306 any_thread().incoming_queue.push(pending_task); | 316 any_thread().incoming_queue.push(pending_task); |
307 any_thread().incoming_queue.back().set_enqueue_order( | 317 any_thread().incoming_queue.back().set_enqueue_order( |
308 any_thread().task_queue_manager->GetNextSequenceNumber()); | 318 any_thread().task_queue_manager->GetNextSequenceNumber()); |
309 TraceQueueSize(true); | 319 TraceQueueSize(true); |
310 } | 320 } |
311 | 321 |
312 void TaskQueueImpl::SetPumpPolicy(PumpPolicy pump_policy) { | 322 void TaskQueueImpl::SetPumpPolicy(PumpPolicy pump_policy) { |
313 base::AutoLock lock(any_thread_lock_); | 323 base::AutoLock lock(any_thread_lock_); |
314 if (pump_policy == PumpPolicy::AUTO && | 324 if (pump_policy == PumpPolicy::AUTO && |
315 any_thread().pump_policy != PumpPolicy::AUTO) { | 325 any_thread().pump_policy != PumpPolicy::AUTO) { |
316 PumpQueueLocked(); | 326 PumpQueueLocked(); |
317 } | 327 } |
318 any_thread().pump_policy = pump_policy; | 328 any_thread().pump_policy = pump_policy; |
319 } | 329 } |
320 | 330 |
321 void TaskQueueImpl::PumpQueueLocked() { | 331 void TaskQueueImpl::PumpQueueLocked() { |
322 if (!any_thread().task_queue_manager) | 332 if (!any_thread().task_queue_manager) |
323 return; | 333 return; |
324 | 334 |
325 LazyNow lazy_now(any_thread().task_queue_manager->delegate().get()); | 335 LazyNow lazy_now(any_thread().time_domain->GetLazyNow()); |
326 MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now); | 336 MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now); |
327 | 337 |
328 bool was_empty = main_thread_only().work_queue.empty(); | 338 bool was_empty = main_thread_only().work_queue.empty(); |
329 while (!any_thread().incoming_queue.empty()) { | 339 while (!any_thread().incoming_queue.empty()) { |
330 // TODO(alexclarke): consider std::move() when allowed. | 340 // TODO(alexclarke): consider std::move() when allowed. |
331 main_thread_only().work_queue.push(any_thread().incoming_queue.front()); | 341 main_thread_only().work_queue.push(any_thread().incoming_queue.front()); |
332 any_thread().incoming_queue.pop(); | 342 any_thread().incoming_queue.pop(); |
333 } | 343 } |
334 // |incoming_queue| is now empty so TaskQueueManager::UpdateQueues no longer | 344 // |incoming_queue| is now empty so TaskQueueManager::UpdateQueues no longer |
Sami
2015/11/18 18:36:24
nit: function name is out of date.
alex clarke (OOO till 29th)
2015/11/19 12:20:12
Done.
| |
335 // needs to consider this queue for reloading. | 345 // needs to consider this queue for reloading. |
336 any_thread().task_queue_manager->UnregisterAsUpdatableTaskQueue(this); | 346 any_thread().time_domain->UnregisterAsUpdatableTaskQueue(this); |
337 if (!main_thread_only().work_queue.empty()) { | 347 if (!main_thread_only().work_queue.empty()) { |
338 if (was_empty) { | 348 if (was_empty) { |
339 any_thread() | 349 any_thread() |
340 .task_queue_manager->selector_.GetTaskQueueSets() | 350 .task_queue_manager->selector_.GetTaskQueueSets() |
341 ->OnPushQueue(this); | 351 ->OnPushQueue(this); |
342 } | 352 } |
343 any_thread().task_queue_manager->MaybePostDoWorkOnMainRunner(); | 353 any_thread().task_queue_manager->MaybePostDoWorkOnMainRunner(); |
344 } | 354 } |
345 } | 355 } |
346 | 356 |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
423 default: | 433 default: |
424 NOTREACHED(); | 434 NOTREACHED(); |
425 return nullptr; | 435 return nullptr; |
426 } | 436 } |
427 } | 437 } |
428 | 438 |
429 void TaskQueueImpl::AsValueInto(base::trace_event::TracedValue* state) const { | 439 void TaskQueueImpl::AsValueInto(base::trace_event::TracedValue* state) const { |
430 base::AutoLock lock(any_thread_lock_); | 440 base::AutoLock lock(any_thread_lock_); |
431 state->BeginDictionary(); | 441 state->BeginDictionary(); |
432 state->SetString("name", GetName()); | 442 state->SetString("name", GetName()); |
443 state->SetString("time_domain_name", any_thread().time_domain->GetName()); | |
433 state->SetString("pump_policy", PumpPolicyToString(any_thread().pump_policy)); | 444 state->SetString("pump_policy", PumpPolicyToString(any_thread().pump_policy)); |
434 state->SetString("wakeup_policy", WakeupPolicyToString(wakeup_policy_)); | 445 state->SetString("wakeup_policy", WakeupPolicyToString(wakeup_policy_)); |
435 bool verbose_tracing_enabled = false; | 446 bool verbose_tracing_enabled = false; |
436 TRACE_EVENT_CATEGORY_GROUP_ENABLED( | 447 TRACE_EVENT_CATEGORY_GROUP_ENABLED( |
437 disabled_by_default_verbose_tracing_category_, &verbose_tracing_enabled); | 448 disabled_by_default_verbose_tracing_category_, &verbose_tracing_enabled); |
438 state->SetInteger("incoming_queue_size", any_thread().incoming_queue.size()); | 449 state->SetInteger("incoming_queue_size", any_thread().incoming_queue.size()); |
439 state->SetInteger("work_queue_size", main_thread_only().work_queue.size()); | 450 state->SetInteger("work_queue_size", main_thread_only().work_queue.size()); |
440 state->SetInteger("delayed_task_queue_size", | 451 state->SetInteger("delayed_task_queue_size", |
441 any_thread().delayed_task_queue.size()); | 452 any_thread().delayed_task_queue.size()); |
442 if (verbose_tracing_enabled) { | 453 if (verbose_tracing_enabled) { |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
509 state->SetInteger("enqueue_order", task.enqueue_order()); | 520 state->SetInteger("enqueue_order", task.enqueue_order()); |
510 state->SetInteger("sequence_num", task.sequence_num); | 521 state->SetInteger("sequence_num", task.sequence_num); |
511 state->SetBoolean("nestable", task.nestable); | 522 state->SetBoolean("nestable", task.nestable); |
512 state->SetBoolean("is_high_res", task.is_high_res); | 523 state->SetBoolean("is_high_res", task.is_high_res); |
513 state->SetDouble( | 524 state->SetDouble( |
514 "delayed_run_time", | 525 "delayed_run_time", |
515 (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L); | 526 (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L); |
516 state->EndDictionary(); | 527 state->EndDictionary(); |
517 } | 528 } |
518 | 529 |
530 size_t TaskQueueImpl::IncomingQueueSizeForTest() const { | |
531 base::AutoLock lock(any_thread_lock_); | |
532 return any_thread().incoming_queue.size(); | |
533 } | |
534 | |
519 } // namespace internal | 535 } // namespace internal |
520 } // namespace scheduler | 536 } // namespace scheduler |
OLD | NEW |