Scheduler: Deprecate CancellableTaskFactory in favor of WebTaskRunner::postCancellableTask (3)

third_party/WebKit/Source/platform/scheduler/CancellableTaskFactory.h

Index: third_party/WebKit/Source/platform/scheduler/CancellableTaskFactory.h
diff --git a/third_party/WebKit/Source/platform/scheduler/CancellableTaskFactory.h b/third_party/WebKit/Source/platform/scheduler/CancellableTaskFactory.h
deleted file mode 100644
index 3a7d81dce4684844a4247717ba4f5abb6a964ab7..0000000000000000000000000000000000000000
--- a/third_party/WebKit/Source/platform/scheduler/CancellableTaskFactory.h
+++ /dev/null
@@ -1,100 +0,0 @@
-// 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/WebTaskRunner.h"
-#include "platform/heap/Handle.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 replace CancellableTaskFactory.
-// 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);
-//   TaskHandle handle =
-//       task_runner->postCancellableTask(BLINK_FROM_HERE, std::move(task));
-//   handle.cancel();
-namespace blink {
-
-class PLATFORM_EXPORT CancellableTaskFactory {
-  WTF_MAKE_NONCOPYABLE(CancellableTaskFactory);
-  USING_FAST_MALLOC(CancellableTaskFactory);
-
- public:
-  // As WTF::Closure objects are off-heap, we have to construct the closure in
-  // such a manner that it doesn't end up referring back to the owning heap
-  // object with a strong Persistent<> GC root reference. If we do, this will
-  // create a heap <-> off-heap cycle and leak, the owning object can never be
-  // GCed. Instead, the closure will keep an off-heap persistent reference of
-  // the weak, which will refer back to the owner heap object safely (but
-  // weakly.)
-  //
-  // DEPRECATED: Please use WebTaskRunner::postCancellableTask instead.
-  // (https://crbug.com/665285)
-  template <typename T>
-  static std::unique_ptr<CancellableTaskFactory> create(
-      T* thisObject,
-      void (T::*method)(),
-      typename std::enable_if<IsGarbageCollectedType<T>::value>::type* =
-          nullptr) {
-    return wrapUnique(new CancellableTaskFactory(
-        WTF::bind(method, wrapWeakPersistent(thisObject))));
-  }
-
-  bool isPending() const { return m_weakPtrFactory.hasWeakPtrs(); }
-
-  void cancel();
-
-  // Returns a task that can be disabled by calling cancel().  The user takes
-  // ownership of the task.  Creating a new task cancels any previous ones.
-  WebTaskRunner::Task* cancelAndCreate();
-
- protected:
-  // Only intended used by unit tests wanting to stack allocate and/or pass in a
-  // closure value. Please use the create() factory method elsewhere.
-  explicit CancellableTaskFactory(std::unique_ptr<WTF::Closure> closure)
-      : m_closure(std::move(closure)), m_weakPtrFactory(this) {}
-
- private:
-  class CancellableTask : public WebTaskRunner::Task {
-    USING_FAST_MALLOC(CancellableTask);
-    WTF_MAKE_NONCOPYABLE(CancellableTask);
-
-   public:
-    explicit CancellableTask(WeakPtr<CancellableTaskFactory> weakPtr)
-        : m_weakPtr(weakPtr) {}
-
-    ~CancellableTask() override {}
-
-    void run() override;
-
-   private:
-    WeakPtr<CancellableTaskFactory> m_weakPtr;
-  };
-
-  std::unique_ptr<WTF::Closure> m_closure;
-  WeakPtrFactory<CancellableTaskFactory> m_weakPtrFactory;
-};
-
-}  // namespace blink
-
-#endif  // CancellableTaskFactory_h