Remove PostIdleTask() from WebThreadBase.

The function is only used in a test, and no production code does not
rely on it. So it can be removed entirely. This simplifies the
implementation of each subclass of WebThreadBase.

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

third_party/blink/public/platform/scheduler/child/webthread_base.h

@@ -23,7 +23,6 @@ class TaskTimeObserver;
 
 namespace blink {
 namespace scheduler {
-class SingleThreadIdleTaskRunner;
 
 // TODO(scheduler-dev): Do not expose this class in Blink public API.
 class BLINK_PLATFORM_EXPORT WebThreadBase : public WebThread {
@@ -41,8 +40,6 @@ class BLINK_PLATFORM_EXPORT WebThreadBase : public WebThread {
   bool IsCurrentThread() const override;
   PlatformThreadId ThreadId() const override = 0;
 
-  virtual void PostIdleTask(const base::Location& location, IdleTask idle_task);
-
   void AddTaskObserver(TaskObserver* observer) override;
   void RemoveTaskObserver(TaskObserver* observer) override;
 
@@ -51,10 +48,6 @@ class BLINK_PLATFORM_EXPORT WebThreadBase : public WebThread {
   void RemoveTaskTimeObserver(
       base::sequence_manager::TaskTimeObserver* task_time_observer) override;
 
-  // Returns the base::Bind-compatible task runner for posting idle tasks to
-  // this thread. Can be called from any thread.
-  virtual scheduler::SingleThreadIdleTaskRunner* GetIdleTaskRunner() const = 0;
-
   virtual void Init() = 0;
 
  protected:

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

@@ -15,7 +15,6 @@
 #include "base/message_loop/message_loop_current.h"
 #include "base/pending_task.h"
 #include "base/threading/platform_thread.h"
-#include "third_party/blink/public/platform/scheduler/single_thread_idle_task_runner.h"
 #include "third_party/blink/renderer/platform/scheduler/child/webthread_impl_for_worker_scheduler.h"
 #include "third_party/blink/renderer/platform/scheduler/utility/webthread_impl_for_utility_thread.h"
 #include "third_party/blink/renderer/platform/scheduler/worker/compositor_thread_scheduler.h"
@@ -88,19 +87,6 @@ void WebThreadBase::RemoveTaskObserverInternal(
   base::MessageLoopCurrent::Get()->RemoveTaskObserver(observer);
 }
 
-// static
-void WebThreadBase::RunWebThreadIdleTask(blink::WebThread::IdleTask idle_task,
-                                         base::TimeTicks deadline) {
-  std::move(idle_task).Run((deadline - base::TimeTicks()).InSecondsF());
-}
-
-void WebThreadBase::PostIdleTask(const base::Location& location,
-                                 IdleTask idle_task) {
-  GetIdleTaskRunner()->PostIdleTask(
-      location, base::BindOnce(&WebThreadBase::RunWebThreadIdleTask,
-                               std::move(idle_task)));
-}
-
 bool WebThreadBase::IsCurrentThread() const {
   return GetTaskRunner()->BelongsToCurrentThread();
 }

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

@@ -67,7 +67,6 @@ void WebThreadImplForWorkerScheduler::InitOnThread(
   task_queue_ = non_main_thread_scheduler_->DefaultTaskQueue();
   task_runner_ = TaskQueueWithTaskType::Create(
       task_queue_, TaskType::kWorkerThreadTaskQueueDefault);
-  idle_task_runner_ = non_main_thread_scheduler_->IdleTaskRunner();
   base::MessageLoopCurrent::Get()->AddDestructionObserver(this);
   completion->Signal();
 }
@@ -78,7 +77,6 @@ void WebThreadImplForWorkerScheduler::ShutdownOnThread(
 
   task_queue_ = nullptr;
   task_runner_ = nullptr;
-  idle_task_runner_ = nullptr;
   non_main_thread_scheduler_ = nullptr;
 
   if (completion)
@@ -103,11 +101,6 @@ blink::ThreadScheduler* WebThreadImplForWorkerScheduler::Scheduler() const {
   return non_main_thread_scheduler_.get();
 }
 
-SingleThreadIdleTaskRunner* WebThreadImplForWorkerScheduler::GetIdleTaskRunner()
-    const {
-  return idle_task_runner_.get();
-}
-
 scoped_refptr<base::SingleThreadTaskRunner>
 WebThreadImplForWorkerScheduler::GetTaskRunner() const {
   return task_runner_;

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

@@ -27,7 +27,6 @@ class ThreadScheduler;
 namespace blink {
 namespace scheduler {
 
-class SingleThreadIdleTaskRunner;
 class NonMainThreadSchedulerImpl;
 class WorkerSchedulerProxy;
 
@@ -45,7 +44,6 @@ class PLATFORM_EXPORT WebThreadImplForWorkerScheduler
   scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const override;
 
   // WebThreadBase implementation.
-  scheduler::SingleThreadIdleTaskRunner* GetIdleTaskRunner() const override;
   void Init() override;
 
   // base::MessageLoopCurrent::DestructionObserver implementation.
@@ -84,7 +82,6 @@ class PLATFORM_EXPORT WebThreadImplForWorkerScheduler
       non_main_thread_scheduler_;
   scoped_refptr<base::sequence_manager::TaskQueue> task_queue_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  scoped_refptr<scheduler::SingleThreadIdleTaskRunner> idle_task_runner_;
 
   base::AtomicFlag was_shutdown_on_thread_;
 };

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

@@ -136,27 +136,6 @@ TEST_F(WebThreadImplForWorkerSchedulerTest,
   thread_.reset();
 }
 
-TEST_F(WebThreadImplForWorkerSchedulerTest, TestIdleTask) {
-  MockIdleTask task;
-  base::WaitableEvent completion(
-      base::WaitableEvent::ResetPolicy::AUTOMATIC,
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
-
-  EXPECT_CALL(task, Run(_));
-  ON_CALL(task, Run(_)).WillByDefault(Invoke([&completion](double) {
-    completion.Signal();
-  }));
-
-  thread_->PostIdleTask(
-      FROM_HERE, base::BindOnce(&MockIdleTask::Run, WTF::Unretained(&task)));
-  // We need to post a wake-up task or idle work will never happen.
-  PostDelayedCrossThreadTask(*thread_->GetTaskRunner(), FROM_HERE,
-                             CrossThreadBind([] {}),
-                             TimeDelta::FromMilliseconds(50));
-
-  completion.Wait();
-}
-
 TEST_F(WebThreadImplForWorkerSchedulerTest, TestTaskObserver) {
   std::string calls;
   TestObserver observer(&calls);

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

@@ -14,7 +14,6 @@ namespace scheduler {
 WebThreadImplForRendererScheduler::WebThreadImplForRendererScheduler(
     MainThreadSchedulerImpl* scheduler)
     : task_runner_(scheduler->DefaultTaskRunner()),
-      idle_task_runner_(scheduler->IdleTaskRunner()),
       scheduler_(scheduler),
       thread_id_(base::PlatformThread::CurrentId()) {}
 
@@ -29,11 +28,6 @@ blink::ThreadScheduler* WebThreadImplForRendererScheduler::Scheduler() const {
   return scheduler_;
 }
 
-SingleThreadIdleTaskRunner*
-WebThreadImplForRendererScheduler::GetIdleTaskRunner() const {
-  return idle_task_runner_.get();
-}
-
 scoped_refptr<base::SingleThreadTaskRunner>
 WebThreadImplForRendererScheduler::GetTaskRunner() const {
   return task_runner_;

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

@@ -31,7 +31,6 @@ class PLATFORM_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
   scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const override;
 
   // WebThreadBase implementation.
-  SingleThreadIdleTaskRunner* GetIdleTaskRunner() const override;
   void Init() override;
 
  private:
@@ -46,7 +45,6 @@ class PLATFORM_EXPORT WebThreadImplForRendererScheduler : public WebThreadBase {
       base::sequence_manager::TaskTimeObserver*) override;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   MainThreadSchedulerImpl* scheduler_;  // Not owned.
   PlatformThreadId thread_id_;
 };

third_party/blink/renderer/platform/scheduler/utility/webthread_impl_for_utility_thread.cc

@@ -29,12 +29,6 @@ WebThreadImplForUtilityThread::GetTaskRunner() const {
   return task_runner_;
 }
 
-scheduler::SingleThreadIdleTaskRunner*
-WebThreadImplForUtilityThread::GetIdleTaskRunner() const {
-  NOTIMPLEMENTED();
-  return nullptr;
-}
-
 void WebThreadImplForUtilityThread::Init() {}
 
 }  // namespace scheduler

third_party/blink/renderer/platform/scheduler/utility/webthread_impl_for_utility_thread.h

@@ -26,7 +26,6 @@ class PLATFORM_EXPORT WebThreadImplForUtilityThread
   scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const override;
 
   // WebThreadBase implementation.
-  scheduler::SingleThreadIdleTaskRunner* GetIdleTaskRunner() const override;
   void Init() override;
 
  private: