[blink] Add PostCancellableTask overloads for non-nested tasks

This is motivated by incremental marking tasks, which are non-nested and
required to be cancelable.

Bug: 1002998
Change-Id: Ie02b1ee71a3289eb69a4fcebb5bd9edbc1fae9d8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1876927
Commit-Queue: Anton Bikineev <bikineev@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709001}

third_party/blink/renderer/platform/scheduler/common/post_cancellable_task.cc

@@ -143,4 +143,33 @@ TaskHandle PostDelayedCancellableTask(base::SequencedTaskRunner& task_runner,
   return TaskHandle(runner);
 }
 
+TaskHandle PostNonNestableCancellableTask(
+    base::SequencedTaskRunner& task_runner,
+    const base::Location& location,
+    base::OnceClosure task) {
+  DCHECK(task_runner.RunsTasksInCurrentSequence());
+  scoped_refptr<TaskHandle::Runner> runner =
+      base::AdoptRef(new TaskHandle::Runner(std::move(task)));
+  task_runner.PostNonNestableTask(
+      location, WTF::Bind(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
+                          TaskHandle(runner)));
+  return TaskHandle(runner);
+}
+
+TaskHandle PostNonNestableDelayedCancellableTask(
+    base::SequencedTaskRunner& task_runner,
+    const base::Location& location,
+    base::OnceClosure task,
+    base::TimeDelta delay) {
+  DCHECK(task_runner.RunsTasksInCurrentSequence());
+  scoped_refptr<TaskHandle::Runner> runner =
+      base::AdoptRef(new TaskHandle::Runner(std::move(task)));
+  task_runner.PostNonNestableDelayedTask(
+      location,
+      WTF::Bind(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
+                TaskHandle(runner)),
+      delay);
+  return TaskHandle(runner);
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/scheduler/common/post_cancellable_task_unittest.cc

@@ -66,6 +66,25 @@ TEST(WebTaskRunnerTest, PostCancellableTaskTest) {
   EXPECT_EQ(1, count);
   EXPECT_FALSE(handle.IsActive());
 
+  count = 0;
+  handle = PostNonNestableCancellableTask(
+      *task_runner, FROM_HERE, WTF::Bind(&Increment, WTF::Unretained(&count)));
+  EXPECT_EQ(0, count);
+  EXPECT_TRUE(handle.IsActive());
+  task_runner->RunUntilIdle();
+  EXPECT_EQ(1, count);
+  EXPECT_FALSE(handle.IsActive());
+
+  count = 0;
+  handle = PostNonNestableDelayedCancellableTask(
+      *task_runner, FROM_HERE, WTF::Bind(&Increment, WTF::Unretained(&count)),
+      base::TimeDelta::FromMilliseconds(1));
+  EXPECT_EQ(0, count);
+  EXPECT_TRUE(handle.IsActive());
+  task_runner->RunUntilIdle();
+  EXPECT_EQ(1, count);
+  EXPECT_FALSE(handle.IsActive());
+
   // Cancel a task.
   count = 0;
   handle = PostCancellableTask(*task_runner, FROM_HERE,
@@ -76,6 +95,35 @@ TEST(WebTaskRunnerTest, PostCancellableTaskTest) {
   task_runner->RunUntilIdle();
   EXPECT_EQ(0, count);
 
+  count = 0;
+  handle = PostDelayedCancellableTask(
+      *task_runner, FROM_HERE, WTF::Bind(&Increment, WTF::Unretained(&count)),
+      base::TimeDelta::FromMilliseconds(1));
+  handle.Cancel();
+  EXPECT_EQ(0, count);
+  EXPECT_FALSE(handle.IsActive());
+  task_runner->RunUntilIdle();
+  EXPECT_EQ(0, count);
+
+  count = 0;
+  handle = PostNonNestableCancellableTask(
+      *task_runner, FROM_HERE, WTF::Bind(&Increment, WTF::Unretained(&count)));
+  handle.Cancel();
+  EXPECT_EQ(0, count);
+  EXPECT_FALSE(handle.IsActive());
+  task_runner->RunUntilIdle();
+  EXPECT_EQ(0, count);
+
+  count = 0;
+  handle = PostNonNestableDelayedCancellableTask(
+      *task_runner, FROM_HERE, WTF::Bind(&Increment, WTF::Unretained(&count)),
+      base::TimeDelta::FromMilliseconds(1));
+  handle.Cancel();
+  EXPECT_EQ(0, count);
+  EXPECT_FALSE(handle.IsActive());
+  task_runner->RunUntilIdle();
+  EXPECT_EQ(0, count);
+
   // The task should be cancelled when the handle is dropped.
   {
     count = 0;

third_party/blink/renderer/platform/scheduler/public/post_cancellable_task.h

@@ -56,6 +56,15 @@ class PLATFORM_EXPORT TaskHandle {
                              const base::Location&,
                              base::OnceClosure,
                              base::TimeDelta delay) WARN_UNUSED_RESULT;
+  friend PLATFORM_EXPORT TaskHandle
+  PostNonNestableCancellableTask(base::SequencedTaskRunner&,
+                                 const base::Location&,
+                                 base::OnceClosure) WARN_UNUSED_RESULT;
+  friend PLATFORM_EXPORT TaskHandle PostNonNestableDelayedCancellableTask(
+      base::SequencedTaskRunner&,
+      const base::Location&,
+      base::OnceClosure,
+      base::TimeDelta delay) WARN_UNUSED_RESULT;
 
   explicit TaskHandle(scoped_refptr<Runner>);
   scoped_refptr<Runner> runner_;
@@ -72,6 +81,15 @@ PostDelayedCancellableTask(base::SequencedTaskRunner&,
                            const base::Location&,
                            base::OnceClosure,
                            base::TimeDelta delay) WARN_UNUSED_RESULT;
+PLATFORM_EXPORT TaskHandle
+PostNonNestableCancellableTask(base::SequencedTaskRunner&,
+                               const base::Location&,
+                               base::OnceClosure) WARN_UNUSED_RESULT;
+PLATFORM_EXPORT TaskHandle
+PostNonNestableDelayedCancellableTask(base::SequencedTaskRunner&,
+                                      const base::Location&,
+                                      base::OnceClosure,
+                                      base::TimeDelta delay) WARN_UNUSED_RESULT;
 
 }  // namespace blink