[DONT COMMIT] Fix perf regression in CompositorWorkerScheduler

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc

Index: third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc b/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
index 10522bcb421062c9dc6a85589a2af35d6936eeba..dd99d026f1e9dc5a05bf624b74acc08c4af598bc 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
@@ -17,6 +17,183 @@
 namespace blink {
 namespace scheduler {
 
+namespace {
+
+class CompositorWorkerTaskRunnerWrapper : public TaskQueue {
+ public:
+  explicit CompositorWorkerTaskRunnerWrapper(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : task_runner_(task_runner) {}
+  ~CompositorWorkerTaskRunnerWrapper() override {}
+
+  // TaskQueue implementation:
+  void UnregisterTaskQueue() override { NOTREACHED(); }
+
+  bool RunsTasksInCurrentSequence() const override {
+    return task_runner_->RunsTasksOnCurrentThread();
+  }
+
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       base::OnceClosure task,
+                       base::TimeDelta delay) override {
+    return task_runner_->PostDelayedTask(from_here, std::move(task), delay);
+  }
+
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return task_runner_->PostNonNestableDelayedTask(from_here, std::move(task),
+                                                    delay);
+  }
+
+  std::unique_ptr<QueueEnabledVoter> CreateQueueEnabledVoter() override {
+    NOTREACHED();
+    return nullptr;
+  }
+
+  void InsertFence(InsertFencePosition position) override { NOTREACHED(); }
+
+  bool HasFence() const override {
+    NOTREACHED();
+    return false;
+  }
+
+  void RemoveFence() override { NOTREACHED(); }
+
+  bool BlockedByFence() const override {
+    NOTREACHED();
+    return false;
+  }
+
+  bool IsQueueEnabled() const override {
+    NOTREACHED();
+    return true;
+  }
+
+  bool IsEmpty() const override {
+    NOTREACHED();
+    return false;
+  };
+
+  size_t GetNumberOfPendingTasks() const override {
+    NOTREACHED();
+    return 0;
+  };
+
+  bool HasTaskToRunImmediately() const override {
+    NOTREACHED();
+    return false;
+  };
+
+  base::Optional<base::TimeTicks> GetNextScheduledWakeUp() override {
+    NOTREACHED();
+    return base::nullopt;
+  }
+
+  const char* GetName() const override {
+    NOTREACHED();
+    return nullptr;
+  };
+
+  QueueType GetQueueType() const override {
+    NOTREACHED();
+    return QueueType::DEFAULT;
+  }
+
+  void SetQueuePriority(QueuePriority priority) override { NOTREACHED(); }
+
+  QueuePriority GetQueuePriority() const override {
+    NOTREACHED();
+    return QueuePriority::NORMAL_PRIORITY;
+  };
+
+  void AddTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) override {
+    NOTREACHED();
+  }
+
+  void RemoveTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) override {
+    NOTREACHED();
+  }
+
+  void SetTimeDomain(TimeDomain* domain) override { NOTREACHED(); }
+
+  TimeDomain* GetTimeDomain() const override { return nullptr; }
+
+  void SetBlameContext(base::trace_event::BlameContext*) override {
+    NOTREACHED();
+  }
+
+  void SetObserver(Observer* observer) override { NOTREACHED(); }
+
+ protected:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+};
+/*
+class GlobalScopeSchedulerTaskRunnerWrapper
+    : public CompositorWorkerTaskRunnerWrapper {
+ public:
+  class TaskWrapper {
+   public:
+    TaskWrapper() : weak_ptr_factory_(this) {}
+
+    void RunTask(base::OnceClosure task) { std::move(task).Run(); }
+
+    base::WeakPtr<TaskWrapper> GetWeakPtr() {
+      return weak_ptr_factory_.GetWeakPtr();
+    }
+
+   private:
+    base::WeakPtrFactory<TaskWrapper> weak_ptr_factory_;
+  };
+
+  explicit GlobalScopeSchedulerTaskRunnerWrapper(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : CompositorWorkerTaskRunnerWrapper(std::move(task_runner)),
+        task_wrapper_(base::MakeUnique<TaskWrapper>()) {
+    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    task_wrapper_weak_ptr_ = task_wrapper_->GetWeakPtr();
+  }
+
+  ~GlobalScopeSchedulerTaskRunnerWrapper() override = default;
+
+  // TaskQueue implementation:
+  void UnregisterTaskQueue() override {
+    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    // Abort all queued tasks.
+    task_wrapper_.reset();
+  }
+
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       base::OnceClosure task,
+                       base::TimeDelta delay) override {
+    return task_runner_->PostDelayedTask(
+        from_here,
+        BindOnce(&TaskWrapper::RunTask, task_wrapper_weak_ptr_,
+                 std::move(task)),
+        delay);
+  }
+
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override {
+    return task_runner_->PostNonNestableDelayedTask(
+        from_here,
+        BindOnce(&TaskWrapper::RunTask, task_wrapper_weak_ptr_,
+                 std::move(task)),
+        delay);
+  }
+
+ private:
+  std::unique_ptr<TaskWrapper> task_wrapper_;
+
+  // Used for posting a cross thread task.
+  base::WeakPtr<TaskWrapper> task_wrapper_weak_ptr_;
+};
+*/
+}  // namespace
+
 CompositorWorkerScheduler::CompositorWorkerScheduler(
     base::Thread* thread,
     scoped_refptr<SchedulerTqmDelegate> main_task_runner)
@@ -28,7 +205,19 @@ CompositorWorkerScheduler::~CompositorWorkerScheduler() {}
 void CompositorWorkerScheduler::Init() {}
 
 scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskQueue() {
-  return helper_->DefaultTaskQueue();
+  // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC
+  // without regressing performance of the rest of the system.
+  return make_scoped_refptr(
+      new CompositorWorkerTaskRunnerWrapper(thread_->task_runner()));
+}
+
+scoped_refptr<TaskQueue> CompositorWorkerScheduler::CreateUnthrottledTaskRunner(
+    TaskQueue::QueueType) {
+  // Assumes this is called only from WorkerGlobalScopeScheduller.
+  return make_scoped_refptr(
+      new CompositorWorkerTaskRunnerWrapper(thread_->task_runner()));
+  // return make_scoped_refptr(
+  //     new GlobalScopeSchedulerTaskRunnerWrapper(thread_->task_runner()));
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
@@ -56,12 +245,12 @@ bool CompositorWorkerScheduler::ShouldYieldForHighPriorityWork() {
 
 void CompositorWorkerScheduler::AddTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
-  helper_->AddTaskObserver(task_observer);
+  thread_->message_loop()->AddTaskObserver(task_observer);
 }
 
 void CompositorWorkerScheduler::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
-  helper_->RemoveTaskObserver(task_observer);
+  thread_->message_loop()->RemoveTaskObserver(task_observer);
 }
 
 void CompositorWorkerScheduler::Shutdown() {}