Add WebTaskRunner::postCancellableTask

third_party/WebKit/public/platform/WebTaskRunner.h

 // 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.
 
 #ifndef WebTaskRunner_h
 #define WebTaskRunner_h
 
 #include "WebCommon.h"
 #include "base/callback_forward.h"
 #include "public/platform/WebTraceLocation.h"
 #include <memory>
 
 #ifdef INSIDE_BLINK
 #include "wtf/Functional.h"
+#include "wtf/RefCounted.h"
+#include "wtf/WeakPtr.h"
 #endif
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace blink {
 
 using SingleThreadTaskRunner = base::SingleThreadTaskRunner;
 
+#ifdef INSIDE_BLINK
+
+class BLINK_PLATFORM_EXPORT TaskHandle
+    : public WTF::ThreadSafeRefCounted<TaskHandle> {
+ public:
+  // Returns true if the task will run later. Returns false if the task is
+  // cancelled or the task is ran already.
+  // This function is not thread safe. Call this on the thread that the task

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

the thread that has posted the task

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

Done.

+  // is posted to.
+  bool isActive() const;
+
+  // Cancels the task invocation. Do nothing if the task is cancelled or ran
+  // already.
+  // This function is not thread safe. Call this on the thread that the task

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

Ditto.

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

Done.

+  // is posted to.
+  void cancel();
+
+  ~TaskHandle();

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

Add a comment and mention that the task is not cancelled on the TaskHandle's
destruction.

[alex clarke (OOO till 29th), 2016/10/19 15:36:46]

Are you sure? :)  Looks to me like the destructor of |m_weakPtrFactory| cancels
the tasks.

[tzik, 2016/10/19 20:46:47]

Since the task has a ref to TaskHandle, TaskHandle outlives the task.

+
+ private:
+  class ClearOnScopeOut;
+  friend class WebTaskRunner;
+
+  explicit TaskHandle(std::unique_ptr<WTF::Closure> task);
+  void run(const ClearOnScopeOut&);
+  WTF::WeakPtr<TaskHandle> asWeakPtr();
+
+  std::unique_ptr<WTF::Closure> m_task;
+  WTF::WeakPtrFactory<TaskHandle> m_weakPtrFactory;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskHandle);
+};
+
+#endif
+
 // The blink representation of a chromium SingleThreadTaskRunner.
 class BLINK_PLATFORM_EXPORT WebTaskRunner {
  public:
   virtual ~WebTaskRunner() {}
 
   class BLINK_PLATFORM_EXPORT Task {
    public:
     virtual ~Task() {}
     virtual void run() = 0;
   };
@@ skipping 50 matching lines @@
   void postTask(const WebTraceLocation&, std::unique_ptr<CrossThreadClosure>);
   void postDelayedTask(const WebTraceLocation&,
                        std::unique_ptr<CrossThreadClosure>,
                        long long delayMs);
 
   // For same-thread posting. Must be called from the associated WebThread.
   void postTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
   void postDelayedTask(const WebTraceLocation&,
                        std::unique_ptr<WTF::Closure>,
                        long long delayMs);
+
+  // For same-thread cancellable task posting. Returns a TaskHandle object for
+  // cancellation.
+  // This is a replacement of CancellableTaskFactory and oneshot WTF::Timer.
+  // Example: For |task_runner| and |foo| below.

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

Instead of adding this comment, shall we add a deprecation comment on
CancellableTaskFactory?

+  //   WebTaskRunner* task_runner;
+  //   Foo* foo;
+  //
+  //   CancellableTaskFactory factory(foo, &Foo::bar);
+  //   task_runner->postTask(BLINK_FROM_HERE, factory.cancelAndCreate());
+  //   factory.cancel();
+  //
+  // Above is equivalent to below:
+  //
+  //   std::unique_ptr<WTF::Closure> task =
+  //       WTF::bind(wrapPersistent(foo), &Foo::bar);
+  //   RefPtr<TaskHandle> handle =
+  //       task_runner->postCancellableTask(BLINK_FROM_HERE, std::move(task));
+  //   handle->cancel();
+  //
+  // Note that the task is not automatically cancelled on TaskHandle scope out.
+  PassRefPtr<TaskHandle> postCancellableTask(const WebTraceLocation&,
+                                             std::unique_ptr<WTF::Closure>);
+  PassRefPtr<TaskHandle> postDelayedCancellableTask(
+      const WebTraceLocation&,
+      std::unique_ptr<WTF::Closure>,
+      long long delayMs);
 #endif
 };
 
 }  // namespace blink
 
 #endif  // WebTaskRunner_h