WebTaskRunnerImpl to take a TaskQueue

components/scheduler/child/compositor_worker_scheduler.cc

Index: components/scheduler/child/compositor_worker_scheduler.cc
diff --git a/components/scheduler/child/compositor_worker_scheduler.cc b/components/scheduler/child/compositor_worker_scheduler.cc
index 3b3500efb781ff472d97f5061f77219accf2c6c5..33535ce6fa96f3f280c1fe7ea6110b869193be2d 100644
--- a/components/scheduler/child/compositor_worker_scheduler.cc
+++ b/components/scheduler/child/compositor_worker_scheduler.cc
@@ -9,6 +9,100 @@
 
 namespace scheduler {
 
+// TODO(scheduler-dev): Get rid of this asap!
+namespace {
+class CompositorWorkerTaskRunnerWrapper : public TaskQueue {
+ public:
+  explicit CompositorWorkerTaskRunnerWrapper(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : task_runner_(task_runner) {}
+
+  // TaskQueue implementation:
+  void UnregisterTaskQueue() override { NOTREACHED(); }
+
+  bool RunsTasksOnCurrentThread() const override {
+    return task_runner_->RunsTasksOnCurrentThread();
+  }
+
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override {
+    return task_runner_->PostDelayedTask(from_here, task, delay);
+  }
+
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const base::Closure& task,
+                                  base::TimeDelta delay) override {
+    return task_runner_->PostNonNestableDelayedTask(from_here, task, delay);
+  }
+
+  void SetQueueEnabled(bool enabled) override { NOTREACHED(); }
+
+  bool IsQueueEnabled() const override {
+    NOTREACHED();
+    return true;
+  }
+
+  bool IsEmpty() const override {
+    NOTREACHED();
+    return false;
+  };
+
+  bool HasPendingImmediateWork() const override {
+    NOTREACHED();
+    return false;
+  };
+
+  bool NeedsPumping() const override {
+    NOTREACHED();
+    return false;
+  };
+
+  const char* GetName() const override {
+    NOTREACHED();
+    return nullptr;
+  };
+
+  void SetQueuePriority(QueuePriority priority) override { NOTREACHED(); }
+
+  QueuePriority GetQueuePriority() const override {
+    NOTREACHED();
+    return QueuePriority::NORMAL_PRIORITY;
+  };
+
+  void SetPumpPolicy(PumpPolicy pump_policy) override { NOTREACHED(); }
+
+  PumpPolicy GetPumpPolicy() const override {
+    NOTREACHED();
+    return PumpPolicy::AUTO;
+  };
+
+  void PumpQueue(bool may_post_dowork) override { NOTREACHED(); }
+
+  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 {
+    NOTREACHED();
+    return nullptr;
+  }
+
+ private:
+  ~CompositorWorkerTaskRunnerWrapper() override {}
+
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+};
+}  // namespace
+
 CompositorWorkerScheduler::CompositorWorkerScheduler(base::Thread* thread)
     : thread_(thread) {}
 
@@ -16,11 +110,11 @@ CompositorWorkerScheduler::~CompositorWorkerScheduler() {}
 
 void CompositorWorkerScheduler::Init() {}
 
-scoped_refptr<base::SingleThreadTaskRunner>
-CompositorWorkerScheduler::DefaultTaskRunner() {
+scoped_refptr<TaskQueue> CompositorWorkerScheduler::DefaultTaskRunner() {
   // TODO(sad): Implement a more robust scheduler that can do idle tasks for GC
   // without regressing performance of the rest of the system.
-  return thread_->task_runner();
+  return make_scoped_refptr(
+      new CompositorWorkerTaskRunnerWrapper(thread_->task_runner()));
 }
 
 scoped_refptr<scheduler::SingleThreadIdleTaskRunner>