Support external task cancellation mechanisms in base::Callback::IsCancelled

third_party/WebKit/Source/platform/WebTaskRunner.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/WebTaskRunner.h"
 
+#include "base/bind_helpers.h"
 #include "base/single_thread_task_runner.h"
 
+namespace base {
+
+using RunnerMethodType =
+    void (blink::TaskHandle::Runner::*)(const blink::TaskHandle&);
+
+template <>
+struct CallbackCancellationTraits<
+    RunnerMethodType,
+    std::tuple<WTF::WeakPtr<blink::TaskHandle::Runner>, blink::TaskHandle>> {
+  static constexpr bool is_cancellable = true;
+
+  static bool IsCancelled(RunnerMethodType,
+                          const WTF::WeakPtr<blink::TaskHandle::Runner>&,
+                          const blink::TaskHandle& handle) {
+    return !handle.isActive();
+  }
+};
+
+}  // namespace base
+
 namespace blink {
 
 class TaskHandle::Runner : public WTF::ThreadSafeRefCounted<Runner> {
  public:
   explicit Runner(std::unique_ptr<WTF::Closure> task)
       : m_task(std::move(task)), m_weakPtrFactory(this) {}
 
   WTF::WeakPtr<Runner> asWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
 
-  bool isActive() { return static_cast<bool>(m_task); }
+  bool isActive() const { return m_task && !m_task->isCancelled(); }
 
   void cancel() {
     std::unique_ptr<WTF::Closure> task = std::move(m_task);
     m_weakPtrFactory.revokeAll();
   }
 
   ~Runner() { cancel(); }
 
   // The TaskHandle parameter on run() holds a reference to the Runner to keep
   // it alive while a task is pending in a task queue, and clears the reference
@@ skipping 99 matching lines @@
   DCHECK(runsTasksOnCurrentThread());
   RefPtr<TaskHandle::Runner> runner =
       adoptRef(new TaskHandle::Runner(std::move(task)));
   postDelayedTask(location, WTF::bind(&TaskHandle::Runner::run,
                                       runner->asWeakPtr(), TaskHandle(runner)),
                   delayMs);
   return TaskHandle(runner);
 }
 
 }  // namespace blink