Merge RendererWebSchedulerImpl into MainThreadSchedulerImpl.

This patch moves virtual function implementation of Renderer-
WebSchedulerImpl to MainThreadSchedulerImpl, and remove Renderer-
WebSchedulerImpl. MainThreadSchedulerImpl now inherits from both
WebMainThreadScheduler and ThreadScheduler, just like NonMainThread-
Scheduler.

WebMainThreadScheduler and ThreadScheduler have a substantial number of
overlapping functions. They are implemented in MainThreadSchedulerImpl
at the same time, as those functions are compatible with each other's.
A future cleanup is planned to reduce the overlaps for a cleaner code
structure.

Bug: 826203
Change-Id: Ic32a1175b07a9f9e86123f4a70329b269758a841
Reviewed-on: https://chromium-review.googlesource.com/1058990
Commit-Queue: Yuta Kitamura <yutak@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#559452}

third_party/blink/renderer/core/dom/idle_deadline_test.cc

@@ -40,7 +40,7 @@ class MockIdleDeadlineScheduler final : public ThreadScheduler {
     return nullptr;
   }
 
-  base::TimeTicks MonotonicallyIncreasingVirtualTime() const override {
+  base::TimeTicks MonotonicallyIncreasingVirtualTime() override {
     return base::TimeTicks();
   }
 

third_party/blink/renderer/core/dom/scripted_idle_task_controller_test.cc

@@ -47,7 +47,7 @@ class MockScriptedIdleTaskControllerScheduler final : public ThreadScheduler {
     return nullptr;
   }
 
-  base::TimeTicks MonotonicallyIncreasingVirtualTime() const override {
+  base::TimeTicks MonotonicallyIncreasingVirtualTime() override {
     return base::TimeTicks();
   }
 

third_party/blink/renderer/platform/scheduler/BUILD.gn

@@ -61,8 +61,6 @@ blink_platform_sources("scheduler") {
     "child/single_thread_idle_task_runner.cc",
     "child/task_queue_with_task_type.cc",
     "child/task_queue_with_task_type.h",
-    "child/web_scheduler_impl.cc",
-    "child/web_scheduler_impl.h",
     "child/webthread_base.cc",
     "child/webthread_impl_for_worker_scheduler.cc",
     "child/webthread_impl_for_worker_scheduler.h",
@@ -125,8 +123,6 @@ blink_platform_sources("scheduler") {
     "public/web_main_thread_scheduler.h",
     "renderer/frame_status.cc",
     "renderer/frame_status.h",
-    "renderer/renderer_web_scheduler_impl.cc",
-    "renderer/renderer_web_scheduler_impl.h",
     "renderer/web_scoped_virtual_time_pauser.cc",
     "renderer/webthread_impl_for_renderer_scheduler.cc",
     "renderer/webthread_impl_for_renderer_scheduler.h",

third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.cc

-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.h"
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "third_party/blink/renderer/platform/scheduler/child/task_queue_with_task_type.h"
-#include "third_party/blink/renderer/platform/scheduler/public/non_main_thread_scheduler.h"
-#include "third_party/blink/renderer/platform/scheduler/public/page_scheduler.h"
-
-namespace blink {
-namespace scheduler {
-
-WebSchedulerImpl::WebSchedulerImpl(
-    WebThreadScheduler* thread_scheduler,
-    scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner,
-    scoped_refptr<base::sequence_manager::TaskQueue> v8_task_runner)
-    : thread_scheduler_(thread_scheduler),
-      idle_task_runner_(idle_task_runner),
-      v8_task_runner_(
-          TaskQueueWithTaskType::Create(std::move(v8_task_runner),
-                                        TaskType::kMainThreadTaskQueueV8)) {}
-
-WebSchedulerImpl::~WebSchedulerImpl() = default;
-
-void WebSchedulerImpl::Shutdown() {
-  thread_scheduler_->Shutdown();
-}
-
-bool WebSchedulerImpl::ShouldYieldForHighPriorityWork() {
-  return thread_scheduler_->ShouldYieldForHighPriorityWork();
-}
-
-bool WebSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
-  return thread_scheduler_->CanExceedIdleDeadlineIfRequired();
-}
-
-void WebSchedulerImpl::RunIdleTask(blink::WebThread::IdleTask task,
-                                   base::TimeTicks deadline) {
-  std::move(task).Run((deadline - base::TimeTicks()).InSecondsF());
-}
-
-void WebSchedulerImpl::PostIdleTask(const base::Location& location,
-                                    blink::WebThread::IdleTask task) {
-  DCHECK(idle_task_runner_);
-  idle_task_runner_->PostIdleTask(
-      location,
-      base::BindOnce(&WebSchedulerImpl::RunIdleTask, std::move(task)));
-}
-
-void WebSchedulerImpl::PostNonNestableIdleTask(
-    const base::Location& location,
-    blink::WebThread::IdleTask task) {
-  DCHECK(idle_task_runner_);
-  idle_task_runner_->PostNonNestableIdleTask(
-      location,
-      base::BindOnce(&WebSchedulerImpl::RunIdleTask, std::move(task)));
-}
-
-scoped_refptr<base::SingleThreadTaskRunner> WebSchedulerImpl::V8TaskRunner() {
-  return v8_task_runner_;
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-WebSchedulerImpl::CompositorTaskRunner() {
-  return nullptr;
-}
-
-std::unique_ptr<blink::PageScheduler> WebSchedulerImpl::CreatePageScheduler(
-    PageScheduler::Delegate* delegate) {
-  NOTREACHED();
-  return nullptr;
-}
-
-std::unique_ptr<WebSchedulerImpl::RendererPauseHandle>
-WebSchedulerImpl::PauseScheduler() {
-  return nullptr;
-}
-
-base::TimeTicks WebSchedulerImpl::MonotonicallyIncreasingVirtualTime() const {
-  return base::TimeTicks::Now();
-}
-
-}  // namespace scheduler
-}  // namespace blink

third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.h

-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_CHILD_WEB_SCHEDULER_IMPL_H_
-#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_CHILD_WEB_SCHEDULER_IMPL_H_
-
-#include <memory>
-
-#include "base/macros.h"
-#include "base/memory/scoped_refptr.h"
-#include "base/time/time.h"
-#include "third_party/blink/public/platform/web_thread.h"
-#include "third_party/blink/renderer/platform/platform_export.h"
-#include "third_party/blink/renderer/platform/scheduler/base/task_queue.h"
-#include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
-
-namespace blink {
-namespace scheduler {
-
-class SingleThreadIdleTaskRunner;
-class TaskQueueWithTaskType;
-class WebThreadScheduler;
-
-class PLATFORM_EXPORT WebSchedulerImpl : public ThreadScheduler {
- public:
-  WebSchedulerImpl(
-      WebThreadScheduler* thread_scheduler,
-      scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner,
-      scoped_refptr<base::sequence_manager::TaskQueue> v8_task_runner);
-  ~WebSchedulerImpl() override;
-
-  // ThreadScheduler implementation:
-  void Shutdown() override;
-  bool ShouldYieldForHighPriorityWork() override;
-  bool CanExceedIdleDeadlineIfRequired() const override;
-  void PostIdleTask(const base::Location& location,
-                    WebThread::IdleTask task) override;
-  void PostNonNestableIdleTask(const base::Location& location,
-                               WebThread::IdleTask task) override;
-  scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override;
-  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
-  std::unique_ptr<PageScheduler> CreatePageScheduler(
-      PageScheduler::Delegate*) override;
-  std::unique_ptr<RendererPauseHandle> PauseScheduler() override
-      WARN_UNUSED_RESULT;
-
-  // Returns TimeTicks::Now() by default.
-  base::TimeTicks MonotonicallyIncreasingVirtualTime() const override;
-
- private:
-  static void RunIdleTask(WebThread::IdleTask task, base::TimeTicks deadline);
-
-  WebThreadScheduler* thread_scheduler_;  // NOT OWNED
-  scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
-  scoped_refptr<TaskQueueWithTaskType> v8_task_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebSchedulerImpl);
-};
-
-}  // namespace scheduler
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_CHILD_WEB_SCHEDULER_IMPL_H_

third_party/blink/renderer/platform/scheduler/child/webthread_impl_for_worker_scheduler_unittest.cc

@@ -10,7 +10,6 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/platform/cross_thread_functional.h"
-#include "third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.h"
 #include "third_party/blink/renderer/platform/web_task_runner.h"
 

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -290,6 +290,12 @@ MainThreadSchedulerImpl::MainThreadSchedulerImpl(
   ipc_task_queue_ = NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
       MainThreadTaskQueue::QueueType::kIPC));
 
+  // TODO(kraynov): Ditch kDeprecatedNone here.
+  v8_task_runner_ =
+      TaskQueueWithTaskType::Create(v8_task_queue_, TaskType::kDeprecatedNone);
+  compositor_task_runner_ = TaskQueueWithTaskType::Create(
+      compositor_task_queue_, TaskType::kDeprecatedNone);
+
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "MainThreadScheduler",
       this);
@@ -646,12 +652,6 @@ MainThreadSchedulerImpl::DefaultTaskRunner() {
   return helper_.DefaultMainThreadTaskQueue();
 }
 
-scoped_refptr<base::SingleThreadTaskRunner>
-MainThreadSchedulerImpl::CompositorTaskRunner() {
-  helper_.CheckOnValidThread();
-  return compositor_task_queue_;
-}
-
 scoped_refptr<base::SingleThreadTaskRunner>
 MainThreadSchedulerImpl::InputTaskRunner() {
   helper_.CheckOnValidThread();
@@ -1013,7 +1013,7 @@ void MainThreadSchedulerImpl::OnAudioStateChanged() {
   main_thread_only().is_audio_playing = is_audio_playing;
 }
 
-std::unique_ptr<MainThreadSchedulerImpl::RendererPauseHandle>
+std::unique_ptr<ThreadScheduler::RendererPauseHandle>
 MainThreadSchedulerImpl::PauseRenderer() {
   return std::make_unique<RendererPauseHandleImpl>(this);
 }
@@ -2403,6 +2403,57 @@ MainThreadSchedulerImpl::CreateWebScopedVirtualTimePauser(
                                     WebString(WTF::String(name)));
 }
 
+void MainThreadSchedulerImpl::RunIdleTask(WebThread::IdleTask task,
+                                          base::TimeTicks deadline) {
+  std::move(task).Run((deadline - base::TimeTicks()).InSecondsF());
+}
+
+void MainThreadSchedulerImpl::PostIdleTask(const base::Location& location,
+                                           WebThread::IdleTask task) {
+  IdleTaskRunner()->PostIdleTask(
+      location,
+      base::BindOnce(&MainThreadSchedulerImpl::RunIdleTask, std::move(task)));
+}
+
+void MainThreadSchedulerImpl::PostNonNestableIdleTask(
+    const base::Location& location,
+    WebThread::IdleTask task) {
+  IdleTaskRunner()->PostNonNestableIdleTask(
+      location,
+      base::BindOnce(&MainThreadSchedulerImpl::RunIdleTask, std::move(task)));
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+MainThreadSchedulerImpl::V8TaskRunner() {
+  return v8_task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+MainThreadSchedulerImpl::CompositorTaskRunner() {
+  return compositor_task_runner_;
+}
+
+std::unique_ptr<PageScheduler> MainThreadSchedulerImpl::CreatePageScheduler(
+    PageScheduler::Delegate* delegate) {
+  return std::make_unique<PageSchedulerImpl>(
+      delegate, this,
+      !RuntimeEnabledFeatures::TimerThrottlingForBackgroundTabsEnabled());
+}
+
+std::unique_ptr<ThreadScheduler::RendererPauseHandle>
+MainThreadSchedulerImpl::PauseScheduler() {
+  return PauseRenderer();
+}
+
+base::TimeTicks MainThreadSchedulerImpl::MonotonicallyIncreasingVirtualTime() {
+  return GetActiveTimeDomain()->Now();
+}
+
+WebMainThreadScheduler*
+MainThreadSchedulerImpl::GetWebMainThreadSchedulerForTest() {
+  return this;
+}
+
 void MainThreadSchedulerImpl::RegisterTimeDomain(TimeDomain* time_domain) {
   helper_.RegisterTimeDomain(time_domain);
 }

third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -28,6 +28,7 @@
 #include "third_party/blink/renderer/platform/scheduler/child/idle_canceled_delayed_task_sweeper.h"
 #include "third_party/blink/renderer/platform/scheduler/child/idle_helper.h"
 #include "third_party/blink/renderer/platform/scheduler/child/pollable_thread_safe_flag.h"
+#include "third_party/blink/renderer/platform/scheduler/child/task_queue_with_task_type.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/auto_advancing_virtual_time_domain.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/deadline_task_runner.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/idle_time_estimator.h"
@@ -63,6 +64,7 @@ class WebRenderWidgetSchedulingState;
 
 class PLATFORM_EXPORT MainThreadSchedulerImpl
     : public WebMainThreadScheduler,
+      public ThreadScheduler,
       public IdleHelper::Delegate,
       public MainThreadSchedulerHelper::Observer,
       public RenderWidgetSignals::Observer,
@@ -103,7 +105,7 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
 
   ~MainThreadSchedulerImpl() override;
 
-  // WebMainThreadSchedulerScheduler implementation:
+  // WebMainThreadScheduler implementation:
   std::unique_ptr<WebThread> CreateMainThread() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
@@ -127,7 +129,7 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   void PauseTimersForAndroidWebView() override;
   void ResumeTimersForAndroidWebView() override;
 #endif
-  std::unique_ptr<RendererPauseHandle> PauseRenderer() override
+  std::unique_ptr<ThreadScheduler::RendererPauseHandle> PauseRenderer() override
       WARN_UNUSED_RESULT;
   bool IsHighPriorityWorkAnticipated() override;
   bool ShouldYieldForHighPriorityWork() override;
@@ -145,6 +147,33 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
       const char* name,
       WebScopedVirtualTimePauser::VirtualTaskDuration duration) override;
 
+  // ThreadScheduler implementation:
+  void PostIdleTask(const base::Location&, WebThread::IdleTask) override;
+  void PostNonNestableIdleTask(const base::Location&,
+                               WebThread::IdleTask) override;
+  scoped_refptr<base::SingleThreadTaskRunner> V8TaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
+  std::unique_ptr<PageScheduler> CreatePageScheduler(
+      PageScheduler::Delegate*) override;
+  std::unique_ptr<ThreadScheduler::RendererPauseHandle> PauseScheduler()
+      override;
+  base::TimeTicks MonotonicallyIncreasingVirtualTime() override;
+  WebMainThreadScheduler* GetWebMainThreadSchedulerForTest() override;
+
+  // The following functions are defined in both WebThreadScheduler and
+  // ThreadScheduler, and have the same function signatures -- see above.
+  // This class implements those functions for both base classes.
+  //
+  // void Shutdown() override;
+  // bool ShouldYieldForHighPriorityWork() override;
+  // bool CanExceedIdleDeadlineIfRequied() override;
+  // void AddPendingNavigation(WebMainThreadScheduler::NavigatingFrameType)
+  //     override;
+  // void RemovePendingNavigation(WebMainThreadScheduler::NavigatingFrameType)
+  //     override;
+  //
+  // TODO(yutak): Reduce the overlaps and simplify.
+
   // AutoAdvancingVirtualTimeDomain::Observer implementation:
   void OnVirtualTimeAdvanced() override;
 
@@ -300,9 +329,11 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   // WebMainThreadScheduler implementation.
   // Use *TaskQueue internally.
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
-  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> InputTaskRunner() override;
 
+  // This is implemented in WebMainThreadScheduler implementation above.
+  // scoped_refptr<SingleThreadTaskRunner> CompositorTaskRunner() override;
+
   // `current_use_case` will be overwritten by the next call to UpdatePolicy.
   // Thus, this function should be only used for testing purposes.
   void SetCurrentUseCaseForTest(UseCase use_case) {
@@ -468,7 +499,7 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
 
   class TaskDurationMetricTracker;
 
-  class RendererPauseHandleImpl : public RendererPauseHandle {
+  class RendererPauseHandleImpl : public ThreadScheduler::RendererPauseHandle {
    public:
     explicit RendererPauseHandleImpl(MainThreadSchedulerImpl* scheduler);
     ~RendererPauseHandleImpl() override;
@@ -606,6 +637,8 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   // Returns true with probability of kSamplingRateForTaskUkm.
   bool ShouldRecordTaskUkm(bool has_thread_time);
 
+  static void RunIdleTask(WebThread::IdleTask, base::TimeTicks deadline);
+
   // Probabilistically record all task metadata for the current task.
   // If task belongs to a per-frame queue, this task is attributed to
   // a particular Page, otherwise it's attributed to all Pages in the process.
@@ -657,6 +690,9 @@ class PLATFORM_EXPORT MainThreadSchedulerImpl
   scoped_refptr<MainThreadTaskQueue> v8_task_queue_;
   scoped_refptr<MainThreadTaskQueue> ipc_task_queue_;
 
+  scoped_refptr<TaskQueueWithTaskType> v8_task_runner_;
+  scoped_refptr<TaskQueueWithTaskType> compositor_task_runner_;
+
   // Note |virtual_time_domain_| is lazily created.
   std::unique_ptr<AutoAdvancingVirtualTimeDomain> virtual_time_domain_;
 

third_party/blink/renderer/platform/scheduler/public/non_main_thread_scheduler.h

@@ -65,7 +65,7 @@ class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler,
       WARN_UNUSED_RESULT;
 
   // Returns TimeTicks::Now() by default.
-  base::TimeTicks MonotonicallyIncreasingVirtualTime() const override;
+  base::TimeTicks MonotonicallyIncreasingVirtualTime() override;
 
   // The following virtual methods are defined in *both* WebThreadScheduler
   // and ThreadScheduler, with identical interfaces and semantics. They are

third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h

@@ -79,7 +79,7 @@ class PLATFORM_EXPORT ThreadScheduler {
 
   // Returns the current time recognized by the scheduler, which may perhaps
   // be based on a real or virtual time domain. Used by Timer.
-  virtual base::TimeTicks MonotonicallyIncreasingVirtualTime() const = 0;
+  virtual base::TimeTicks MonotonicallyIncreasingVirtualTime() = 0;
 
   // Test helpers.
 

third_party/blink/renderer/platform/scheduler/renderer/renderer_web_scheduler_impl.cc

-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "third_party/blink/renderer/platform/scheduler/renderer/renderer_web_scheduler_impl.h"
-
-#include <memory>
-
-#include "base/memory/ptr_util.h"
-#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
-#include "third_party/blink/renderer/platform/scheduler/base/task_queue.h"
-#include "third_party/blink/renderer/platform/scheduler/child/task_queue_with_task_type.h"
-#include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
-#include "third_party/blink/renderer/platform/scheduler/main_thread/page_scheduler_impl.h"
-
-namespace blink {
-namespace scheduler {
-
-RendererWebSchedulerImpl::RendererWebSchedulerImpl(
-    MainThreadSchedulerImpl* main_thread_scheduler)
-    : WebSchedulerImpl(main_thread_scheduler,
-                       main_thread_scheduler->IdleTaskRunner(),
-                       main_thread_scheduler->V8TaskQueue()),
-      main_thread_scheduler_(main_thread_scheduler),
-      compositor_task_runner_(TaskQueueWithTaskType::Create(
-          main_thread_scheduler_->CompositorTaskQueue(),
-          TaskType::kMainThreadTaskQueueCompositor)) {}
-
-RendererWebSchedulerImpl::~RendererWebSchedulerImpl() = default;
-
-scoped_refptr<base::SingleThreadTaskRunner>
-RendererWebSchedulerImpl::CompositorTaskRunner() {
-  return compositor_task_runner_;
-}
-
-std::unique_ptr<RendererWebSchedulerImpl::RendererPauseHandle>
-RendererWebSchedulerImpl::PauseScheduler() {
-  return main_thread_scheduler_->PauseRenderer();
-}
-
-std::unique_ptr<blink::PageScheduler>
-RendererWebSchedulerImpl::CreatePageScheduler(
-    PageScheduler::Delegate* delegate) {
-  return base::WrapUnique(
-      new PageSchedulerImpl(delegate, main_thread_scheduler_,
-                            !blink::RuntimeEnabledFeatures::
-                                TimerThrottlingForBackgroundTabsEnabled()));
-}
-
-base::TimeTicks RendererWebSchedulerImpl::MonotonicallyIncreasingVirtualTime()
-    const {
-  return main_thread_scheduler_->GetActiveTimeDomain()->Now();
-}
-
-WebMainThreadScheduler*
-RendererWebSchedulerImpl::GetWebMainThreadSchedulerForTest() {
-  return main_thread_scheduler_;
-}
-
-}  // namespace scheduler
-}  // namespace blink

third_party/blink/renderer/platform/scheduler/renderer/renderer_web_scheduler_impl.h

-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_RENDERER_RENDERER_WEB_SCHEDULER_IMPL_H_
-#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_RENDERER_RENDERER_WEB_SCHEDULER_IMPL_H_
-
-#include "third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.h"
-
-namespace blink {
-namespace scheduler {
-
-class MainThreadSchedulerImpl;
-
-class PLATFORM_EXPORT RendererWebSchedulerImpl : public WebSchedulerImpl {
- public:
-  explicit RendererWebSchedulerImpl(
-      MainThreadSchedulerImpl* main_thread_scheduler);
-
-  ~RendererWebSchedulerImpl() override;
-
-  // ThreadScheduler implementation:
-  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
-  std::unique_ptr<RendererPauseHandle> PauseScheduler() override
-      WARN_UNUSED_RESULT;
-  std::unique_ptr<PageScheduler> CreatePageScheduler(
-      PageScheduler::Delegate*) override;
-
-  base::TimeTicks MonotonicallyIncreasingVirtualTime() const override;
-
-  WebMainThreadScheduler* GetWebMainThreadSchedulerForTest() override;
-
- private:
-  MainThreadSchedulerImpl* main_thread_scheduler_;  // NOT OWNED
-  scoped_refptr<TaskQueueWithTaskType> compositor_task_runner_;
-};
-
-}  // namespace scheduler
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_RENDERER_RENDERER_WEB_SCHEDULER_IMPL_H_

third_party/blink/renderer/platform/scheduler/renderer/webthread_impl_for_renderer_scheduler.cc

@@ -7,15 +7,13 @@
 #include "base/location.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue.h"
 #include "third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h"
-#include "third_party/blink/renderer/platform/scheduler/renderer/renderer_web_scheduler_impl.h"
 
 namespace blink {
 namespace scheduler {
 
 WebThreadImplForRendererScheduler::WebThreadImplForRendererScheduler(
     MainThreadSchedulerImpl* scheduler)
-    : web_scheduler_(new RendererWebSchedulerImpl(scheduler)),
-      task_runner_(scheduler->DefaultTaskQueue()),
+    : task_runner_(scheduler->DefaultTaskQueue()),
       idle_task_runner_(scheduler->IdleTaskRunner()),
       scheduler_(scheduler),
       thread_id_(base::PlatformThread::CurrentId()) {}
@@ -28,7 +26,7 @@ blink::PlatformThreadId WebThreadImplForRendererScheduler::ThreadId() const {
 }
 
 blink::ThreadScheduler* WebThreadImplForRendererScheduler::Scheduler() const {
-  return web_scheduler_.get();
+  return scheduler_;
 }
 
 SingleThreadIdleTaskRunner*

third_party/blink/renderer/platform/scheduler/renderer/webthread_impl_for_renderer_scheduler.h

@@ -18,7 +18,6 @@ class ThreadScheduler;
 namespace blink {
 namespace scheduler {
 class MainThreadSchedulerImpl;
-class WebSchedulerImpl;
 
 class PLATFORM_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
  public:
@@ -46,7 +45,6 @@ class PLATFORM_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
   void RemoveTaskTimeObserverInternal(
       base::sequence_manager::TaskTimeObserver*) override;
 
-  std::unique_ptr<WebSchedulerImpl> web_scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   MainThreadSchedulerImpl* scheduler_;  // Not owned.

third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler.cc

@@ -88,8 +88,7 @@ NonMainThreadScheduler::PauseScheduler() {
   return nullptr;
 }
 
-base::TimeTicks NonMainThreadScheduler::MonotonicallyIncreasingVirtualTime()
-    const {
+base::TimeTicks NonMainThreadScheduler::MonotonicallyIncreasingVirtualTime() {
   return base::TimeTicks::Now();
 }