OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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/child/compositor_worker_scheduler.h" | 5 #include "platform/scheduler/child/compositor_worker_scheduler.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "base/threading/thread.h" | 11 #include "base/threading/thread.h" |
| 12 #include "platform/scheduler/child/scheduler_helper.h" |
| 13 #include "platform/scheduler/child/scheduler_tqm_delegate.h" |
| 14 #include "platform/wtf/PtrUtil.h" |
12 | 15 |
13 namespace blink { | 16 namespace blink { |
14 namespace scheduler { | 17 namespace scheduler { |
15 | 18 |
16 // TODO(scheduler-dev): Get rid of this asap! | 19 CompositorWorkerScheduler::CompositorWorkerScheduler( |
17 namespace { | 20 base::Thread* thread, |
18 class CompositorWorkerTaskRunnerWrapper : public TaskQueue { | 21 scoped_refptr<SchedulerTqmDelegate> main_task_runner) |
19 public: | 22 : WorkerScheduler(WTF::MakeUnique<SchedulerHelper>( |
20 explicit CompositorWorkerTaskRunnerWrapper( | 23 main_task_runner, |
21 scoped_refptr<base::SingleThreadTaskRunner> task_runner) | 24 "compositor.scheduler", |
22 : task_runner_(task_runner) {} | 25 TRACE_DISABLED_BY_DEFAULT("compositor.scheduler"), |
23 | 26 TRACE_DISABLED_BY_DEFAULT("compositor.scheduler.debug"))), |
24 // TaskQueue implementation: | 27 thread_(thread) {} |
25 void UnregisterTaskQueue() override { NOTREACHED(); } | |
26 | |
27 bool RunsTasksOnCurrentThread() const override { | |
28 return task_runner_->RunsTasksOnCurrentThread(); | |
29 } | |
30 | |
31 bool PostDelayedTask(const tracked_objects::Location& from_here, | |
32 base::OnceClosure task, | |
33 base::TimeDelta delay) override { | |
34 return task_runner_->PostDelayedTask(from_here, std::move(task), delay); | |
35 } | |
36 | |
37 bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here, | |
38 base::OnceClosure task, | |
39 base::TimeDelta delay) override { | |
40 return task_runner_->PostNonNestableDelayedTask(from_here, std::move(task), | |
41 delay); | |
42 } | |
43 | |
44 std::unique_ptr<QueueEnabledVoter> CreateQueueEnabledVoter() override { | |
45 NOTREACHED(); | |
46 return nullptr; | |
47 } | |
48 | |
49 void InsertFence(InsertFencePosition position) override { NOTREACHED(); } | |
50 | |
51 void RemoveFence() override { NOTREACHED(); } | |
52 | |
53 bool BlockedByFence() const override { | |
54 NOTREACHED(); | |
55 return false; | |
56 } | |
57 | |
58 bool IsQueueEnabled() const override { | |
59 NOTREACHED(); | |
60 return true; | |
61 } | |
62 | |
63 bool IsEmpty() const override { | |
64 NOTREACHED(); | |
65 return false; | |
66 }; | |
67 | |
68 size_t GetNumberOfPendingTasks() const override { | |
69 NOTREACHED(); | |
70 return 0; | |
71 }; | |
72 | |
73 bool HasPendingImmediateWork() const override { | |
74 NOTREACHED(); | |
75 return false; | |
76 }; | |
77 | |
78 base::Optional<base::TimeTicks> GetNextScheduledWakeUp() override { | |
79 NOTREACHED(); | |
80 return base::nullopt; | |
81 } | |
82 | |
83 const char* GetName() const override { | |
84 NOTREACHED(); | |
85 return nullptr; | |
86 }; | |
87 | |
88 QueueType GetQueueType() const override { | |
89 NOTREACHED(); | |
90 return QueueType::DEFAULT; | |
91 } | |
92 | |
93 void SetQueuePriority(QueuePriority priority) override { NOTREACHED(); } | |
94 | |
95 QueuePriority GetQueuePriority() const override { | |
96 NOTREACHED(); | |
97 return QueuePriority::NORMAL_PRIORITY; | |
98 }; | |
99 | |
100 void AddTaskObserver( | |
101 base::MessageLoop::TaskObserver* task_observer) override { | |
102 NOTREACHED(); | |
103 } | |
104 | |
105 void RemoveTaskObserver( | |
106 base::MessageLoop::TaskObserver* task_observer) override { | |
107 NOTREACHED(); | |
108 } | |
109 | |
110 void SetTimeDomain(TimeDomain* domain) override { NOTREACHED(); } | |
111 | |
112 TimeDomain* GetTimeDomain() const override { | |
113 return nullptr; | |
114 } | |
115 | |
116 void SetBlameContext(base::trace_event::BlameContext*) override { | |
117 NOTREACHED(); | |
118 } | |
119 | |
120 void SetObserver(Observer* observer) override { NOTREACHED(); } | |
121 | |
122 private: | |
123 ~CompositorWorkerTaskRunnerWrapper() override {} | |
124 | |
125 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | |
126 }; | |
127 } // namespace | |
128 | |
129 CompositorWorkerScheduler::CompositorWorkerScheduler(base::Thread* thread) | |
130 : thread_(thread) {} | |
131 | 28 |
132 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} | 29 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} |
133 | 30 |
134 void CompositorWorkerScheduler::Init() {} | 31 void CompositorWorkerScheduler::Init() {} |
135 | 32 |
136 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { | 33 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { |
137 // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC | 34 return helper_->DefaultTaskRunner(); |
138 // without regressing performance of the rest of the system. | |
139 return make_scoped_refptr( | |
140 new CompositorWorkerTaskRunnerWrapper(thread_->task_runner())); | |
141 } | 35 } |
142 | 36 |
143 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> | 37 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> |
144 CompositorWorkerScheduler::IdleTaskRunner() { | 38 CompositorWorkerScheduler::IdleTaskRunner() { |
145 // TODO(flackr): This posts idle tasks as regular tasks. We need to create | 39 // TODO(flackr): This posts idle tasks as regular tasks. We need to create |
146 // an idle task runner with the semantics we want for the compositor thread | 40 // an idle task runner with the semantics we want for the compositor thread |
147 // which runs them after the current frame has been drawn before the next | 41 // which runs them after the current frame has been drawn before the next |
148 // vsync. https://crbug.com/609532 | 42 // vsync. https://crbug.com/609532 |
149 return make_scoped_refptr(new SingleThreadIdleTaskRunner( | 43 return make_scoped_refptr(new SingleThreadIdleTaskRunner( |
150 thread_->task_runner(), this, "compositor.scheduler")); | 44 thread_->task_runner(), this, "compositor.scheduler")); |
151 } | 45 } |
152 | 46 |
153 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { | 47 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { |
154 return false; | 48 return false; |
155 } | 49 } |
156 | 50 |
157 bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() { | 51 bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() { |
158 return false; | 52 return false; |
159 } | 53 } |
160 | 54 |
161 void CompositorWorkerScheduler::AddTaskObserver( | 55 void CompositorWorkerScheduler::AddTaskObserver( |
162 base::MessageLoop::TaskObserver* task_observer) { | 56 base::MessageLoop::TaskObserver* task_observer) { |
163 thread_->message_loop()->AddTaskObserver(task_observer); | 57 helper_->AddTaskObserver(task_observer); |
164 } | 58 } |
165 | 59 |
166 void CompositorWorkerScheduler::RemoveTaskObserver( | 60 void CompositorWorkerScheduler::RemoveTaskObserver( |
167 base::MessageLoop::TaskObserver* task_observer) { | 61 base::MessageLoop::TaskObserver* task_observer) { |
168 thread_->message_loop()->RemoveTaskObserver(task_observer); | 62 helper_->RemoveTaskObserver(task_observer); |
169 } | 63 } |
170 | 64 |
171 void CompositorWorkerScheduler::Shutdown() {} | 65 void CompositorWorkerScheduler::Shutdown() {} |
172 | 66 |
173 void CompositorWorkerScheduler::OnIdleTaskPosted() {} | 67 void CompositorWorkerScheduler::OnIdleTaskPosted() {} |
174 | 68 |
175 base::TimeTicks CompositorWorkerScheduler::WillProcessIdleTask() { | 69 base::TimeTicks CompositorWorkerScheduler::WillProcessIdleTask() { |
176 // TODO(flackr): Return the next frame time as the deadline instead. | 70 // TODO(flackr): Return the next frame time as the deadline instead. |
177 // TODO(flackr): Ensure that oilpan GC does happen on the compositor thread | 71 // TODO(flackr): Ensure that oilpan GC does happen on the compositor thread |
178 // even though we will have no long idle periods. https://crbug.com/609531 | 72 // even though we will have no long idle periods. https://crbug.com/609531 |
179 return base::TimeTicks::Now() + base::TimeDelta::FromMillisecondsD(16.7); | 73 return base::TimeTicks::Now() + base::TimeDelta::FromMillisecondsD(16.7); |
180 } | 74 } |
181 | 75 |
182 void CompositorWorkerScheduler::DidProcessIdleTask() {} | 76 void CompositorWorkerScheduler::DidProcessIdleTask() {} |
183 | 77 |
184 base::TimeTicks CompositorWorkerScheduler::NowTicks() { | 78 base::TimeTicks CompositorWorkerScheduler::NowTicks() { |
185 return base::TimeTicks::Now(); | 79 return base::TimeTicks::Now(); |
186 } | 80 } |
187 | 81 |
188 } // namespace scheduler | 82 } // namespace scheduler |
189 } // namespace blink | 83 } // namespace blink |
OLD | NEW |