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 "components/scheduler/child/compositor_worker_scheduler.h" | 5 #include "components/scheduler/child/compositor_worker_scheduler.h" |
6 | 6 |
7 #include "base/message_loop/message_loop.h" | 7 #include "base/message_loop/message_loop.h" |
8 #include "base/threading/thread.h" | 8 #include "base/threading/thread.h" |
9 | 9 |
10 namespace scheduler { | 10 namespace scheduler { |
11 | 11 |
| 12 // TODO(scheduler-dev): Get rid of this asap! |
| 13 namespace { |
| 14 class CompositorWorkerTaskRunnerWrapper : public TaskQueue { |
| 15 public: |
| 16 explicit CompositorWorkerTaskRunnerWrapper( |
| 17 scoped_refptr<base::SingleThreadTaskRunner> task_runner) |
| 18 : task_runner_(task_runner) {} |
| 19 |
| 20 // TaskQueue implementation: |
| 21 void UnregisterTaskQueue() override { NOTREACHED(); } |
| 22 |
| 23 bool RunsTasksOnCurrentThread() const override { |
| 24 return task_runner_->RunsTasksOnCurrentThread(); |
| 25 } |
| 26 |
| 27 bool PostDelayedTask(const tracked_objects::Location& from_here, |
| 28 const base::Closure& task, |
| 29 base::TimeDelta delay) override { |
| 30 return task_runner_->PostDelayedTask(from_here, task, delay); |
| 31 } |
| 32 |
| 33 bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here, |
| 34 const base::Closure& task, |
| 35 base::TimeDelta delay) override { |
| 36 return task_runner_->PostNonNestableDelayedTask(from_here, task, delay); |
| 37 } |
| 38 |
| 39 void SetQueueEnabled(bool enabled) override { NOTREACHED(); } |
| 40 |
| 41 bool IsQueueEnabled() const override { |
| 42 NOTREACHED(); |
| 43 return true; |
| 44 } |
| 45 |
| 46 bool IsEmpty() const override { |
| 47 NOTREACHED(); |
| 48 return false; |
| 49 }; |
| 50 |
| 51 bool HasPendingImmediateWork() const override { |
| 52 NOTREACHED(); |
| 53 return false; |
| 54 }; |
| 55 |
| 56 bool NeedsPumping() const override { |
| 57 NOTREACHED(); |
| 58 return false; |
| 59 }; |
| 60 |
| 61 const char* GetName() const override { |
| 62 NOTREACHED(); |
| 63 return nullptr; |
| 64 }; |
| 65 |
| 66 void SetQueuePriority(QueuePriority priority) override { NOTREACHED(); } |
| 67 |
| 68 QueuePriority GetQueuePriority() const override { |
| 69 NOTREACHED(); |
| 70 return QueuePriority::NORMAL_PRIORITY; |
| 71 }; |
| 72 |
| 73 void SetPumpPolicy(PumpPolicy pump_policy) override { NOTREACHED(); } |
| 74 |
| 75 PumpPolicy GetPumpPolicy() const override { |
| 76 NOTREACHED(); |
| 77 return PumpPolicy::AUTO; |
| 78 }; |
| 79 |
| 80 void PumpQueue(bool may_post_dowork) override { NOTREACHED(); } |
| 81 |
| 82 void AddTaskObserver( |
| 83 base::MessageLoop::TaskObserver* task_observer) override { |
| 84 NOTREACHED(); |
| 85 } |
| 86 |
| 87 void RemoveTaskObserver( |
| 88 base::MessageLoop::TaskObserver* task_observer) override { |
| 89 NOTREACHED(); |
| 90 } |
| 91 |
| 92 void SetTimeDomain(TimeDomain* domain) override { NOTREACHED(); } |
| 93 |
| 94 TimeDomain* GetTimeDomain() const override { |
| 95 NOTREACHED(); |
| 96 return nullptr; |
| 97 } |
| 98 |
| 99 private: |
| 100 ~CompositorWorkerTaskRunnerWrapper() override {} |
| 101 |
| 102 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; |
| 103 }; |
| 104 } // namespace |
| 105 |
12 CompositorWorkerScheduler::CompositorWorkerScheduler(base::Thread* thread) | 106 CompositorWorkerScheduler::CompositorWorkerScheduler(base::Thread* thread) |
13 : thread_(thread) {} | 107 : thread_(thread) {} |
14 | 108 |
15 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} | 109 CompositorWorkerScheduler::~CompositorWorkerScheduler() {} |
16 | 110 |
17 void CompositorWorkerScheduler::Init() {} | 111 void CompositorWorkerScheduler::Init() {} |
18 | 112 |
19 scoped_refptr<base::SingleThreadTaskRunner> | 113 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() { |
20 CompositorWorkerScheduler::DefaultTaskRunner() { | |
21 // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC | 114 // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC |
22 // without regressing performance of the rest of the system. | 115 // without regressing performance of the rest of the system. |
23 return thread_->task_runner(); | 116 return make_scoped_refptr( |
| 117 new CompositorWorkerTaskRunnerWrapper(thread_->task_runner())); |
24 } | 118 } |
25 | 119 |
26 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> | 120 scoped_refptr<scheduler::SingleThreadIdleTaskRunner> |
27 CompositorWorkerScheduler::IdleTaskRunner() { | 121 CompositorWorkerScheduler::IdleTaskRunner() { |
28 // TODO(sad): Not having a task-runner for idle tasks means v8 has to fallback | 122 // TODO(sad): Not having a task-runner for idle tasks means v8 has to fallback |
29 // to inline GC, which might cause jank. | 123 // to inline GC, which might cause jank. |
30 return nullptr; | 124 return nullptr; |
31 } | 125 } |
32 | 126 |
33 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { | 127 bool CompositorWorkerScheduler::CanExceedIdleDeadlineIfRequired() const { |
(...skipping 10 matching lines...) Expand all Loading... |
44 } | 138 } |
45 | 139 |
46 void CompositorWorkerScheduler::RemoveTaskObserver( | 140 void CompositorWorkerScheduler::RemoveTaskObserver( |
47 base::MessageLoop::TaskObserver* task_observer) { | 141 base::MessageLoop::TaskObserver* task_observer) { |
48 thread_->message_loop()->RemoveTaskObserver(task_observer); | 142 thread_->message_loop()->RemoveTaskObserver(task_observer); |
49 } | 143 } |
50 | 144 |
51 void CompositorWorkerScheduler::Shutdown() {} | 145 void CompositorWorkerScheduler::Shutdown() {} |
52 | 146 |
53 } // namespace scheduler | 147 } // namespace scheduler |
OLD | NEW |