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/web_view_scheduler_impl_unittest.cc

@@ -79,23 +79,22 @@ TEST_F(WebViewSchedulerImplTest, TestDestructionOfFrameSchedulersAfter) {
 }
 
 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(blink::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));
+}
+
+void runRepeatingTask(blink::WebTaskRunner* task_runner, int* run_count) {
+  ++*run_count;
+  task_runner->postDelayedTask(BLINK_FROM_HERE,
+                               makeRepeatingTask(task_runner, run_count), 1.0);
+}
 
- private:
-  blink::WebTaskRunner* web_task_runner_;  // NOT OWNED
-  int* run_count_;                         // NOT OWNED
-};
 }  // namespace
 
 TEST_F(WebViewSchedulerImplTest, RepeatingTimer_PageInForeground) {
@@ -104,7 +103,7 @@ TEST_F(WebViewSchedulerImplTest, 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));
@@ -117,7 +116,7 @@ TEST_F(WebViewSchedulerImplTest, 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));
@@ -130,7 +129,7 @@ TEST_F(WebViewSchedulerImplTest, RepeatingLoadingTask_PageInBackground) {
   int run_count = 0;
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->loadingTaskRunner(), &run_count),
+      makeRepeatingTask(web_frame_scheduler_->loadingTaskRunner(), &run_count),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -150,11 +149,11 @@ TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) {
   int run_count2 = 0;
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1),
+      makeRepeatingTask(web_frame_scheduler_->timerTaskRunner(), &run_count1),
       1.0);
   web_frame_scheduler2->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new RepeatingTask(web_frame_scheduler2->timerTaskRunner(), &run_count2),
+      makeRepeatingTask(web_frame_scheduler2->timerTaskRunner(), &run_count2),
       1.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(1));
@@ -163,31 +162,26 @@ TEST_F(WebViewSchedulerImplTest, RepeatingTimers_OneBackgroundOneForeground) {
 }
 
 namespace {
-class VirtualTimeRecorderTask : public blink::WebTaskRunner::Task {
- public:
-  VirtualTimeRecorderTask(base::SimpleTestTickClock* clock,
-                          blink::WebTaskRunner* web_task_runner,
-                          std::vector<base::TimeTicks>* out_real_times,
-                          std::vector<size_t>* out_virtual_times_ms)
-      : clock_(clock),
-        web_task_runner_(web_task_runner),
-        out_real_times_(out_real_times),
-        out_virtual_times_ms_(out_virtual_times_ms) {}
-
-  ~VirtualTimeRecorderTask() override {}
-
-  void run() override {
-    out_real_times_->push_back(clock_->NowTicks());
-    out_virtual_times_ms_->push_back(
-        web_task_runner_->monotonicallyIncreasingVirtualTimeSeconds() * 1000.0);
-  }
 
- private:
-  base::SimpleTestTickClock* clock_;              // NOT OWNED
-  blink::WebTaskRunner* web_task_runner_;         // NOT OWNED
-  std::vector<base::TimeTicks>* out_real_times_;  // NOT OWNED
-  std::vector<size_t>* out_virtual_times_ms_;     // NOT OWNED
-};
+void runVirtualTimeRecorderTask(base::SimpleTestTickClock* clock,
+                                blink::WebTaskRunner* web_task_runner,
+                                std::vector<base::TimeTicks>* out_real_times,
+                                std::vector<size_t>* out_virtual_times_ms) {
+  out_real_times->push_back(clock->NowTicks());
+  out_virtual_times_ms->push_back(
+      web_task_runner->monotonicallyIncreasingVirtualTimeSeconds() * 1000.0);
+}
+
+std::unique_ptr<WTF::Closure> makeVirtualTimeRecorderTask(
+    base::SimpleTestTickClock* clock,
+    blink::WebTaskRunner* web_task_runner,
+    std::vector<base::TimeTicks>* out_real_times,
+    std::vector<size_t>* out_virtual_times_ms) {
+  return WTF::bind(&runVirtualTimeRecorderTask, WTF::unretained(clock),
+                   WTF::unretained(web_task_runner),
+                   WTF::unretained(out_real_times),
+                   WTF::unretained(out_virtual_times_ms));
+}
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTime_TimerFastForwarding) {
@@ -203,21 +197,21 @@ TEST_F(WebViewSchedulerImplTest, VirtualTime_TimerFastForwarding) {
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(clock_.get(),
+      makeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->timerTaskRunner(),
                                   &real_times, &virtual_times_ms),
       2.0);
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(clock_.get(),
+      makeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->timerTaskRunner(),
                                   &real_times, &virtual_times_ms),
       20.0);
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(clock_.get(),
+      makeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->timerTaskRunner(),
                                   &real_times, &virtual_times_ms),
       200.0);
@@ -244,21 +238,21 @@ TEST_F(WebViewSchedulerImplTest, VirtualTime_LoadingTaskFastForwarding) {
 
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(clock_.get(),
+      makeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->loadingTaskRunner(),
                                   &real_times, &virtual_times_ms),
       2.0);
 
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(clock_.get(),
+      makeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->loadingTaskRunner(),
                                   &real_times, &virtual_times_ms),
       20.0);
 
   web_frame_scheduler_->loadingTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new VirtualTimeRecorderTask(clock_.get(),
+      makeVirtualTimeRecorderTask(clock_.get(),
                                   web_frame_scheduler_->loadingTaskRunner(),
                                   &real_times, &virtual_times_ms),
       200.0);
@@ -281,7 +275,7 @@ TEST_F(WebViewSchedulerImplTest,
   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_->RunTasksWhile(mock_task_runner_->TaskRunCountBelow(2000));
@@ -294,42 +288,19 @@ TEST_F(WebViewSchedulerImplTest,
 }
 
 namespace {
-class RunOrderTask : public blink::WebTaskRunner::Task {
- public:
-  RunOrderTask(int index, std::vector<int>* out_run_order)
-      : index_(index), out_run_order_(out_run_order) {}
-
-  ~RunOrderTask() override {}
-
-  void run() override { out_run_order_->push_back(index_); }
-
- private:
-  int index_;
-  std::vector<int>* out_run_order_;  // NOT OWNED
-};
 
-class DelayedRunOrderTask : public blink::WebTaskRunner::Task {
- public:
-  DelayedRunOrderTask(int index,
-                      blink::WebTaskRunner* task_runner,
-                      std::vector<int>* out_run_order)
-      : index_(index),
-        task_runner_(task_runner),
-        out_run_order_(out_run_order) {}
-
-  ~DelayedRunOrderTask() override {}
-
-  void run() override {
-    out_run_order_->push_back(index_);
-    task_runner_->postTask(BLINK_FROM_HERE,
-                           new RunOrderTask(index_ + 1, out_run_order_));
-  }
+void runOrderTask(int index, std::vector<int>* out_run_order) {
+  out_run_order->push_back(index);
+}
 
- private:
-  int index_;
-  blink::WebTaskRunner* task_runner_;  // NOT OWNED
-  std::vector<int>* out_run_order_;    // NOT OWNED
-};
+void delayedRunOrderTask(int index,
+                         blink::WebTaskRunner* task_runner,
+                         std::vector<int>* out_run_order) {
+  out_run_order->push_back(index);
+  task_runner->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&runOrderTask, index + 1, WTF::unretained(out_run_order)));
+}
 }
 
 TEST_F(WebViewSchedulerImplTest, VirtualTime_NotAllowedToAdvance) {
@@ -339,18 +310,21 @@ TEST_F(WebViewSchedulerImplTest, VirtualTime_NotAllowedToAdvance) {
   web_view_scheduler_->enableVirtualTime();
 
   web_frame_scheduler_->timerTaskRunner()->postTask(
-      BLINK_FROM_HERE, new RunOrderTask(0, &run_order));
+      BLINK_FROM_HERE,
+      WTF::bind(&runOrderTask, 0, WTF::unretained(&run_order)));
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(),
-                              &run_order),
+      WTF::bind(&delayedRunOrderTask, 1,
+                WTF::unretained(web_frame_scheduler_->timerTaskRunner()),
+                WTF::unretained(&run_order)),
       2.0);
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new DelayedRunOrderTask(3, web_frame_scheduler_->timerTaskRunner(),
-                              &run_order),
+      WTF::bind(&delayedRunOrderTask, 3,
+                WTF::unretained(web_frame_scheduler_->timerTaskRunner()),
+                WTF::unretained(&run_order)),
       4.0);
 
   mock_task_runner_->RunUntilIdle();
@@ -366,18 +340,21 @@ TEST_F(WebViewSchedulerImplTest, VirtualTime_AllowedToAdvance) {
   web_view_scheduler_->enableVirtualTime();
 
   web_frame_scheduler_->timerTaskRunner()->postTask(
-      BLINK_FROM_HERE, new RunOrderTask(0, &run_order));
+      BLINK_FROM_HERE,
+      WTF::bind(&runOrderTask, 0, WTF::unretained(&run_order)));
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new DelayedRunOrderTask(1, web_frame_scheduler_->timerTaskRunner(),
-                              &run_order),
+      WTF::bind(&delayedRunOrderTask, 1,
+                WTF::unretained(web_frame_scheduler_->timerTaskRunner()),
+                WTF::unretained(&run_order)),
       2.0);
 
   web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
       BLINK_FROM_HERE,
-      new DelayedRunOrderTask(3, web_frame_scheduler_->timerTaskRunner(),
-                              &run_order),
+      WTF::bind(&delayedRunOrderTask, 3,
+                WTF::unretained(web_frame_scheduler_->timerTaskRunner()),
+                WTF::unretained(&run_order)),
       4.0);
 
   mock_task_runner_->RunUntilIdle();
@@ -401,7 +378,7 @@ TEST_F(WebViewSchedulerImplTestWithDisabledBackgroundTimerThrottling,
   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));
@@ -418,7 +395,8 @@ TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) {
       web_view_scheduler_->createWebFrameSchedulerImpl(nullptr);
 
   web_frame_scheduler->timerTaskRunner()->postDelayedTask(
-      BLINK_FROM_HERE, new RunOrderTask(1, &run_order), 0.1);
+      BLINK_FROM_HERE, WTF::bind(&runOrderTask, 1, WTF::unretained(&run_order)),
+      1);
 
   mock_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
@@ -430,72 +408,47 @@ TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) {
 }
 
 namespace {
-class DeleteWebFrameSchedulerTask : public blink::WebTaskRunner::Task {
- public:
-  explicit DeleteWebFrameSchedulerTask(WebViewSchedulerImpl* web_view_scheduler)
-      : web_frame_scheduler_(
-            web_view_scheduler->createWebFrameSchedulerImpl(nullptr)) {}
-
-  ~DeleteWebFrameSchedulerTask() override {}
-
-  void run() override { web_frame_scheduler_.reset(); }
-
-  WebFrameSchedulerImpl* web_frame_scheduler() const {
-    return web_frame_scheduler_.get();
-  }
-
- private:
-  std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler_;
-};
-
-class DeleteWebViewSchedulerTask : public blink::WebTaskRunner::Task {
- public:
-  explicit DeleteWebViewSchedulerTask(WebViewSchedulerImpl* web_view_scheduler)
-      : web_view_scheduler_(web_view_scheduler) {}
-
-  ~DeleteWebViewSchedulerTask() override {}
 
-  void run() override { web_view_scheduler_.reset(); }
+template <typename T>
+std::unique_ptr<WTF::Closure> makeDeletionTask(T* obj) {
+  return WTF::bind([](T* obj) { delete obj; }, WTF::unretained(obj));
+}
 
- private:
-  std::unique_ptr<WebViewSchedulerImpl> web_view_scheduler_;
-};
 }  // namespace
 
 TEST_F(WebViewSchedulerImplTest, DeleteWebFrameSchedulers_InTask) {
   for (int i = 0; i < 10; i++) {
-    DeleteWebFrameSchedulerTask* task =
-        new DeleteWebFrameSchedulerTask(web_view_scheduler_.get());
-    task->web_frame_scheduler()->timerTaskRunner()->postDelayedTask(
-        BLINK_FROM_HERE, task, 1.0);
+    WebFrameSchedulerImpl* web_frame_scheduler =
+        web_view_scheduler_->createWebFrameSchedulerImpl(nullptr).release();
+    web_frame_scheduler->timerTaskRunner()->postDelayedTask(
+        BLINK_FROM_HERE, makeDeletionTask(web_frame_scheduler), 1);
   }
   mock_task_runner_->RunUntilIdle();
 }
 
 TEST_F(WebViewSchedulerImplTest, DeleteWebViewScheduler_InTask) {
   web_frame_scheduler_->timerTaskRunner()->postTask(
-      BLINK_FROM_HERE,
-      new DeleteWebViewSchedulerTask(web_view_scheduler_.release()));
+      BLINK_FROM_HERE, makeDeletionTask(web_view_scheduler_.release()));
   mock_task_runner_->RunUntilIdle();
 }
 
 TEST_F(WebViewSchedulerImplTest, DeleteThrottledQueue_InTask) {
   web_view_scheduler_->setPageVisible(false);
 
-  DeleteWebFrameSchedulerTask* delete_frame_task =
-      new DeleteWebFrameSchedulerTask(web_view_scheduler_.get());
+  WebFrameSchedulerImpl* web_frame_scheduler =
+      web_view_scheduler_->createWebFrameSchedulerImpl(nullptr).release();
   blink::WebTaskRunner* timer_task_runner =
-      delete_frame_task->web_frame_scheduler()->timerTaskRunner();
+      web_frame_scheduler->timerTaskRunner();
 
   int run_count = 0;
   timer_task_runner->postDelayedTask(
-      BLINK_FROM_HERE, new RepeatingTask(timer_task_runner, &run_count), 1.0);
+      BLINK_FROM_HERE, makeRepeatingTask(timer_task_runner, &run_count), 1.0);
 
   // Note this will run at time t = 10s since we start at time t = 5000us, and
   // it will prevent further tasks from running (i.e. the RepeatingTask) by
   // deleting the WebFrameScheduler.
-  timer_task_runner->postDelayedTask(BLINK_FROM_HERE, delete_frame_task,
-                                     9990.0);
+  timer_task_runner->postDelayedTask(
+      BLINK_FROM_HERE, makeDeletionTask(web_frame_scheduler), 9990.0);
 
   mock_task_runner_->RunForPeriod(base::TimeDelta::FromSeconds(100));
   EXPECT_EQ(10, run_count);

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 {