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" | |
15 | 12 |
16 namespace blink { | 13 namespace blink { |
17 namespace scheduler { | 14 namespace scheduler { |
18 | 15 |
19 CompositorWorkerScheduler::CompositorWorkerScheduler( | 16 // TODO(scheduler-dev): Get rid of this asap! |
20 base::Thread* thread, | 17 namespace { |
21 scoped_refptr<SchedulerTqmDelegate> main_task_runner) | 18 class CompositorWorkerTaskRunnerWrapper : public TaskQueue { |
22 : WorkerScheduler(WTF::MakeUnique<SchedulerHelper>( | 19 public: |
23 main_task_runner, | 20 explicit CompositorWorkerTaskRunnerWrapper( |
24 "compositor.scheduler", | 21 scoped_refptr<base::SingleThreadTaskRunner> task_runner) |
25 TRACE_DISABLED_BY_DEFAULT("compositor.scheduler"), | 22 : task_runner_(task_runner) {} |
26 TRACE_DISABLED_BY_DEFAULT("compositor.scheduler.debug"))), | 23 |
27 thread_(thread) {} | 24 // TaskQueue implementation: |
| 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) {} |
28 | 131 |
29 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} | 132 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} |
30 | 133 |
31 void CompositorWorkerScheduler::Init() {} | 134 void CompositorWorkerScheduler::Init() {} |
32 | 135 |
33 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { | 136 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { |
34 return helper_->DefaultTaskRunner(); | 137 // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC |
| 138 // without regressing performance of the rest of the system. |
| 139 return make_scoped_refptr( |
| 140 new CompositorWorkerTaskRunnerWrapper(thread_->task_runner())); |
35 } | 141 } |
36 | 142 |
37 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> | 143 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> |
38 CompositorWorkerScheduler::IdleTaskRunner() { | 144 CompositorWorkerScheduler::IdleTaskRunner() { |
39 // TODO(flackr): This posts idle tasks as regular tasks. We need to create | 145 // TODO(flackr): This posts idle tasks as regular tasks. We need to create |
40 // an idle task runner with the semantics we want for the compositor thread | 146 // an idle task runner with the semantics we want for the compositor thread |
41 // which runs them after the current frame has been drawn before the next | 147 // which runs them after the current frame has been drawn before the next |
42 // vsync. https://crbug.com/609532 | 148 // vsync. https://crbug.com/609532 |
43 return make_scoped_refptr(new SingleThreadIdleTaskRunner( | 149 return make_scoped_refptr(new SingleThreadIdleTaskRunner( |
44 thread_->task_runner(), this, "compositor.scheduler")); | 150 thread_->task_runner(), this, "compositor.scheduler")); |
45 } | 151 } |
46 | 152 |
47 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { | 153 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { |
48 return false; | 154 return false; |
49 } | 155 } |
50 | 156 |
51 bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() { | 157 bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() { |
52 return false; | 158 return false; |
53 } | 159 } |
54 | 160 |
55 void CompositorWorkerScheduler::AddTaskObserver( | 161 void CompositorWorkerScheduler::AddTaskObserver( |
56 base::MessageLoop::TaskObserver* task_observer) { | 162 base::MessageLoop::TaskObserver* task_observer) { |
57 helper_->AddTaskObserver(task_observer); | 163 thread_->message_loop()->AddTaskObserver(task_observer); |
58 } | 164 } |
59 | 165 |
60 void CompositorWorkerScheduler::RemoveTaskObserver( | 166 void CompositorWorkerScheduler::RemoveTaskObserver( |
61 base::MessageLoop::TaskObserver* task_observer) { | 167 base::MessageLoop::TaskObserver* task_observer) { |
62 helper_->RemoveTaskObserver(task_observer); | 168 thread_->message_loop()->RemoveTaskObserver(task_observer); |
63 } | 169 } |
64 | 170 |
65 void CompositorWorkerScheduler::Shutdown() {} | 171 void CompositorWorkerScheduler::Shutdown() {} |
66 | 172 |
67 void CompositorWorkerScheduler::OnIdleTaskPosted() {} | 173 void CompositorWorkerScheduler::OnIdleTaskPosted() {} |
68 | 174 |
69 base::TimeTicks CompositorWorkerScheduler::WillProcessIdleTask() { | 175 base::TimeTicks CompositorWorkerScheduler::WillProcessIdleTask() { |
70 // TODO(flackr): Return the next frame time as the deadline instead. | 176 // TODO(flackr): Return the next frame time as the deadline instead. |
71 // TODO(flackr): Ensure that oilpan GC does happen on the compositor thread | 177 // TODO(flackr): Ensure that oilpan GC does happen on the compositor thread |
72 // even though we will have no long idle periods. https://crbug.com/609531 | 178 // even though we will have no long idle periods. https://crbug.com/609531 |
73 return base::TimeTicks::Now() + base::TimeDelta::FromMillisecondsD(16.7); | 179 return base::TimeTicks::Now() + base::TimeDelta::FromMillisecondsD(16.7); |
74 } | 180 } |
75 | 181 |
76 void CompositorWorkerScheduler::DidProcessIdleTask() {} | 182 void CompositorWorkerScheduler::DidProcessIdleTask() {} |
77 | 183 |
78 base::TimeTicks CompositorWorkerScheduler::NowTicks() { | 184 base::TimeTicks CompositorWorkerScheduler::NowTicks() { |
79 return base::TimeTicks::Now(); | 185 return base::TimeTicks::Now(); |
80 } | 186 } |
81 | 187 |
82 } // namespace scheduler | 188 } // namespace scheduler |
83 } // namespace blink | 189 } // namespace blink |
OLD | NEW |