Add WebTaskRunner::postCancellableTask

third_party/WebKit/Source/platform/scheduler/CancellableTaskFactory.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 CancellableTaskFactory_h
 #define CancellableTaskFactory_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/WebTaskRunner.h"
 #include "wtf/Allocator.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/WeakPtr.h"
 #include <memory>
 #include <type_traits>
 
+// WebTaskRunner::postCancellableTask will take over CancellableTaskFactory.

[dcheng, 2016/10/21 06:14:46]

Nit: take over => replace

[tzik, 2016/10/25 07:03:52]

Done.

+// Use postCancellableTask in new code.
+// Example: For |task_runner| and |foo| below.
+//   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.

[dcheng, 2016/10/21 06:14:46]

Hmm, that's unfortunate. That means that something using postCancellableTask
that binds a WeakPersistent won't be able to take advantage of the scheduler
fast-path for cancelled callbacks.

[tzik, 2016/10/25 07:03:52]

It hopefully doesn't make big difference. I expect the users of the
postCancellableTask manually clears the TaskHandle on their destructor, and the
destructor call will be not so late after WeakPersistent invalidation.

+
 namespace blink {
 
 class TraceLocation;
 
 class PLATFORM_EXPORT CancellableTaskFactory {
   WTF_MAKE_NONCOPYABLE(CancellableTaskFactory);
   USING_FAST_MALLOC(CancellableTaskFactory);
 
  public:
   // A pair of mutually exclusive factory methods are provided for constructing
@@ skipping 60 matching lines @@
     WeakPtr<CancellableTaskFactory> m_weakPtr;
   };
 
   std::unique_ptr<WTF::Closure> m_closure;
   WeakPtrFactory<CancellableTaskFactory> m_weakPtrFactory;
 };
 
 }  // namespace blink
 
 #endif  // CancellableTaskFactory_h