Use WTF::WeakPtr in WTF::makeCancellable

third_party/WebKit/Source/wtf/MakeCancellable.h

 // Copyright 2016 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 WTF_MakeCancellable_h
 #define WTF_MakeCancellable_h
 
 #include "base/logging.h"
 #include "wtf/Functional.h"
 #include "wtf/RefCounted.h"
@@ skipping 17 matching lines @@
     friend RefCounted<FunctionCanceller>;
 
     DISALLOW_COPY_AND_ASSIGN(FunctionCanceller);
 };
 
 template <typename... Params>
 class FunctionCancellerImpl final : public FunctionCanceller {
 public:
     FunctionCancellerImpl(std::unique_ptr<Function<void(Params...)>> function)
         : m_function(std::move(function))
+        , m_weakPtrFactory(this)
     {
         DCHECK(m_function);
     }
 
-    void runUnlessCancelled(const ScopedFunctionCanceller&, Params... params)
+    void run(const ScopedFunctionCanceller&, Params... params)
     {
-        if (m_function)
-            (*m_function)(std::forward<Params>(params)...);
+        DCHECK(m_function);
+        (*m_function)(std::forward<Params>(params)...);
+    }
+
+    WeakPtr<FunctionCancellerImpl> createWeakPtr()
+    {
+        return m_weakPtrFactory.createWeakPtr();
     }
 
     void cancel() override
     {
+        m_weakPtrFactory.revokeAll();
         m_function = nullptr;
     }
 
     bool isActive() const override
     {
         return !!m_function;
     }
 
 private:
     ~FunctionCancellerImpl() override = default;
 
     std::unique_ptr<WTF::Function<void(Params...)>> m_function;
+    WeakPtrFactory<FunctionCancellerImpl<Params...>> m_weakPtrFactory;
 
     DISALLOW_COPY_AND_ASSIGN(FunctionCancellerImpl);
 };
 
 } // namespace internal
 
 // ScopedFunctionCanceller is a handle associated to a Function, and cancels the
 // invocation of the Function on the scope out or cancel() call.
 // Example:
 //   void Foo() {}
@@ skipping 84 matching lines @@
     //   };
     //
     //   Foo* foo = new Foo;
     //   auto result = makeCancellable(bind(&Foo::bar, wrapPersistent(foo)));
     //
     //   // Destruction of the resulting Function implies the destruction of
     //   // the original function via ScopedFunctionCanceller below, that
     //   // resolves a circular strong reference:
     //   //   foo -> m_canceller -> m_function -> foo
     //   result.function = nullptr;
-    auto wrappedFunction = bind(&Canceller::runUnlessCancelled, canceller, ScopedFunctionCanceller(canceller));
+    auto wrappedFunction = bind(&Canceller::run, canceller->createWeakPtr(), ScopedFunctionCanceller(canceller));
     return MakeCancellableResult<Params...>(ScopedFunctionCanceller(canceller.release()), std::move(wrappedFunction));
 }
 
 } // namespace WTF
 
 #endif // WTF_MakeCancellable_h