Add WebTaskRunner::postCancellableTask

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

Index: third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc b/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
index 36536c6d40370178f54fe69b0c0cd8a57d6a43f3..dfafdb58b089369d5c8ad3b9916612578ac64acf 100644
--- a/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
+++ b/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
@@ -4,7 +4,11 @@
 
 #include "platform/scheduler/test/fake_web_task_runner.h"
 
+#include <deque>
+
+#include "base/callback.h"
 #include "base/logging.h"
+#include "base/single_thread_task_runner.h"
 #include "wtf/RefCounted.h"
 
 namespace blink {
@@ -14,8 +18,8 @@ class FakeWebTaskRunner::Data : public WTF::ThreadSafeRefCounted<Data> {
  public:
   Data() : time_(0.0) {}
 
-  std::unique_ptr<Task> task_;
-  base::Closure closure_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  std::deque<base::Closure> task_queue_;
   double time_;
 
  private:
@@ -25,11 +29,37 @@ class FakeWebTaskRunner::Data : public WTF::ThreadSafeRefCounted<Data> {
   DISALLOW_COPY_AND_ASSIGN(Data);
 };
 
-FakeWebTaskRunner::FakeWebTaskRunner() : data_(adoptRef(new Data)) {}
+class FakeWebTaskRunner::BaseTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  explicit BaseTaskRunner(PassRefPtr<Data> data) : data_(std::move(data)) {}
+
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override {
+    data_->task_queue_.push_back(task);
+    return true;
+  }
 
-FakeWebTaskRunner::FakeWebTaskRunner(PassRefPtr<Data> data)
-    : data_(std::move(data)) {
-}
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const base::Closure& task,
+                                  base::TimeDelta delay) override {
+    data_->task_queue_.push_back(task);
+    return true;
+  }
+
+  bool RunsTasksOnCurrentThread() const { return true; }
+
+ private:
+  RefPtr<Data> data_;
+};
+
+FakeWebTaskRunner::FakeWebTaskRunner()
+    : data_(adoptRef(new Data)), base_task_runner_(new BaseTaskRunner(data_)) {}
+
+FakeWebTaskRunner::FakeWebTaskRunner(
+    PassRefPtr<Data> data,
+    scoped_refptr<BaseTaskRunner> base_task_runner)
+    : data_(std::move(data)), base_task_runner_(std::move(base_task_runner)) {}
 
 FakeWebTaskRunner::~FakeWebTaskRunner() {
 }
@@ -45,13 +75,14 @@ void FakeWebTaskRunner::postTask(const WebTraceLocation&, Task*) {
 void FakeWebTaskRunner::postDelayedTask(const WebTraceLocation&,
                                         Task* task,
                                         double) {
-  data_->task_.reset(task);
+  data_->task_queue_.push_back(
+      base::Bind(&WebTaskRunner::Task::run, base::Owned(task)));
 }
 
 void FakeWebTaskRunner::postDelayedTask(const WebTraceLocation&,
                                         const base::Closure& closure,
                                         double) {
-  data_->closure_ = closure;
+  data_->task_queue_.push_back(closure);
 }
 
 bool FakeWebTaskRunner::runsTasksOnCurrentThread() {
@@ -59,7 +90,7 @@ bool FakeWebTaskRunner::runsTasksOnCurrentThread() {
 }
 
 std::unique_ptr<WebTaskRunner> FakeWebTaskRunner::clone() {
-  return WTF::wrapUnique(new FakeWebTaskRunner(data_));
+  return WTF::wrapUnique(new FakeWebTaskRunner(data_, base_task_runner_));
 }
 
 double FakeWebTaskRunner::virtualTimeSeconds() const {
@@ -71,8 +102,13 @@ double FakeWebTaskRunner::monotonicallyIncreasingVirtualTimeSeconds() const {
 }
 
 SingleThreadTaskRunner* FakeWebTaskRunner::toSingleThreadTaskRunner() {
-  NOTREACHED();
-  return nullptr;
+  return base_task_runner_.get();
+}
+
+void FakeWebTaskRunner::runUntilIdle() {
+  std::deque<base::Closure> task_queue = std::move(data_->task_queue_);

[haraken, 2016/10/19 15:20:39]

Why do we need std::move?

[dcheng, 2016/10/19 22:21:47]

I believe this is because it's possible that executing a task in the task queue
will mutate the fake web task runner, so we pull everything out first.

(Probably worth commenting on this)

[tzik, 2016/10/20 16:15:12]

Added a comment, and fixed a behavior as well.
The previous implementation didn't run tasks that posted in runUntilIdle.

+  for (auto& task : task_queue)
+    task.Run();
 }
 
 }  // namespace scheduler