1 // Copyright 2019 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 "third_party/blink/renderer/platform/scheduler/public/dummy_schedulers.h"
6
7 #include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
8 #include "third_party/blink/renderer/platform/scheduler/public/agent_group_scheduler.h"
9 #include "third_party/blink/renderer/platform/scheduler/public/frame_scheduler.h"
10 #include "third_party/blink/renderer/platform/scheduler/public/page_scheduler.h"
11 #include "third_party/blink/renderer/platform/scheduler/public/thread.h"
12 #include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
13 #include "third_party/blink/renderer/platform/scheduler/public/web_scheduling_priority.h"
14 #include "third_party/blink/renderer/platform/scheduler/public/web_scheduling_task_queue.h"
15 #include "third_party/blink/renderer/platform/wtf/wtf.h"
16
17 namespace blink {
18 namespace scheduler {
19
20 namespace {
21
22 class DummyFrameScheduler : public FrameScheduler {
23 public:
DummyFrameScheduler(PageScheduler * page_scheduler)24 explicit DummyFrameScheduler(PageScheduler* page_scheduler)
25 : page_scheduler_(page_scheduler) {}
~DummyFrameScheduler()26 ~DummyFrameScheduler() override {}
27
28 DummyFrameScheduler(const DummyFrameScheduler&) = delete;
29 DummyFrameScheduler& operator=(const DummyFrameScheduler&) = delete;
30
GetTaskRunner(TaskType)31 scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner(TaskType) override {
32 DCHECK(WTF::IsMainThread());
33 return base::ThreadTaskRunnerHandle::Get();
34 }
35
GetPageScheduler() const36 PageScheduler* GetPageScheduler() const override { return page_scheduler_; }
GetAgentGroupScheduler()37 AgentGroupScheduler* GetAgentGroupScheduler() override { return nullptr; }
38
SetPreemptedForCooperativeScheduling(Preempted)39 void SetPreemptedForCooperativeScheduling(Preempted) override {}
SetFrameVisible(bool)40 void SetFrameVisible(bool) override {}
IsFrameVisible() const41 bool IsFrameVisible() const override { return true; }
IsPageVisible() const42 bool IsPageVisible() const override { return true; }
SetPaused(bool)43 void SetPaused(bool) override {}
SetShouldReportPostedTasksWhenDisabled(bool)44 void SetShouldReportPostedTasksWhenDisabled(bool) override {}
SetCrossOriginToMainFrame(bool)45 void SetCrossOriginToMainFrame(bool) override {}
IsCrossOriginToMainFrame() const46 bool IsCrossOriginToMainFrame() const override { return false; }
SetIsAdFrame()47 void SetIsAdFrame() override {}
IsAdFrame() const48 bool IsAdFrame() const override { return false; }
TraceUrlChange(const String &)49 void TraceUrlChange(const String&) override {}
AddTaskTime(base::TimeDelta)50 void AddTaskTime(base::TimeDelta) override {}
GetFrameType() const51 FrameType GetFrameType() const override { return FrameType::kMainFrame; }
CreateWebScopedVirtualTimePauser(const String & name,WebScopedVirtualTimePauser::VirtualTaskDuration)52 WebScopedVirtualTimePauser CreateWebScopedVirtualTimePauser(
53 const String& name,
54 WebScopedVirtualTimePauser::VirtualTaskDuration) override {
55 return WebScopedVirtualTimePauser();
56 }
DidStartProvisionalLoad(bool is_main_frame)57 void DidStartProvisionalLoad(bool is_main_frame) override {}
DidCommitProvisionalLoad(bool,FrameScheduler::NavigationType)58 void DidCommitProvisionalLoad(bool, FrameScheduler::NavigationType) override {
59 }
OnFirstContentfulPaint()60 void OnFirstContentfulPaint() override {}
OnFirstMeaningfulPaint()61 void OnFirstMeaningfulPaint() override {}
OnLoad()62 void OnLoad() override {}
IsExemptFromBudgetBasedThrottling() const63 bool IsExemptFromBudgetBasedThrottling() const override { return false; }
64 std::unique_ptr<blink::mojom::blink::PauseSubresourceLoadingHandle>
GetPauseSubresourceLoadingHandle()65 GetPauseSubresourceLoadingHandle() override {
66 return nullptr;
67 }
68 std::unique_ptr<WebResourceLoadingTaskRunnerHandle>
CreateResourceLoadingTaskRunnerHandle()69 CreateResourceLoadingTaskRunnerHandle() override {
70 return WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
71 base::ThreadTaskRunnerHandle::Get());
72 }
73 std::unique_ptr<WebResourceLoadingTaskRunnerHandle>
CreateResourceLoadingMaybeUnfreezableTaskRunnerHandle()74 CreateResourceLoadingMaybeUnfreezableTaskRunnerHandle() override {
75 return WebResourceLoadingTaskRunnerHandle::CreateUnprioritized(
76 base::ThreadTaskRunnerHandle::Get());
77 }
CreateWebSchedulingTaskQueue(WebSchedulingPriority)78 std::unique_ptr<WebSchedulingTaskQueue> CreateWebSchedulingTaskQueue(
79 WebSchedulingPriority) override {
80 return nullptr;
81 }
GetUkmSourceId()82 ukm::SourceId GetUkmSourceId() override { return ukm::kInvalidSourceId; }
OnStartedUsingFeature(SchedulingPolicy::Feature feature,const SchedulingPolicy & policy)83 void OnStartedUsingFeature(SchedulingPolicy::Feature feature,
84 const SchedulingPolicy& policy) override {}
OnStoppedUsingFeature(SchedulingPolicy::Feature feature,const SchedulingPolicy & policy)85 void OnStoppedUsingFeature(SchedulingPolicy::Feature feature,
86 const SchedulingPolicy& policy) override {}
87 WTF::HashSet<SchedulingPolicy::Feature>
GetActiveFeaturesTrackedForBackForwardCacheMetrics()88 GetActiveFeaturesTrackedForBackForwardCacheMetrics() override {
89 return WTF::HashSet<SchedulingPolicy::Feature>();
90 }
GetWeakPtr()91 base::WeakPtr<FrameScheduler> GetWeakPtr() override {
92 return weak_ptr_factory_.GetWeakPtr();
93 }
ReportActiveSchedulerTrackedFeatures()94 void ReportActiveSchedulerTrackedFeatures() override {}
95
96 private:
97 PageScheduler* page_scheduler_;
98 base::WeakPtrFactory<FrameScheduler> weak_ptr_factory_{this};
99 };
100
101 class DummyAgentGroupScheduler : public AgentGroupScheduler {
102 public:
103 DummyAgentGroupScheduler() = default;
104 ~DummyAgentGroupScheduler() override = default;
105
106 DummyAgentGroupScheduler(const DummyAgentGroupScheduler&) = delete;
107 DummyAgentGroupScheduler& operator=(const DummyAgentGroupScheduler&) = delete;
108
AsAgentGroupScheduler()109 AgentGroupScheduler& AsAgentGroupScheduler() override { return *this; }
CreatePageScheduler(PageScheduler::Delegate *)110 std::unique_ptr<PageScheduler> CreatePageScheduler(
111 PageScheduler::Delegate*) override {
112 return CreateDummyPageScheduler();
113 }
DefaultTaskRunner()114 scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override {
115 return base::ThreadTaskRunnerHandle::Get();
116 }
117 };
118
119 class DummyPageScheduler : public PageScheduler {
120 public:
DummyPageScheduler()121 DummyPageScheduler()
122 : agent_group_scheduler_(std::make_unique<DummyAgentGroupScheduler>()) {}
123 ~DummyPageScheduler() override = default;
124
125 DummyPageScheduler(const DummyPageScheduler&) = delete;
126 DummyPageScheduler& operator=(const DummyPageScheduler&) = delete;
127
CreateFrameScheduler(FrameScheduler::Delegate * delegate,BlameContext *,FrameScheduler::FrameType)128 std::unique_ptr<FrameScheduler> CreateFrameScheduler(
129 FrameScheduler::Delegate* delegate,
130 BlameContext*,
131 FrameScheduler::FrameType) override {
132 return std::make_unique<DummyFrameScheduler>(this);
133 }
134
OnTitleOrFaviconUpdated()135 void OnTitleOrFaviconUpdated() override {}
SetPageVisible(bool)136 void SetPageVisible(bool) override {}
SetPageFrozen(bool)137 void SetPageFrozen(bool) override {}
SetPageBackForwardCached(bool)138 void SetPageBackForwardCached(bool) override {}
SetKeepActive(bool)139 void SetKeepActive(bool) override {}
IsMainFrameLocal() const140 bool IsMainFrameLocal() const override { return true; }
SetIsMainFrameLocal(bool)141 void SetIsMainFrameLocal(bool) override {}
OnLocalMainFrameNetworkAlmostIdle()142 void OnLocalMainFrameNetworkAlmostIdle() override {}
EnableVirtualTime()143 base::TimeTicks EnableVirtualTime() override { return base::TimeTicks(); }
DisableVirtualTimeForTesting()144 void DisableVirtualTimeForTesting() override {}
VirtualTimeAllowedToAdvance() const145 bool VirtualTimeAllowedToAdvance() const override { return true; }
SetInitialVirtualTime(base::Time)146 void SetInitialVirtualTime(base::Time) override {}
SetInitialVirtualTimeOffset(base::TimeDelta)147 void SetInitialVirtualTimeOffset(base::TimeDelta) override {}
SetVirtualTimePolicy(VirtualTimePolicy)148 void SetVirtualTimePolicy(VirtualTimePolicy) override {}
GrantVirtualTimeBudget(base::TimeDelta,base::OnceClosure)149 void GrantVirtualTimeBudget(base::TimeDelta, base::OnceClosure) override {}
SetMaxVirtualTimeTaskStarvationCount(int)150 void SetMaxVirtualTimeTaskStarvationCount(int) override {}
AudioStateChanged(bool is_audio_playing)151 void AudioStateChanged(bool is_audio_playing) override {}
IsAudioPlaying() const152 bool IsAudioPlaying() const override { return false; }
IsExemptFromBudgetBasedThrottling() const153 bool IsExemptFromBudgetBasedThrottling() const override { return false; }
OptedOutFromAggressiveThrottlingForTest() const154 bool OptedOutFromAggressiveThrottlingForTest() const override {
155 return false;
156 }
IsInBackForwardCache() const157 bool IsInBackForwardCache() const override { return false; }
RequestBeginMainFrameNotExpected(bool)158 bool RequestBeginMainFrameNotExpected(bool) override { return false; }
CreateWebScopedVirtualTimePauser(const String & name,WebScopedVirtualTimePauser::VirtualTaskDuration)159 WebScopedVirtualTimePauser CreateWebScopedVirtualTimePauser(
160 const String& name,
161 WebScopedVirtualTimePauser::VirtualTaskDuration) override {
162 return WebScopedVirtualTimePauser();
163 }
GetAgentGroupScheduler()164 scheduler::WebAgentGroupScheduler& GetAgentGroupScheduler() override {
165 return *agent_group_scheduler_;
166 }
167
168 private:
169 std::unique_ptr<DummyAgentGroupScheduler> agent_group_scheduler_;
170 };
171
172 // TODO(altimin,yutak): Merge with SimpleThread in platform.cc.
173 class SimpleThread : public Thread {
174 public:
SimpleThread(ThreadScheduler * scheduler)175 explicit SimpleThread(ThreadScheduler* scheduler) : scheduler_(scheduler) {}
~SimpleThread()176 ~SimpleThread() override {}
177
178 SimpleThread(const SimpleThread&) = delete;
179 SimpleThread& operator=(const SimpleThread&) = delete;
180
GetTaskRunner() const181 scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const override {
182 return base::ThreadTaskRunnerHandle::Get();
183 }
184
Scheduler()185 ThreadScheduler* Scheduler() override { return scheduler_; }
186
IsCurrentThread() const187 bool IsCurrentThread() const { return WTF::IsMainThread(); }
188
189 private:
190 ThreadScheduler* scheduler_;
191 };
192
193 class DummyThreadScheduler : public ThreadScheduler {
194 public:
DummyThreadScheduler()195 DummyThreadScheduler() {}
~DummyThreadScheduler()196 ~DummyThreadScheduler() override {}
197
Shutdown()198 void Shutdown() override {}
199
V8TaskRunner()200 scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override {
201 return base::ThreadTaskRunnerHandle::Get();
202 }
203
DeprecatedDefaultTaskRunner()204 scoped_refptr<base::SingleThreadTaskRunner> DeprecatedDefaultTaskRunner()
205 override {
206 return base::ThreadTaskRunnerHandle::Get();
207 }
208
CompositorTaskRunner()209 scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override {
210 return base::ThreadTaskRunnerHandle::Get();
211 }
212
NonWakingTaskRunner()213 scoped_refptr<base::SingleThreadTaskRunner> NonWakingTaskRunner() override {
214 return base::ThreadTaskRunnerHandle::Get();
215 }
216
CreateAgentGroupScheduler()217 std::unique_ptr<WebAgentGroupScheduler> CreateAgentGroupScheduler() override {
218 return std::make_unique<DummyAgentGroupScheduler>();
219 }
220
GetCurrentAgentGroupScheduler()221 WebAgentGroupScheduler* GetCurrentAgentGroupScheduler() override {
222 return nullptr;
223 }
224
225 // ThreadScheduler implementation:
ShouldYieldForHighPriorityWork()226 bool ShouldYieldForHighPriorityWork() override { return false; }
CanExceedIdleDeadlineIfRequired() const227 bool CanExceedIdleDeadlineIfRequired() const override { return false; }
PostIdleTask(const base::Location &,Thread::IdleTask)228 void PostIdleTask(const base::Location&, Thread::IdleTask) override {}
PostDelayedIdleTask(const base::Location &,base::TimeDelta delay,Thread::IdleTask)229 void PostDelayedIdleTask(const base::Location&,
230 base::TimeDelta delay,
231 Thread::IdleTask) override {}
PostNonNestableIdleTask(const base::Location &,Thread::IdleTask)232 void PostNonNestableIdleTask(const base::Location&,
233 Thread::IdleTask) override {}
AddRAILModeObserver(RAILModeObserver *)234 void AddRAILModeObserver(RAILModeObserver*) override {}
RemoveRAILModeObserver(RAILModeObserver const *)235 void RemoveRAILModeObserver(RAILModeObserver const*) override {}
PauseScheduler()236 std::unique_ptr<WebThreadScheduler::RendererPauseHandle> PauseScheduler()
237 override {
238 return nullptr;
239 }
MonotonicallyIncreasingVirtualTime()240 base::TimeTicks MonotonicallyIncreasingVirtualTime() override {
241 return base::TimeTicks::Now();
242 }
AddTaskObserver(base::TaskObserver *)243 void AddTaskObserver(base::TaskObserver*) override {}
RemoveTaskObserver(base::TaskObserver *)244 void RemoveTaskObserver(base::TaskObserver*) override {}
AsNonMainThreadScheduler()245 NonMainThreadSchedulerImpl* AsNonMainThreadScheduler() override {
246 return nullptr;
247 }
SetV8Isolate(v8::Isolate * isolate)248 void SetV8Isolate(v8::Isolate* isolate) override {}
249 };
250
251 class DummyWebThreadScheduler : public WebThreadScheduler,
252 public DummyThreadScheduler {
253 public:
DummyWebThreadScheduler()254 DummyWebThreadScheduler() {}
~DummyWebThreadScheduler()255 ~DummyWebThreadScheduler() override {}
256
257 // WebThreadScheduler implementation:
Shutdown()258 void Shutdown() override {}
259
DefaultTaskRunner()260 scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override {
261 DCHECK(WTF::IsMainThread());
262 return base::ThreadTaskRunnerHandle::Get();
263 }
264
DeprecatedDefaultTaskRunner()265 scoped_refptr<base::SingleThreadTaskRunner> DeprecatedDefaultTaskRunner()
266 override {
267 DCHECK(WTF::IsMainThread());
268 return base::ThreadTaskRunnerHandle::Get();
269 }
270
CompositorTaskRunner()271 scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override {
272 DCHECK(WTF::IsMainThread());
273 return base::ThreadTaskRunnerHandle::Get();
274 }
275
V8TaskRunner()276 scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override {
277 DCHECK(WTF::IsMainThread());
278 return base::ThreadTaskRunnerHandle::Get();
279 }
280
CreateMainThread()281 std::unique_ptr<Thread> CreateMainThread() override {
282 return std::make_unique<SimpleThread>(this);
283 }
284
CreateAgentGroupScheduler()285 std::unique_ptr<WebAgentGroupScheduler> CreateAgentGroupScheduler() override {
286 return std::make_unique<DummyAgentGroupScheduler>();
287 }
288
GetCurrentAgentGroupScheduler()289 WebAgentGroupScheduler* GetCurrentAgentGroupScheduler() override {
290 return nullptr;
291 }
292 };
293
294 } // namespace
295
CreateDummyFrameScheduler()296 std::unique_ptr<FrameScheduler> CreateDummyFrameScheduler() {
297 return std::make_unique<DummyFrameScheduler>(nullptr);
298 }
299
CreateDummyPageScheduler()300 std::unique_ptr<PageScheduler> CreateDummyPageScheduler() {
301 return std::make_unique<DummyPageScheduler>();
302 }
303
CreateDummyAgentGroupScheduler()304 std::unique_ptr<AgentGroupScheduler> CreateDummyAgentGroupScheduler() {
305 return std::make_unique<DummyAgentGroupScheduler>();
306 }
307
CreateDummyThreadScheduler()308 std::unique_ptr<ThreadScheduler> CreateDummyThreadScheduler() {
309 return std::make_unique<DummyThreadScheduler>();
310 }
311
CreateDummyWebThreadScheduler()312 std::unique_ptr<WebThreadScheduler> CreateDummyWebThreadScheduler() {
313 return std::make_unique<DummyWebThreadScheduler>();
314 }
315
316 } // namespace scheduler
317 } // namespace blink
318