Remove WebTaskRunner::Task

WebTaskRunner::Task is replaced by WTF::Closure/CrossThreadClosure,
and no longer used in the production.

Review-Url: https://codereview.chromium.org/2568063003
Cr-Commit-Position: refs/heads/master@{#437992}

third_party/WebKit/Source/platform/WebTaskRunner.h

@@ -60,22 +60,6 @@ class BLINK_PLATFORM_EXPORT WebTaskRunner {
  public:
   virtual ~WebTaskRunner() {}
 
-  class BLINK_PLATFORM_EXPORT Task {
-   public:
-    virtual ~Task() {}
-    virtual void run() = 0;
-  };
-
-  // Schedule a task to be run on the the associated WebThread.
-  // Takes ownership of |Task|. Can be called from any thread.
-  virtual void postTask(const WebTraceLocation&, Task*) = 0;
-
-  // Schedule a task to be run after |delayMs| on the the associated WebThread.
-  // Takes ownership of |Task|. Can be called from any thread.
-  virtual void postDelayedTask(const WebTraceLocation&,
-                               Task*,
-                               double delayMs) = 0;
-
   // Schedule a task to be run after |delayMs| on the the associated WebThread.
   // Can be called from any thread.
   virtual void postDelayedTask(const WebTraceLocation&,

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

@@ -19,24 +19,6 @@ WebTaskRunnerImpl::WebTaskRunnerImpl(scoped_refptr<TaskQueue> task_queue)
 
 WebTaskRunnerImpl::~WebTaskRunnerImpl() {}
 
-void WebTaskRunnerImpl::postTask(const blink::WebTraceLocation& location,
-                                 blink::WebTaskRunner::Task* task) {
-  task_queue_->PostTask(location,
-                        base::Bind(&WebTaskRunnerImpl::runTask,
-                                   base::Passed(base::WrapUnique(task))));
-}
-
-void WebTaskRunnerImpl::postDelayedTask(const blink::WebTraceLocation& location,
-                                        blink::WebTaskRunner::Task* task,
-                                        double delayMs) {
-  DCHECK_GE(delayMs, 0.0) << location.function_name() << " "
-                          << location.file_name();
-  task_queue_->PostDelayedTask(location,
-                               base::Bind(&WebTaskRunnerImpl::runTask,
-                                          base::Passed(base::WrapUnique(task))),
-                               base::TimeDelta::FromMillisecondsD(delayMs));
-}
-
 void WebTaskRunnerImpl::postDelayedTask(const WebTraceLocation& location,
                                         const base::Closure& task,
                                         double delayMs) {
@@ -76,10 +58,5 @@ base::SingleThreadTaskRunner* WebTaskRunnerImpl::toSingleThreadTaskRunner() {
   return task_queue_.get();
 }
 
-void WebTaskRunnerImpl::runTask(
-    std::unique_ptr<blink::WebTaskRunner::Task> task) {
-  task->run();
-}
-
 }  // namespace scheduler
 }  // namespace blink

third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.h

@@ -24,11 +24,6 @@ class BLINK_PLATFORM_EXPORT WebTaskRunnerImpl : public WebTaskRunner {
   ~WebTaskRunnerImpl() override;
 
   // WebTaskRunner implementation:
-  void postTask(const WebTraceLocation& web_location,
-                WebTaskRunner::Task* task) override;
-  void postDelayedTask(const WebTraceLocation& web_location,
-                       WebTaskRunner::Task* task,
-                       double delayMs) override;
   void postDelayedTask(const WebTraceLocation&,
                        const base::Closure&,
                        double delayMs) override;
@@ -38,14 +33,6 @@ class BLINK_PLATFORM_EXPORT WebTaskRunnerImpl : public WebTaskRunner {
   std::unique_ptr<WebTaskRunner> clone() override;
   base::SingleThreadTaskRunner* toSingleThreadTaskRunner() override;
 
-  // WebTaskRunner::Task should be wrapped by base::Passed() when
-  // used with base::Bind(). See https://crbug.com/551356.
-  // runTask() is a helper to call WebTaskRunner::Task::run from
-  // std::unique_ptr<WebTaskRunner::Task>.
-  // runTask() is placed here because std::unique_ptr<> cannot be used from
-  // Blink.
-  static void runTask(std::unique_ptr<WebTaskRunner::Task>);
-
  private:
   base::TimeTicks Now() const;
 

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

@@ -22,17 +22,8 @@ namespace blink {
 namespace scheduler {
 namespace {
 
-class NopTask : public blink::WebTaskRunner::Task {
+class MockTask {
  public:
-  ~NopTask() override {}
-
-  void run() override {}
-};
-
-class MockTask : public blink::WebTaskRunner::Task {
- public:
-  ~MockTask() override {}
-
   MOCK_METHOD0(run, void());
 };
 
@@ -57,17 +48,9 @@ class TestObserver : public blink::WebThread::TaskObserver {
   std::string* calls_;  // NOT OWNED
 };
 
-class TestTask : public blink::WebTaskRunner::Task {
- public:
-  explicit TestTask(std::string* calls) : calls_(calls) {}
-
-  ~TestTask() override {}
-
-  void run() override { calls_->append(" run"); }
-
- private:
-  std::string* calls_;  // NOT OWNED
-};
+void runTestTask(std::string* calls) {
+  calls->append(" run");
+}
 
 void addTaskObserver(WebThreadImplForWorkerScheduler* thread,
                      TestObserver* observer) {
@@ -123,33 +106,35 @@ class WebThreadImplForWorkerSchedulerTest : public testing::Test {
 };
 
 TEST_F(WebThreadImplForWorkerSchedulerTest, TestDefaultTask) {
-  std::unique_ptr<MockTask> task(new MockTask());
+  MockTask task;
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
 
-  EXPECT_CALL(*task, run());
-  ON_CALL(*task, run())
-      .WillByDefault(Invoke([&completion]() { completion.Signal(); }));
+  EXPECT_CALL(task, run());
+  ON_CALL(task, run()).WillByDefault(Invoke([&completion]() {
+    completion.Signal();
+  }));
 
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task.release());
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task)));
   completion.Wait();
 }
 
 TEST_F(WebThreadImplForWorkerSchedulerTest,
        TestTaskExecutedBeforeThreadDeletion) {
-  std::unique_ptr<MockTask> task(new MockTask());
+  MockTask task;
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
 
-  EXPECT_CALL(*task, run());
-  ON_CALL(*task, run())
-      .WillByDefault(Invoke([&completion]() { completion.Signal(); }));
+  EXPECT_CALL(task, run());
+  ON_CALL(task, run()).WillByDefault(Invoke([&completion]() {
+    completion.Signal();
+  }));
 
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task.release());
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task)));
   thread_.reset();
 }
 
@@ -163,10 +148,10 @@ TEST_F(WebThreadImplForWorkerSchedulerTest, TestIdleTask) {
   ON_CALL(*task, run(_))
       .WillByDefault(Invoke([&completion](double) { completion.Signal(); }));
 
-  thread_->postIdleTask(blink::WebTraceLocation(), task.release());
+  thread_->postIdleTask(BLINK_FROM_HERE, task.release());
   // We need to post a wakeup task or idle work will never happen.
-  thread_->getWebTaskRunner()->postDelayedTask(blink::WebTraceLocation(),
-                                               new NopTask(), 50ll);
+  thread_->getWebTaskRunner()->postDelayedTask(BLINK_FROM_HERE,
+                                               WTF::bind([] {}), 50ll);
 
   completion.Wait();
 }
@@ -177,8 +162,8 @@ TEST_F(WebThreadImplForWorkerSchedulerTest, TestTaskObserver) {
 
   RunOnWorkerThread(FROM_HERE,
                     base::Bind(&addTaskObserver, thread_.get(), &observer));
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        new TestTask(&calls));
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&runTestTask, WTF::unretained(&calls)));
   RunOnWorkerThread(FROM_HERE,
                     base::Bind(&removeTaskObserver, thread_.get(), &observer));
 
@@ -191,17 +176,18 @@ TEST_F(WebThreadImplForWorkerSchedulerTest, TestTaskObserver) {
 }
 
 TEST_F(WebThreadImplForWorkerSchedulerTest, TestShutdown) {
-  std::unique_ptr<MockTask> task(new MockTask());
-  std::unique_ptr<MockTask> delayed_task(new MockTask());
+  MockTask task;
+  MockTask delayed_task;
 
-  EXPECT_CALL(*task, run()).Times(0);
-  EXPECT_CALL(*delayed_task, run()).Times(0);
+  EXPECT_CALL(task, run()).Times(0);
+  EXPECT_CALL(delayed_task, run()).Times(0);
 
   RunOnWorkerThread(FROM_HERE, base::Bind(&shutdownOnThread, thread_.get()));
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task.release());
-  thread_->getWebTaskRunner()->postDelayedTask(blink::WebTraceLocation(),
-                                               task.release(), 50ll);
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task)));
+  thread_->getWebTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&MockTask::run, WTF::unretained(&delayed_task)), 50ll);
   thread_.reset();
 }
 

third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl_unittest.cc

@@ -57,23 +57,21 @@ class WebFrameSchedulerImplTest : public testing::Test {
 };
 
 namespace {
-class RepeatingTask : public blink::WebTaskRunner::Task {
- public:
-  RepeatingTask(blink::WebTaskRunner* web_task_runner, int* run_count)
-      : web_task_runner_(web_task_runner), run_count_(run_count) {}
 
-  ~RepeatingTask() override {}
+void runRepeatingTask(WebTaskRunner* task_runner, int* run_count);
 
-  void run() override {
-    (*run_count_)++;
-    web_task_runner_->postDelayedTask(
-        BLINK_FROM_HERE, new RepeatingTask(web_task_runner_, run_count_), 1.0);
-  }
+std::unique_ptr<WTF::Closure> makeRepeatingTask(
+    blink::WebTaskRunner* task_runner,
+    int* run_count) {
+  return WTF::bind(&runRepeatingTask, WTF::unretained(task_runner),
+                   WTF::unretained(run_count));
+}
 
- private:
-  blink::WebTaskRunner* web_task_runner_;  // NOT OWNED
-  int* run_count_;                         // NOT OWNED
-};
+void runRepeatingTask(WebTaskRunner* task_runner, int* run_count) {
+  ++*run_count;
+  task_runner->postDelayedTask(BLINK_FROM_HERE,
+                               makeRepeatingTask(task_runner, run_count), 1.0);
+}
 
 void IncrementCounter(int* counter) {
   ++*counter;
@@ -87,7 +85,7 @@ TEST_F(WebFrameSchedulerImplTest, RepeatingTimer_PageInForeground) {
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -101,7 +99,7 @@ TEST_F(WebFrameSchedulerImplTest, RepeatingTimer_PageInBackground) {
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -115,7 +113,7 @@ TEST_F(WebFrameSchedulerImplTest, RepeatingTimer_FrameHidden_SameOrigin) {
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -130,7 +128,7 @@ TEST_F(WebFrameSchedulerImplTest, RepeatingTimer_FrameVisible_CrossOrigin) {
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -145,7 +143,7 @@ TEST_F(WebFrameSchedulerImplTest, RepeatingTimer_FrameHidden_CrossOrigin) {
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -159,7 +157,7 @@ TEST_F(WebFrameSchedulerImplTest, PageInBackground_ThrottlingDisabled) {
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -174,7 +172,7 @@ TEST_F(WebFrameSchedulerImplTest, RepeatingTimer_FrameHidden_CrossOrigin_Throttl
   int run_count = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));

third_party/WebKit/Source/platform/scheduler/renderer/webthread_impl_for_renderer_scheduler_unittest.cc

@@ -26,7 +26,7 @@ namespace {
 
 const int kWorkBatchSize = 2;
 
-class MockTask : public blink::WebTaskRunner::Task {
+class MockTask {
  public:
   MOCK_METHOD0(run, void());
 };
@@ -73,17 +73,17 @@ class WebThreadImplForRendererSchedulerTest : public testing::Test {
 TEST_F(WebThreadImplForRendererSchedulerTest, TestTaskObserver) {
   MockTaskObserver observer;
   thread_->addTaskObserver(&observer);
-  std::unique_ptr<MockTask> task(new MockTask());
+  MockTask task;
 
   {
     testing::InSequence sequence;
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task, run());
+    EXPECT_CALL(task, run());
     EXPECT_CALL(observer, didProcessTask());
   }
 
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task.release());
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task)));
   base::RunLoop().RunUntilIdle();
   thread_->removeTaskObserver(&observer);
 }
@@ -91,18 +91,18 @@ TEST_F(WebThreadImplForRendererSchedulerTest, TestTaskObserver) {
 TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithOneTask) {
   MockTaskObserver observer;
   thread_->addTaskObserver(&observer);
-  std::unique_ptr<MockTask> task(new MockTask());
+  MockTask task;
 
   SetWorkBatchSizeForTesting(kWorkBatchSize);
   {
     testing::InSequence sequence;
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task, run());
+    EXPECT_CALL(task, run());
     EXPECT_CALL(observer, didProcessTask());
   }
 
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task.release());
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task)));
   base::RunLoop().RunUntilIdle();
   thread_->removeTaskObserver(&observer);
 }
@@ -110,25 +110,25 @@ TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithOneTask) {
 TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithTwoTasks) {
   MockTaskObserver observer;
   thread_->addTaskObserver(&observer);
-  std::unique_ptr<MockTask> task1(new MockTask());
-  std::unique_ptr<MockTask> task2(new MockTask());
+  MockTask task1;
+  MockTask task2;
 
   SetWorkBatchSizeForTesting(kWorkBatchSize);
   {
     testing::InSequence sequence;
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task1, run());
+    EXPECT_CALL(task1, run());
     EXPECT_CALL(observer, didProcessTask());
 
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task2, run());
+    EXPECT_CALL(task2, run());
     EXPECT_CALL(observer, didProcessTask());
   }
 
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task1.release());
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task2.release());
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task1)));
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task2)));
   base::RunLoop().RunUntilIdle();
   thread_->removeTaskObserver(&observer);
 }
@@ -136,52 +136,43 @@ TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithTwoTasks) {
 TEST_F(WebThreadImplForRendererSchedulerTest, TestWorkBatchWithThreeTasks) {
   MockTaskObserver observer;
   thread_->addTaskObserver(&observer);
-  std::unique_ptr<MockTask> task1(new MockTask());
-  std::unique_ptr<MockTask> task2(new MockTask());
-  std::unique_ptr<MockTask> task3(new MockTask());
+  MockTask task1;
+  MockTask task2;
+  MockTask task3;
 
   SetWorkBatchSizeForTesting(kWorkBatchSize);
   {
     testing::InSequence sequence;
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task1, run());
+    EXPECT_CALL(task1, run());
     EXPECT_CALL(observer, didProcessTask());
 
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task2, run());
+    EXPECT_CALL(task2, run());
     EXPECT_CALL(observer, didProcessTask());
 
     EXPECT_CALL(observer, willProcessTask());
-    EXPECT_CALL(*task3, run());
+    EXPECT_CALL(task3, run());
     EXPECT_CALL(observer, didProcessTask());
   }
 
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task1.release());
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task2.release());
-  thread_->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                        task3.release());
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task1)));
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task2)));
+  thread_->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE, WTF::bind(&MockTask::run, WTF::unretained(&task3)));
   base::RunLoop().RunUntilIdle();
   thread_->removeTaskObserver(&observer);
 }
 
-class ExitRunLoopTask : public blink::WebTaskRunner::Task {
- public:
-  ExitRunLoopTask(base::RunLoop* run_loop) : run_loop_(run_loop) {}
-
-  void run() override { run_loop_->Quit(); }
-
- private:
-  base::RunLoop* run_loop_;
-};
-
 void EnterRunLoop(base::MessageLoop* message_loop, blink::WebThread* thread) {
   // Note: WebThreads do not support nested run loops, which is why we use a
   // run loop directly.
   base::RunLoop run_loop;
-  thread->getWebTaskRunner()->postTask(blink::WebTraceLocation(),
-                                       new ExitRunLoopTask(&run_loop));
+  thread->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&base::RunLoop::Quit, WTF::unretained(&run_loop)));
   message_loop->SetNestableTasksAllowed(true);
   run_loop.Run();
 }

third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc

@@ -68,17 +68,6 @@ void FakeWebTaskRunner::setTime(double new_time) {
   data_->time_ = new_time;
 }
 
-void FakeWebTaskRunner::postTask(const WebTraceLocation&, Task*) {
-  NOTREACHED();
-}
-
-void FakeWebTaskRunner::postDelayedTask(const WebTraceLocation&,
-                                        Task* task,
-                                        double) {
-  data_->task_queue_.push_back(
-      base::Bind(&WebTaskRunner::Task::run, base::Owned(task)));
-}
-
 void FakeWebTaskRunner::postDelayedTask(const WebTraceLocation&,
                                         const base::Closure& closure,
                                         double) {

third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.h

@@ -25,8 +25,6 @@ class FakeWebTaskRunner : public WebTaskRunner {
   void setTime(double new_time);
 
   // WebTaskRunner implementation:
-  void postTask(const WebTraceLocation&, Task*) override;
-  void postDelayedTask(const WebTraceLocation&, Task*, double) override;
   void postDelayedTask(const WebTraceLocation&,
                        const base::Closure&,
                        double) override;

third_party/WebKit/Source/platform/testing/TestingPlatformSupport.h

@@ -108,9 +108,6 @@ class TestingPlatformMockScheduler : public WebScheduler {
   void resumeTimerQueue() override {}
   void addPendingNavigation(WebScheduler::NavigatingFrameType) override {}
   void removePendingNavigation(WebScheduler::NavigatingFrameType) override {}
-
- private:
-  WTF::Deque<std::unique_ptr<WebTaskRunner::Task>> m_tasks;
 };
 
 class TestingPlatformSupport : public Platform {