| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/scheduler/child/scheduler_helper.h" | |
| 6 | |
| 7 #include "base/time/default_tick_clock.h" | |
| 8 #include "base/trace_event/trace_event.h" | |
| 9 #include "base/trace_event/trace_event_argument.h" | |
| 10 #include "components/scheduler/base/task_queue_impl.h" | |
| 11 #include "components/scheduler/child/scheduler_tqm_delegate.h" | |
| 12 | |
| 13 namespace scheduler { | |
| 14 | |
| 15 SchedulerHelper::SchedulerHelper( | |
| 16 scoped_refptr<SchedulerTqmDelegate> task_queue_manager_delegate, | |
| 17 const char* tracing_category, | |
| 18 const char* disabled_by_default_tracing_category, | |
| 19 const char* disabled_by_default_verbose_tracing_category) | |
| 20 : task_queue_manager_delegate_(task_queue_manager_delegate), | |
| 21 task_queue_manager_( | |
| 22 new TaskQueueManager(task_queue_manager_delegate, | |
| 23 tracing_category, | |
| 24 disabled_by_default_tracing_category, | |
| 25 disabled_by_default_verbose_tracing_category)), | |
| 26 control_task_runner_(NewTaskQueue( | |
| 27 TaskQueue::Spec("control_tq") | |
| 28 .SetWakeupPolicy(TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES) | |
| 29 .SetShouldNotifyObservers(false))), | |
| 30 control_after_wakeup_task_runner_(NewTaskQueue( | |
| 31 TaskQueue::Spec("control_after_wakeup_tq") | |
| 32 .SetPumpPolicy(TaskQueue::PumpPolicy::AFTER_WAKEUP) | |
| 33 .SetWakeupPolicy(TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES) | |
| 34 .SetShouldNotifyObservers(false))), | |
| 35 default_task_runner_(NewTaskQueue( | |
| 36 TaskQueue::Spec("default_tq").SetShouldMonitorQuiescence(true))), | |
| 37 observer_(nullptr), | |
| 38 tracing_category_(tracing_category), | |
| 39 disabled_by_default_tracing_category_( | |
| 40 disabled_by_default_tracing_category) { | |
| 41 control_task_runner_->SetQueuePriority(TaskQueue::CONTROL_PRIORITY); | |
| 42 control_after_wakeup_task_runner_->SetQueuePriority( | |
| 43 TaskQueue::CONTROL_PRIORITY); | |
| 44 | |
| 45 task_queue_manager_->SetWorkBatchSize(4); | |
| 46 | |
| 47 DCHECK(task_queue_manager_delegate_); | |
| 48 task_queue_manager_delegate_->SetDefaultTaskRunner( | |
| 49 default_task_runner_.get()); | |
| 50 } | |
| 51 | |
| 52 SchedulerHelper::~SchedulerHelper() { | |
| 53 Shutdown(); | |
| 54 } | |
| 55 | |
| 56 void SchedulerHelper::Shutdown() { | |
| 57 CheckOnValidThread(); | |
| 58 if (task_queue_manager_) | |
| 59 task_queue_manager_->SetObserver(nullptr); | |
| 60 task_queue_manager_.reset(); | |
| 61 task_queue_manager_delegate_->RestoreDefaultTaskRunner(); | |
| 62 } | |
| 63 | |
| 64 scoped_refptr<TaskQueue> SchedulerHelper::NewTaskQueue( | |
| 65 const TaskQueue::Spec& spec) { | |
| 66 DCHECK(task_queue_manager_.get()); | |
| 67 return task_queue_manager_->NewTaskQueue(spec); | |
| 68 } | |
| 69 | |
| 70 scoped_refptr<TaskQueue> SchedulerHelper::DefaultTaskRunner() { | |
| 71 CheckOnValidThread(); | |
| 72 return default_task_runner_; | |
| 73 } | |
| 74 | |
| 75 scoped_refptr<TaskQueue> SchedulerHelper::ControlTaskRunner() { | |
| 76 return control_task_runner_; | |
| 77 } | |
| 78 | |
| 79 scoped_refptr<TaskQueue> SchedulerHelper::ControlAfterWakeUpTaskRunner() { | |
| 80 return control_after_wakeup_task_runner_; | |
| 81 } | |
| 82 | |
| 83 void SchedulerHelper::SetWorkBatchSizeForTesting(size_t work_batch_size) { | |
| 84 CheckOnValidThread(); | |
| 85 DCHECK(task_queue_manager_.get()); | |
| 86 task_queue_manager_->SetWorkBatchSize(work_batch_size); | |
| 87 } | |
| 88 | |
| 89 TaskQueueManager* SchedulerHelper::GetTaskQueueManagerForTesting() { | |
| 90 CheckOnValidThread(); | |
| 91 return task_queue_manager_.get(); | |
| 92 } | |
| 93 | |
| 94 const scoped_refptr<SchedulerTqmDelegate>& | |
| 95 SchedulerHelper::scheduler_tqm_delegate() const { | |
| 96 return task_queue_manager_delegate_; | |
| 97 } | |
| 98 | |
| 99 | |
| 100 bool SchedulerHelper::GetAndClearSystemIsQuiescentBit() { | |
| 101 CheckOnValidThread(); | |
| 102 DCHECK(task_queue_manager_.get()); | |
| 103 return task_queue_manager_->GetAndClearSystemIsQuiescentBit(); | |
| 104 } | |
| 105 | |
| 106 void SchedulerHelper::AddTaskObserver( | |
| 107 base::MessageLoop::TaskObserver* task_observer) { | |
| 108 CheckOnValidThread(); | |
| 109 if (task_queue_manager_) | |
| 110 task_queue_manager_->AddTaskObserver(task_observer); | |
| 111 } | |
| 112 | |
| 113 void SchedulerHelper::RemoveTaskObserver( | |
| 114 base::MessageLoop::TaskObserver* task_observer) { | |
| 115 CheckOnValidThread(); | |
| 116 if (task_queue_manager_) | |
| 117 task_queue_manager_->RemoveTaskObserver(task_observer); | |
| 118 } | |
| 119 | |
| 120 void SchedulerHelper::SetObserver(Observer* observer) { | |
| 121 CheckOnValidThread(); | |
| 122 observer_ = observer; | |
| 123 DCHECK(task_queue_manager_); | |
| 124 task_queue_manager_->SetObserver(this); | |
| 125 } | |
| 126 | |
| 127 RealTimeDomain* SchedulerHelper::real_time_domain() const { | |
| 128 CheckOnValidThread(); | |
| 129 DCHECK(task_queue_manager_); | |
| 130 return task_queue_manager_->real_time_domain(); | |
| 131 } | |
| 132 | |
| 133 void SchedulerHelper::RegisterTimeDomain(TimeDomain* time_domain) { | |
| 134 CheckOnValidThread(); | |
| 135 DCHECK(task_queue_manager_); | |
| 136 task_queue_manager_->RegisterTimeDomain(time_domain); | |
| 137 } | |
| 138 | |
| 139 void SchedulerHelper::UnregisterTimeDomain(TimeDomain* time_domain) { | |
| 140 CheckOnValidThread(); | |
| 141 if (task_queue_manager_) | |
| 142 task_queue_manager_->UnregisterTimeDomain(time_domain); | |
| 143 } | |
| 144 | |
| 145 void SchedulerHelper::OnUnregisterTaskQueue( | |
| 146 const scoped_refptr<TaskQueue>& queue) { | |
| 147 if (observer_) | |
| 148 observer_->OnUnregisterTaskQueue(queue); | |
| 149 } | |
| 150 | |
| 151 void SchedulerHelper::OnTriedToExecuteBlockedTask( | |
| 152 const TaskQueue& queue, | |
| 153 const base::PendingTask& task) { | |
| 154 if (observer_) | |
| 155 observer_->OnTriedToExecuteBlockedTask(queue, task); | |
| 156 } | |
| 157 | |
| 158 TaskQueue* SchedulerHelper::CurrentlyExecutingTaskQueue() const { | |
| 159 if (!task_queue_manager_) | |
| 160 return nullptr; | |
| 161 return task_queue_manager_->currently_executing_task_queue(); | |
| 162 } | |
| 163 | |
| 164 } // namespace scheduler | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2118903002:
scheduler: Move the Blink scheduler into Blink (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master