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 "platform/scheduler/renderer/renderer_scheduler_impl.h" | 5 #include "platform/scheduler/renderer/renderer_scheduler_impl.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/debug/stack_trace.h" | 8 #include "base/debug/stack_trace.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
94 idle_helper_(&helper_, | 94 idle_helper_(&helper_, |
95 this, | 95 this, |
96 "renderer.scheduler", | 96 "renderer.scheduler", |
97 TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), | 97 TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), |
98 "RendererSchedulerIdlePeriod", | 98 "RendererSchedulerIdlePeriod", |
99 base::TimeDelta()), | 99 base::TimeDelta()), |
100 idle_canceled_delayed_task_sweeper_("renderer.scheduler", | 100 idle_canceled_delayed_task_sweeper_("renderer.scheduler", |
101 &helper_, | 101 &helper_, |
102 idle_helper_.IdleTaskRunner()), | 102 idle_helper_.IdleTaskRunner()), |
103 render_widget_scheduler_signals_(this), | 103 render_widget_scheduler_signals_(this), |
104 control_task_runner_(helper_.ControlTaskQueue()), | 104 control_task_queue_(helper_.ControlTaskQueue()), |
105 compositor_task_runner_( | 105 compositor_task_queue_( |
106 helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR) | 106 helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR) |
107 .SetShouldMonitorQuiescence(true))), | 107 .SetShouldMonitorQuiescence(true))), |
108 compositor_task_runner_enabled_voter_( | 108 compositor_task_queue_enabled_voter_( |
109 compositor_task_runner_->CreateQueueEnabledVoter()), | 109 compositor_task_queue_->CreateQueueEnabledVoter()), |
110 delayed_update_policy_runner_( | 110 delayed_update_policy_runner_( |
111 base::Bind(&RendererSchedulerImpl::UpdatePolicy, | 111 base::Bind(&RendererSchedulerImpl::UpdatePolicy, |
112 base::Unretained(this)), | 112 base::Unretained(this)), |
113 helper_.ControlTaskQueue()), | 113 helper_.ControlTaskQueue()), |
114 seqlock_queueing_time_estimator_( | 114 seqlock_queueing_time_estimator_( |
115 QueueingTimeEstimator(this, base::TimeDelta::FromSeconds(1))), | 115 QueueingTimeEstimator(this, base::TimeDelta::FromSeconds(1))), |
116 main_thread_only_(this, | 116 main_thread_only_(this, |
117 compositor_task_runner_, | 117 compositor_task_queue_, |
118 helper_.scheduler_tqm_delegate().get(), | 118 helper_.scheduler_tqm_delegate().get(), |
119 helper_.scheduler_tqm_delegate()->NowTicks()), | 119 helper_.scheduler_tqm_delegate()->NowTicks()), |
120 policy_may_need_update_(&any_thread_lock_), | 120 policy_may_need_update_(&any_thread_lock_), |
121 weak_factory_(this) { | 121 weak_factory_(this) { |
122 task_queue_throttler_.reset( | 122 task_queue_throttler_.reset( |
123 new TaskQueueThrottler(this, "renderer.scheduler")); | 123 new TaskQueueThrottler(this, "renderer.scheduler")); |
124 update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy, | 124 update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy, |
125 weak_factory_.GetWeakPtr()); | 125 weak_factory_.GetWeakPtr()); |
126 end_renderer_hidden_idle_period_closure_.Reset(base::Bind( | 126 end_renderer_hidden_idle_period_closure_.Reset(base::Bind( |
127 &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr())); | 127 &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr())); |
128 | 128 |
129 suspend_timers_when_backgrounded_closure_.Reset( | 129 suspend_timers_when_backgrounded_closure_.Reset( |
130 base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded, | 130 base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded, |
131 weak_factory_.GetWeakPtr())); | 131 weak_factory_.GetWeakPtr())); |
132 | 132 |
133 default_loading_task_runner_ = | 133 default_loading_task_queue_ = |
134 NewLoadingTaskQueue(TaskQueue::QueueType::DEFAULT_LOADING); | 134 NewLoadingTaskQueue(TaskQueue::QueueType::DEFAULT_LOADING); |
135 default_timer_task_runner_ = | 135 default_timer_task_queue_ = |
136 NewTimerTaskQueue(TaskQueue::QueueType::DEFAULT_TIMER); | 136 NewTimerTaskQueue(TaskQueue::QueueType::DEFAULT_TIMER); |
137 | 137 |
138 TRACE_EVENT_OBJECT_CREATED_WITH_ID( | 138 TRACE_EVENT_OBJECT_CREATED_WITH_ID( |
139 TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler", | 139 TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler", |
140 this); | 140 this); |
141 | 141 |
142 helper_.SetObserver(this); | 142 helper_.SetObserver(this); |
143 helper_.AddTaskTimeObserver(this); | 143 helper_.AddTaskTimeObserver(this); |
144 | 144 |
145 // Register a tracing state observer unless we're running in a test without a | 145 // Register a tracing state observer unless we're running in a test without a |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
265 } | 265 } |
266 | 266 |
267 scoped_refptr<base::SingleThreadTaskRunner> | 267 scoped_refptr<base::SingleThreadTaskRunner> |
268 RendererSchedulerImpl::DefaultTaskRunner() { | 268 RendererSchedulerImpl::DefaultTaskRunner() { |
269 return helper_.DefaultTaskQueue(); | 269 return helper_.DefaultTaskQueue(); |
270 } | 270 } |
271 | 271 |
272 scoped_refptr<base::SingleThreadTaskRunner> | 272 scoped_refptr<base::SingleThreadTaskRunner> |
273 RendererSchedulerImpl::CompositorTaskRunner() { | 273 RendererSchedulerImpl::CompositorTaskRunner() { |
274 helper_.CheckOnValidThread(); | 274 helper_.CheckOnValidThread(); |
275 return compositor_task_runner_; | 275 return compositor_task_queue_; |
276 } | 276 } |
277 | 277 |
278 scoped_refptr<SingleThreadIdleTaskRunner> | 278 scoped_refptr<SingleThreadIdleTaskRunner> |
279 RendererSchedulerImpl::IdleTaskRunner() { | 279 RendererSchedulerImpl::IdleTaskRunner() { |
280 return idle_helper_.IdleTaskRunner(); | 280 return idle_helper_.IdleTaskRunner(); |
281 } | 281 } |
282 | 282 |
283 scoped_refptr<base::SingleThreadTaskRunner> | 283 scoped_refptr<base::SingleThreadTaskRunner> |
284 RendererSchedulerImpl::LoadingTaskRunner() { | 284 RendererSchedulerImpl::LoadingTaskRunner() { |
285 helper_.CheckOnValidThread(); | 285 helper_.CheckOnValidThread(); |
286 return default_loading_task_runner_; | 286 return default_loading_task_queue_; |
287 } | 287 } |
288 | 288 |
289 scoped_refptr<base::SingleThreadTaskRunner> | 289 scoped_refptr<base::SingleThreadTaskRunner> |
290 RendererSchedulerImpl::TimerTaskRunner() { | 290 RendererSchedulerImpl::TimerTaskRunner() { |
291 helper_.CheckOnValidThread(); | 291 helper_.CheckOnValidThread(); |
292 return default_timer_task_runner_; | 292 return default_timer_task_queue_; |
293 } | 293 } |
294 | 294 |
295 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskQueue() { | 295 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskQueue() { |
296 return helper_.DefaultTaskQueue(); | 296 return helper_.DefaultTaskQueue(); |
297 } | 297 } |
298 | 298 |
299 scoped_refptr<TaskQueue> RendererSchedulerImpl::CompositorTaskQueue() { | 299 scoped_refptr<TaskQueue> RendererSchedulerImpl::CompositorTaskQueue() { |
300 helper_.CheckOnValidThread(); | 300 helper_.CheckOnValidThread(); |
301 return compositor_task_runner_; | 301 return compositor_task_queue_; |
302 } | 302 } |
303 | 303 |
304 scoped_refptr<TaskQueue> RendererSchedulerImpl::LoadingTaskQueue() { | 304 scoped_refptr<TaskQueue> RendererSchedulerImpl::LoadingTaskQueue() { |
305 helper_.CheckOnValidThread(); | 305 helper_.CheckOnValidThread(); |
306 return default_loading_task_runner_; | 306 return default_loading_task_queue_; |
307 } | 307 } |
308 | 308 |
309 scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskQueue() { | 309 scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskQueue() { |
310 helper_.CheckOnValidThread(); | 310 helper_.CheckOnValidThread(); |
311 return default_timer_task_runner_; | 311 return default_timer_task_queue_; |
312 } | 312 } |
313 | 313 |
314 scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskQueue() { | 314 scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskQueue() { |
315 helper_.CheckOnValidThread(); | 315 helper_.CheckOnValidThread(); |
316 return helper_.ControlTaskQueue(); | 316 return helper_.ControlTaskQueue(); |
317 } | 317 } |
318 | 318 |
319 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskQueue( | 319 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskQueue( |
320 TaskQueue::QueueType queue_type) { | 320 TaskQueue::QueueType queue_type) { |
321 helper_.CheckOnValidThread(); | 321 helper_.CheckOnValidThread(); |
(...skipping 162 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
484 | 484 |
485 end_renderer_hidden_idle_period_closure_.Cancel(); | 485 end_renderer_hidden_idle_period_closure_.Cancel(); |
486 | 486 |
487 if (hidden) { | 487 if (hidden) { |
488 idle_helper_.EnableLongIdlePeriod(); | 488 idle_helper_.EnableLongIdlePeriod(); |
489 | 489 |
490 // Ensure that we stop running idle tasks after a few seconds of being | 490 // Ensure that we stop running idle tasks after a few seconds of being |
491 // hidden. | 491 // hidden. |
492 base::TimeDelta end_idle_when_hidden_delay = | 492 base::TimeDelta end_idle_when_hidden_delay = |
493 base::TimeDelta::FromMilliseconds(kEndIdleWhenHiddenDelayMillis); | 493 base::TimeDelta::FromMilliseconds(kEndIdleWhenHiddenDelayMillis); |
494 control_task_runner_->PostDelayedTask( | 494 control_task_queue_->PostDelayedTask( |
495 FROM_HERE, end_renderer_hidden_idle_period_closure_.GetCallback(), | 495 FROM_HERE, end_renderer_hidden_idle_period_closure_.GetCallback(), |
496 end_idle_when_hidden_delay); | 496 end_idle_when_hidden_delay); |
497 GetMainThreadOnly().renderer_hidden = true; | 497 GetMainThreadOnly().renderer_hidden = true; |
498 } else { | 498 } else { |
499 GetMainThreadOnly().renderer_hidden = false; | 499 GetMainThreadOnly().renderer_hidden = false; |
500 EndIdlePeriod(); | 500 EndIdlePeriod(); |
501 } | 501 } |
502 | 502 |
503 // TODO(alexclarke): Should we update policy here? | 503 // TODO(alexclarke): Should we update policy here? |
504 CreateTraceEventObjectSnapshot(); | 504 CreateTraceEventObjectSnapshot(); |
(...skipping 28 matching lines...) Expand all Loading... |
533 GetMainThreadOnly().foreground_main_thread_load_tracker.Pause(now); | 533 GetMainThreadOnly().foreground_main_thread_load_tracker.Pause(now); |
534 GetMainThreadOnly().background_main_thread_load_tracker.Resume(now); | 534 GetMainThreadOnly().background_main_thread_load_tracker.Resume(now); |
535 | 535 |
536 if (!GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled) | 536 if (!GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled) |
537 return; | 537 return; |
538 | 538 |
539 suspend_timers_when_backgrounded_closure_.Cancel(); | 539 suspend_timers_when_backgrounded_closure_.Cancel(); |
540 base::TimeDelta suspend_timers_when_backgrounded_delay = | 540 base::TimeDelta suspend_timers_when_backgrounded_delay = |
541 base::TimeDelta::FromMilliseconds( | 541 base::TimeDelta::FromMilliseconds( |
542 kSuspendTimersWhenBackgroundedDelayMillis); | 542 kSuspendTimersWhenBackgroundedDelayMillis); |
543 control_task_runner_->PostDelayedTask( | 543 control_task_queue_->PostDelayedTask( |
544 FROM_HERE, suspend_timers_when_backgrounded_closure_.GetCallback(), | 544 FROM_HERE, suspend_timers_when_backgrounded_closure_.GetCallback(), |
545 suspend_timers_when_backgrounded_delay); | 545 suspend_timers_when_backgrounded_delay); |
546 } | 546 } |
547 | 547 |
548 void RendererSchedulerImpl::OnRendererForegrounded() { | 548 void RendererSchedulerImpl::OnRendererForegrounded() { |
549 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), | 549 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), |
550 "RendererSchedulerImpl::OnRendererForegrounded"); | 550 "RendererSchedulerImpl::OnRendererForegrounded"); |
551 helper_.CheckOnValidThread(); | 551 helper_.CheckOnValidThread(); |
552 if (helper_.IsShutdown() || !GetMainThreadOnly().renderer_backgrounded) | 552 if (helper_.IsShutdown() || !GetMainThreadOnly().renderer_backgrounded) |
553 return; | 553 return; |
(...skipping 287 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
841 // for it since these tasks are not user-provided work and they are only | 841 // for it since these tasks are not user-provided work and they are only |
842 // intended to run before the next task, not interrupt the tasks. | 842 // intended to run before the next task, not interrupt the tasks. |
843 switch (GetMainThreadOnly().current_use_case) { | 843 switch (GetMainThreadOnly().current_use_case) { |
844 case UseCase::COMPOSITOR_GESTURE: | 844 case UseCase::COMPOSITOR_GESTURE: |
845 case UseCase::NONE: | 845 case UseCase::NONE: |
846 return GetMainThreadOnly().touchstart_expected_soon; | 846 return GetMainThreadOnly().touchstart_expected_soon; |
847 | 847 |
848 case UseCase::MAIN_THREAD_GESTURE: | 848 case UseCase::MAIN_THREAD_GESTURE: |
849 case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING: | 849 case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING: |
850 case UseCase::SYNCHRONIZED_GESTURE: | 850 case UseCase::SYNCHRONIZED_GESTURE: |
851 return compositor_task_runner_->HasPendingImmediateWork() || | 851 return compositor_task_queue_->HasPendingImmediateWork() || |
852 GetMainThreadOnly().touchstart_expected_soon; | 852 GetMainThreadOnly().touchstart_expected_soon; |
853 | 853 |
854 case UseCase::TOUCHSTART: | 854 case UseCase::TOUCHSTART: |
855 return true; | 855 return true; |
856 | 856 |
857 case UseCase::LOADING: | 857 case UseCase::LOADING: |
858 return false; | 858 return false; |
859 | 859 |
860 default: | 860 default: |
861 NOTREACHED(); | 861 NOTREACHED(); |
(...skipping 22 matching lines...) Expand all Loading... |
884 } | 884 } |
885 } | 885 } |
886 | 886 |
887 void RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread( | 887 void RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread( |
888 const tracked_objects::Location& from_here) { | 888 const tracked_objects::Location& from_here) { |
889 // TODO(scheduler-dev): Check that this method isn't called from the main | 889 // TODO(scheduler-dev): Check that this method isn't called from the main |
890 // thread. | 890 // thread. |
891 any_thread_lock_.AssertAcquired(); | 891 any_thread_lock_.AssertAcquired(); |
892 if (!policy_may_need_update_.IsSet()) { | 892 if (!policy_may_need_update_.IsSet()) { |
893 policy_may_need_update_.SetWhileLocked(true); | 893 policy_may_need_update_.SetWhileLocked(true); |
894 control_task_runner_->PostTask(from_here, update_policy_closure_); | 894 control_task_queue_->PostTask(from_here, update_policy_closure_); |
895 } | 895 } |
896 } | 896 } |
897 | 897 |
898 void RendererSchedulerImpl::UpdatePolicy() { | 898 void RendererSchedulerImpl::UpdatePolicy() { |
899 base::AutoLock lock(any_thread_lock_); | 899 base::AutoLock lock(any_thread_lock_); |
900 UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED); | 900 UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED); |
901 } | 901 } |
902 | 902 |
903 void RendererSchedulerImpl::ForceUpdatePolicy() { | 903 void RendererSchedulerImpl::ForceUpdatePolicy() { |
904 base::AutoLock lock(any_thread_lock_); | 904 base::AutoLock lock(any_thread_lock_); |
(...skipping 253 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1158 "RendererScheduler.timer_tasks_seem_expensive", | 1158 "RendererScheduler.timer_tasks_seem_expensive", |
1159 GetMainThreadOnly().timer_tasks_seem_expensive); | 1159 GetMainThreadOnly().timer_tasks_seem_expensive); |
1160 | 1160 |
1161 // TODO(alexclarke): Can we get rid of force update now? | 1161 // TODO(alexclarke): Can we get rid of force update now? |
1162 if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED && | 1162 if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED && |
1163 new_policy == GetMainThreadOnly().current_policy) { | 1163 new_policy == GetMainThreadOnly().current_policy) { |
1164 return; | 1164 return; |
1165 } | 1165 } |
1166 | 1166 |
1167 ApplyTaskQueuePolicy( | 1167 ApplyTaskQueuePolicy( |
1168 compositor_task_runner_.get(), | 1168 compositor_task_queue_.get(), compositor_task_queue_enabled_voter_.get(), |
1169 compositor_task_runner_enabled_voter_.get(), | |
1170 GetMainThreadOnly().current_policy.compositor_queue_policy, | 1169 GetMainThreadOnly().current_policy.compositor_queue_policy, |
1171 new_policy.compositor_queue_policy); | 1170 new_policy.compositor_queue_policy); |
1172 | 1171 |
1173 for (const auto& pair : loading_task_runners_) { | 1172 for (const auto& pair : loading_task_runners_) { |
1174 ApplyTaskQueuePolicy( | 1173 ApplyTaskQueuePolicy( |
1175 pair.first.get(), pair.second.get(), | 1174 pair.first.get(), pair.second.get(), |
1176 GetMainThreadOnly().current_policy.loading_queue_policy, | 1175 GetMainThreadOnly().current_policy.loading_queue_policy, |
1177 new_policy.loading_queue_policy); | 1176 new_policy.loading_queue_policy); |
1178 } | 1177 } |
1179 | 1178 |
(...skipping 19 matching lines...) Expand all Loading... |
1199 | 1198 |
1200 if (new_policy.should_disable_throttling != | 1199 if (new_policy.should_disable_throttling != |
1201 GetMainThreadOnly().current_policy.should_disable_throttling) { | 1200 GetMainThreadOnly().current_policy.should_disable_throttling) { |
1202 if (new_policy.should_disable_throttling) { | 1201 if (new_policy.should_disable_throttling) { |
1203 task_queue_throttler()->DisableThrottling(); | 1202 task_queue_throttler()->DisableThrottling(); |
1204 } else { | 1203 } else { |
1205 task_queue_throttler()->EnableThrottling(); | 1204 task_queue_throttler()->EnableThrottling(); |
1206 } | 1205 } |
1207 } | 1206 } |
1208 | 1207 |
1209 DCHECK(compositor_task_runner_->IsQueueEnabled()); | 1208 DCHECK(compositor_task_queue_->IsQueueEnabled()); |
1210 GetMainThreadOnly().current_policy = new_policy; | 1209 GetMainThreadOnly().current_policy = new_policy; |
1211 } | 1210 } |
1212 | 1211 |
1213 void RendererSchedulerImpl::ApplyTaskQueuePolicy( | 1212 void RendererSchedulerImpl::ApplyTaskQueuePolicy( |
1214 TaskQueue* task_queue, | 1213 TaskQueue* task_queue, |
1215 TaskQueue::QueueEnabledVoter* task_queue_enabled_voter, | 1214 TaskQueue::QueueEnabledVoter* task_queue_enabled_voter, |
1216 const TaskQueuePolicy& old_task_queue_policy, | 1215 const TaskQueuePolicy& old_task_queue_policy, |
1217 const TaskQueuePolicy& new_task_queue_policy) const { | 1216 const TaskQueuePolicy& new_task_queue_policy) const { |
1218 if (task_queue_enabled_voter && | 1217 if (task_queue_enabled_voter && |
1219 old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) { | 1218 old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) { |
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1354 } | 1353 } |
1355 | 1354 |
1356 IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() { | 1355 IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() { |
1357 return &GetMainThreadOnly().idle_time_estimator; | 1356 return &GetMainThreadOnly().idle_time_estimator; |
1358 } | 1357 } |
1359 | 1358 |
1360 void RendererSchedulerImpl::SuspendTimerQueue() { | 1359 void RendererSchedulerImpl::SuspendTimerQueue() { |
1361 GetMainThreadOnly().timer_queue_suspend_count++; | 1360 GetMainThreadOnly().timer_queue_suspend_count++; |
1362 ForceUpdatePolicy(); | 1361 ForceUpdatePolicy(); |
1363 #ifndef NDEBUG | 1362 #ifndef NDEBUG |
1364 DCHECK(!default_timer_task_runner_->IsQueueEnabled()); | 1363 DCHECK(!default_timer_task_queue_->IsQueueEnabled()); |
1365 for (const auto& runner : timer_task_runners_) { | 1364 for (const auto& runner : timer_task_runners_) { |
1366 DCHECK(!runner.first->IsQueueEnabled()); | 1365 DCHECK(!runner.first->IsQueueEnabled()); |
1367 } | 1366 } |
1368 #endif | 1367 #endif |
1369 } | 1368 } |
1370 | 1369 |
1371 void RendererSchedulerImpl::ResumeTimerQueue() { | 1370 void RendererSchedulerImpl::ResumeTimerQueue() { |
1372 GetMainThreadOnly().timer_queue_suspend_count--; | 1371 GetMainThreadOnly().timer_queue_suspend_count--; |
1373 DCHECK_GE(GetMainThreadOnly().timer_queue_suspend_count, 0); | 1372 DCHECK_GE(GetMainThreadOnly().timer_queue_suspend_count, 0); |
1374 ForceUpdatePolicy(); | 1373 ForceUpdatePolicy(); |
(...skipping 275 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1650 } | 1649 } |
1651 | 1650 |
1652 void RendererSchedulerImpl::SetTopLevelBlameContext( | 1651 void RendererSchedulerImpl::SetTopLevelBlameContext( |
1653 base::trace_event::BlameContext* blame_context) { | 1652 base::trace_event::BlameContext* blame_context) { |
1654 // Any task that runs in the default task runners belongs to the context of | 1653 // Any task that runs in the default task runners belongs to the context of |
1655 // all frames (as opposed to a particular frame). Note that the task itself | 1654 // all frames (as opposed to a particular frame). Note that the task itself |
1656 // may still enter a more specific blame context if necessary. | 1655 // may still enter a more specific blame context if necessary. |
1657 // | 1656 // |
1658 // Per-frame task runners (loading, timers, etc.) are configured with a more | 1657 // Per-frame task runners (loading, timers, etc.) are configured with a more |
1659 // specific blame context by WebFrameSchedulerImpl. | 1658 // specific blame context by WebFrameSchedulerImpl. |
1660 control_task_runner_->SetBlameContext(blame_context); | 1659 control_task_queue_->SetBlameContext(blame_context); |
1661 DefaultTaskQueue()->SetBlameContext(blame_context); | 1660 DefaultTaskQueue()->SetBlameContext(blame_context); |
1662 default_loading_task_runner_->SetBlameContext(blame_context); | 1661 default_loading_task_queue_->SetBlameContext(blame_context); |
1663 default_timer_task_runner_->SetBlameContext(blame_context); | 1662 default_timer_task_queue_->SetBlameContext(blame_context); |
1664 compositor_task_runner_->SetBlameContext(blame_context); | 1663 compositor_task_queue_->SetBlameContext(blame_context); |
1665 idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context); | 1664 idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context); |
1666 } | 1665 } |
1667 | 1666 |
1668 void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) { | 1667 void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) { |
1669 GetMainThreadOnly().rail_mode_observer = observer; | 1668 GetMainThreadOnly().rail_mode_observer = observer; |
1670 } | 1669 } |
1671 | 1670 |
1672 bool RendererSchedulerImpl::MainThreadSeemsUnresponsive( | 1671 bool RendererSchedulerImpl::MainThreadSeemsUnresponsive( |
1673 base::TimeDelta main_thread_responsiveness_threshold) { | 1672 base::TimeDelta main_thread_responsiveness_threshold) { |
1674 base::TimeTicks now = tick_clock()->NowTicks(); | 1673 base::TimeTicks now = tick_clock()->NowTicks(); |
(...skipping 278 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1953 case TimeDomainType::VIRTUAL: | 1952 case TimeDomainType::VIRTUAL: |
1954 return "virtual"; | 1953 return "virtual"; |
1955 default: | 1954 default: |
1956 NOTREACHED(); | 1955 NOTREACHED(); |
1957 return nullptr; | 1956 return nullptr; |
1958 } | 1957 } |
1959 } | 1958 } |
1960 | 1959 |
1961 } // namespace scheduler | 1960 } // namespace scheduler |
1962 } // namespace blink | 1961 } // namespace blink |
OLD | NEW |