scheduler: Merge WebSchedulerImpl into NonMainThreadScheduler.

As part of ongoing scheduler architecture refactoring, this patch
updates NonMainThreadScheduler so it can be used in place of
WebSchedulerImpl.

Specifically, this patch does the following:

* Let NonMainThreadScheduler inherit from ThreadScheduler (in addition
  to WebThreadScheduler).
* Implement required virtual functions.
* Remove WebSchedulerImpl instance from WebThreadImplForWorkerScheduler,
  and make it work with NonMainThreadScheduler.

Now, WebThreadImplForWorkerScheduler works without relying on
WebSchedulerImpl.

WebSchedulerImpl is still used by RendererWebSchedulerImpl, so the class
itself is not removed yet.

This patch adds post-constructor initialization to NonMainThreadScheduler
in order to initialize a member requiring a virtual function call. The
work is done in the Init() function which is now a non-virtual function
of the class, and the original virtual Init() function is renamed to
InitImpl(), which is called from Init().

Bug: 826203
Change-Id: I7499fb1df197b760e2289414020f7136e3545a46
Reviewed-on: https://chromium-review.googlesource.com/1032452
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@{#556394}

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

@@ -23,7 +23,7 @@ class MockIdleDeadlineScheduler final : public ThreadScheduler {
   base::SingleThreadTaskRunner* V8TaskRunner() override { return nullptr; }
   void Shutdown() override {}
   bool ShouldYieldForHighPriorityWork() override { return true; }
-  bool CanExceedIdleDeadlineIfRequired() override { return false; }
+  bool CanExceedIdleDeadlineIfRequired() const override { return false; }
   void PostIdleTask(const base::Location&, WebThread::IdleTask) override {}
   void PostNonNestableIdleTask(const base::Location&,
                                WebThread::IdleTask) override {}

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

@@ -30,7 +30,7 @@ class MockScriptedIdleTaskControllerScheduler final : public ThreadScheduler {
   base::SingleThreadTaskRunner* V8TaskRunner() override { return nullptr; }
   void Shutdown() override {}
   bool ShouldYieldForHighPriorityWork() override { return should_yield_; }
-  bool CanExceedIdleDeadlineIfRequired() override { return false; }
+  bool CanExceedIdleDeadlineIfRequired() const override { return false; }
   void PostIdleTask(const base::Location&,
                     WebThread::IdleTask idle_task) override {
     idle_task_ = std::move(idle_task);

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

@@ -34,7 +34,7 @@ bool WebSchedulerImpl::ShouldYieldForHighPriorityWork() {
   return thread_scheduler_->ShouldYieldForHighPriorityWork();
 }
 
-bool WebSchedulerImpl::CanExceedIdleDeadlineIfRequired() {
+bool WebSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
   return thread_scheduler_->CanExceedIdleDeadlineIfRequired();
 }
 

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

@@ -32,7 +32,7 @@ class PLATFORM_EXPORT WebSchedulerImpl : public ThreadScheduler {
   // ThreadScheduler implementation:
   void Shutdown() override;
   bool ShouldYieldForHighPriorityWork() override;
-  bool CanExceedIdleDeadlineIfRequired() override;
+  bool CanExceedIdleDeadlineIfRequired() const override;
   void PostIdleTask(const base::Location& location,
                     WebThread::IdleTask task) override;
   void PostNonNestableIdleTask(const base::Location& location,

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

@@ -11,7 +11,6 @@
 #include "base/synchronization/waitable_event.h"
 #include "base/time/default_tick_clock.h"
 #include "third_party/blink/renderer/platform/scheduler/base/task_queue.h"
-#include "third_party/blink/renderer/platform/scheduler/child/web_scheduler_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/child/worker_scheduler_proxy.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.h"
 
@@ -65,10 +64,6 @@ void WebThreadImplForWorkerScheduler::InitOnThread(
   non_main_thread_scheduler_->Init();
   task_queue_ = non_main_thread_scheduler_->DefaultTaskQueue();
   idle_task_runner_ = non_main_thread_scheduler_->IdleTaskRunner();
-  web_scheduler_.reset(
-      new WebSchedulerImpl(non_main_thread_scheduler_.get(),
-                           non_main_thread_scheduler_->IdleTaskRunner(),
-                           non_main_thread_scheduler_->DefaultTaskQueue()));
   base::MessageLoopCurrent::Get()->AddDestructionObserver(this);
   completion->Signal();
 }
@@ -79,7 +74,6 @@ void WebThreadImplForWorkerScheduler::ShutdownOnThread(
 
   task_queue_ = nullptr;
   idle_task_runner_ = nullptr;
-  web_scheduler_ = nullptr;
   non_main_thread_scheduler_ = nullptr;
 
   if (completion)
@@ -101,7 +95,7 @@ blink::PlatformThreadId WebThreadImplForWorkerScheduler::ThreadId() const {
 }
 
 blink::ThreadScheduler* WebThreadImplForWorkerScheduler::Scheduler() const {
-  return web_scheduler_.get();
+  return non_main_thread_scheduler_.get();
 }
 
 SingleThreadIdleTaskRunner* WebThreadImplForWorkerScheduler::GetIdleTaskRunner()

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

@@ -25,7 +25,6 @@ namespace blink {
 namespace scheduler {
 class SingleThreadIdleTaskRunner;
 class TaskQueue;
-class WebSchedulerImpl;
 class NonMainThreadScheduler;
 class WorkerSchedulerProxy;
 
@@ -76,7 +75,6 @@ class PLATFORM_EXPORT WebThreadImplForWorkerScheduler
   const WebThreadType thread_type_;
   std::unique_ptr<scheduler::WorkerSchedulerProxy> worker_scheduler_proxy_;
   std::unique_ptr<scheduler::NonMainThreadScheduler> non_main_thread_scheduler_;
-  std::unique_ptr<scheduler::WebSchedulerImpl> web_scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner_;
   scoped_refptr<TaskQueue> task_queue_;
   scoped_refptr<scheduler::SingleThreadIdleTaskRunner> idle_task_runner_;

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

@@ -62,9 +62,7 @@ void RemoveTaskObserver(WebThreadImplForWorkerScheduler* thread,
 }
 
 void ShutdownOnThread(WebThreadImplForWorkerScheduler* thread) {
-  WebSchedulerImpl* web_scheduler_impl =
-      static_cast<WebSchedulerImpl*>(thread->Scheduler());
-  web_scheduler_impl->Shutdown();
+  thread->Scheduler()->Shutdown();
 }
 
 class WebThreadImplForWorkerSchedulerTest : public testing::Test {

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

@@ -14,13 +14,19 @@
 #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/child/worker_task_queue.h"
+#include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.h"
 
 namespace blink {
 namespace scheduler {
+class TaskRunnerImpl;
 class WorkerSchedulerProxy;
 
-class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler {
+// TODO(yutak): Remove the dependency to WebThreadScheduler. We want to
+// separate interfaces to Chromium (in blink/public/platform/scheduler) from
+// interfaces to Blink (in blink/renderer/platform/scheduler/public).
+class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler,
+                                               public ThreadScheduler {
  public:
   ~NonMainThreadScheduler() override;
 
@@ -34,7 +40,7 @@ class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler {
 
   // Must be called before the scheduler can be used. Does any post construction
   // initialization needed such as initializing idle period detection.
-  virtual void Init() = 0;
+  void Init();
 
   virtual void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
                                const TaskQueue::Task& task,
@@ -42,14 +48,54 @@ class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler {
                                base::TimeTicks end,
                                base::Optional<base::TimeDelta> thread_time) = 0;
 
+  // ThreadScheduler implementation.
+  // TODO(yutak): Some functions are only meaningful in main thread. Move them
+  // to MainThreadScheduler.
+  void PostIdleTask(const base::Location& location,
+                    WebThread::IdleTask task) override;
+  void PostNonNestableIdleTask(const base::Location& location,
+                               WebThread::IdleTask task) override;
+  base::SingleThreadTaskRunner* V8TaskRunner() override;
+  base::SingleThreadTaskRunner* CompositorTaskRunner() override;
+  std::unique_ptr<PageScheduler> CreatePageScheduler(
+      PageScheduler::Delegate*) override;
+  std::unique_ptr<RendererPauseHandle> PauseScheduler() override
+      WARN_UNUSED_RESULT;
+  void AddPendingNavigation(
+      scheduler::WebMainThreadScheduler::NavigatingFrameType type) override {}
+  void RemovePendingNavigation(
+      scheduler::WebMainThreadScheduler::NavigatingFrameType type) override {}
+
+  // Returns TimeTicks::Now() by default.
+  base::TimeTicks MonotonicallyIncreasingVirtualTime() const override;
+
+  // The following virtual methods are defined in *both* WebThreadScheduler
+  // and ThreadScheduler, with identical interfaces and semantics. They are
+  // overriden in a subclass, effectively implementing the virtual methods
+  // in both classes at the same time. This is allowed in C++, as long as
+  // there is only one final overrider (i.e. definitions in base classes are
+  // not used in instantiated objects, since otherwise they may have multiple
+  // definitions of the virtual function in question).
+  //
+  // virtual void Shutdown();
+  // virtual bool ShouldYieldForHighPriorityWork();
+  // virtual bool CanExceedIdleDeadlineIfRequired() const;
+
   scoped_refptr<WorkerTaskQueue> CreateTaskRunner();
 
  protected:
   explicit NonMainThreadScheduler(
       std::unique_ptr<NonMainThreadSchedulerHelper> helper);
 
+  // Called during Init() for delayed initialization for subclasses.
+  virtual void InitImpl() = 0;
+
   std::unique_ptr<NonMainThreadSchedulerHelper> helper_;
 
+ private:
+  static void RunIdleTask(WebThread::IdleTask task, base::TimeTicks deadline);
+  scoped_refptr<TaskRunnerImpl> v8_task_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(NonMainThreadScheduler);
 };
 

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

@@ -42,7 +42,7 @@ class PLATFORM_EXPORT ThreadScheduler {
   // its deadline has expired - post a new idle task for the continuation of
   // the work in this case.
   // Must be called from the associated WebThread.
-  virtual bool CanExceedIdleDeadlineIfRequired() = 0;
+  virtual bool CanExceedIdleDeadlineIfRequired() const = 0;
 
   // Schedule an idle task to run the associated WebThread. For non-critical
   // tasks which may be reordered relative to other task types and may be

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

@@ -31,7 +31,7 @@ scoped_refptr<WorkerTaskQueue> CompositorThreadScheduler::DefaultTaskQueue() {
   return helper_->DefaultWorkerTaskQueue();
 }
 
-void CompositorThreadScheduler::Init() {}
+void CompositorThreadScheduler::InitImpl() {}
 
 void CompositorThreadScheduler::OnTaskCompleted(
     WorkerTaskQueue* worker_task_queue,

third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.h

@@ -32,16 +32,15 @@ class PLATFORM_EXPORT CompositorThreadScheduler
 
   ~CompositorThreadScheduler() override;
 
-  // WorkerScheduler:
+  // NonMainThreadScheduler:
   scoped_refptr<WorkerTaskQueue> DefaultTaskQueue() override;
-  void Init() override;
   void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
                        const TaskQueue::Task& task,
                        base::TimeTicks start,
                        base::TimeTicks end,
                        base::Optional<base::TimeDelta> thread_time) override;
 
-  // ChildScheduler:
+  // WebThreadScheduler:
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
   scoped_refptr<scheduler::SingleThreadIdleTaskRunner> IdleTaskRunner()
       override;
@@ -59,6 +58,10 @@ class PLATFORM_EXPORT CompositorThreadScheduler
   void DidProcessIdleTask() override;
   base::TimeTicks NowTicks() override;
 
+ protected:
+  // NonMainThreadScheduler:
+  void InitImpl() override;
+
  private:
   base::Thread* thread_;
 

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

@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "third_party/blink/renderer/platform/scheduler/child/task_runner_impl.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.h"
 
 namespace blink {
@@ -25,6 +26,17 @@ std::unique_ptr<NonMainThreadScheduler> NonMainThreadScheduler::Create(
       thread_type, TaskQueueManager::TakeOverCurrentThread(), proxy);
 }
 
+void NonMainThreadScheduler::Init() {
+  InitImpl();
+
+  // DefaultTaskQueue() is a virtual function, so it can't be called in the
+  // constructor. Also, DefaultTaskQueue() checks if InitImpl() is called.
+  // Therefore, v8_task_runner_ needs to be initialized here.
+  // TODO(kraynov): Ditch kDeprecatedNone here.
+  v8_task_runner_ =
+      TaskRunnerImpl::Create(DefaultTaskQueue(), TaskType::kDeprecatedNone);
+}
+
 scoped_refptr<WorkerTaskQueue> NonMainThreadScheduler::CreateTaskRunner() {
   helper_->CheckOnValidThread();
   return helper_->NewTaskQueue(TaskQueue::Spec("worker_tq")
@@ -32,5 +44,49 @@ scoped_refptr<WorkerTaskQueue> NonMainThreadScheduler::CreateTaskRunner() {
                                    .SetTimeDomain(nullptr));
 }
 
+void NonMainThreadScheduler::RunIdleTask(blink::WebThread::IdleTask task,
+                                         base::TimeTicks deadline) {
+  std::move(task).Run((deadline - base::TimeTicks()).InSecondsF());
+}
+
+void NonMainThreadScheduler::PostIdleTask(const base::Location& location,
+                                          blink::WebThread::IdleTask task) {
+  IdleTaskRunner()->PostIdleTask(
+      location,
+      base::BindOnce(&NonMainThreadScheduler::RunIdleTask, std::move(task)));
+}
+
+void NonMainThreadScheduler::PostNonNestableIdleTask(
+    const base::Location& location,
+    blink::WebThread::IdleTask task) {
+  IdleTaskRunner()->PostNonNestableIdleTask(
+      location,
+      base::BindOnce(&NonMainThreadScheduler::RunIdleTask, std::move(task)));
+}
+
+base::SingleThreadTaskRunner* NonMainThreadScheduler::V8TaskRunner() {
+  return v8_task_runner_.get();
+}
+
+base::SingleThreadTaskRunner* NonMainThreadScheduler::CompositorTaskRunner() {
+  return nullptr;
+}
+
+std::unique_ptr<blink::PageScheduler>
+NonMainThreadScheduler::CreatePageScheduler(PageScheduler::Delegate* delegate) {
+  NOTREACHED();
+  return nullptr;
+}
+
+std::unique_ptr<NonMainThreadScheduler::RendererPauseHandle>
+NonMainThreadScheduler::PauseScheduler() {
+  return nullptr;
+}
+
+base::TimeTicks NonMainThreadScheduler::MonotonicallyIncreasingVirtualTime()
+    const {
+  return base::TimeTicks::Now();
+}
+
 }  // namespace scheduler
 }  // namespace blink

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

@@ -145,7 +145,7 @@ scoped_refptr<WorkerTaskQueue> WorkerThreadScheduler::DefaultTaskQueue() {
   return helper_->DefaultWorkerTaskQueue();
 }
 
-void WorkerThreadScheduler::Init() {
+void WorkerThreadScheduler::InitImpl() {
   initialized_ = true;
   idle_helper_.EnableLongIdlePeriod();
 }

third_party/blink/renderer/platform/scheduler/worker/worker_thread_scheduler.h

@@ -47,7 +47,6 @@ class PLATFORM_EXPORT WorkerThreadScheduler : public NonMainThreadScheduler,
 
   // NonMainThreadScheduler implementation:
   scoped_refptr<WorkerTaskQueue> DefaultTaskQueue() override;
-  void Init() override;
   void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
                        const TaskQueue::Task& task,
                        base::TimeTicks start,
@@ -71,6 +70,9 @@ class PLATFORM_EXPORT WorkerThreadScheduler : public NonMainThreadScheduler,
   scoped_refptr<WorkerTaskQueue> ControlTaskQueue();
 
  protected:
+  // NonMainThreadScheduler implementation:
+  void InitImpl() override;
+
   // IdleHelper::Delegate implementation:
   bool CanEnterLongIdlePeriod(
       base::TimeTicks now,