Add 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"
+#include "wtf/WTFExport.h"
+#include <memory>
+
+namespace WTF {
+
+class FunctionCanceller;
+
+namespace internal {
+
+class WTF_EXPORT FunctionCancellerImplBase : public RefCounted<FunctionCancellerImplBase> {

[haraken, 2016/07/27 11:18:04]

Do we need WTF_EXPORT? It looks strange to export a class inside the internal
namespace.

[tzik, 2016/07/27 13:56:53]

Yes, we need it to expose the ctor and dtor to FunctionCancellerImpl and
makeCancellable. Since they are a template function and a class template, ctor
and dtor invocation needs to be visible from the user of these function where
the template instantiation happens.

+public:
+    virtual void cancel() = 0;
+
+protected:
+    FunctionCancellerImplBase();
+    virtual ~FunctionCancellerImplBase();
+    friend RefCounted<FunctionCancellerImplBase>;
+
+    DISALLOW_COPY_AND_ASSIGN(FunctionCancellerImplBase);
+};
+
+template <typename... Params>
+class FunctionCancellerImpl final : public FunctionCancellerImplBase {
+public:
+    FunctionCancellerImpl(std::unique_ptr<Function<void(Params...)>> function)
+        : m_function(std::move(function))
+    {
+        DCHECK(m_function);
+    }
+
+    void runUnlessCancelled(const FunctionCanceller&, Params... params)
+    {
+        if (m_function)
+            (*m_function)(std::forward<Params>(params)...);
+    }
+
+    void cancel() override
+    {
+        m_function = nullptr;
+    }
+
+private:
+    ~FunctionCancellerImpl() override = default;
+
+    std::unique_ptr<WTF::Function<void(Params...)>> m_function;
+
+    DISALLOW_COPY_AND_ASSIGN(FunctionCancellerImpl);
+};
+
+} // namespace internal
+
+class WTF_EXPORT FunctionCanceller {
+public:
+    FunctionCanceller();
+    explicit FunctionCanceller(PassRefPtr<internal::FunctionCancellerImplBase> cancellation);
+
+    FunctionCanceller(FunctionCanceller&&);
+    FunctionCanceller& operator=(FunctionCanceller&&);
+    FunctionCanceller(const FunctionCanceller&) = delete;
+    FunctionCanceller& operator=(const FunctionCanceller&) = delete;
+
+    ~FunctionCanceller();
+    void detach();
+    void cancel();
+
+private:
+    RefPtr<internal::FunctionCancellerImplBase> m_cancellation;
+};
+
+// makeCancellable wraps a WTF::Function to make cancellable function.
+// This function returns a tuple of a WTF::Function, and a FunctionCanceller.
+// An invocation of the resulting function is relayed to the original function
+// unless the FunctionCanceller is alive and its cancel() is not called.

[haraken, 2016/07/27 11:18:04]

unless => if ?

[tzik, 2016/07/27 13:56:52]

Done.

+//
+// Example:
+//   void foo() {}
+//   std::unique_ptr<Function<void()>> function = WTF::bind(&foo);
+//
+//   std::unique_ptr<Function<void()>> wrappedFunction;
+//   FunctionCanceller canceller;
+//   std::tie(wrappedFunction, canceller) = makeCancellable(std::move(function));

[haraken, 2016/07/27 11:18:04]

Instead of returning a pair of WTF::Function and FunctionCanceller, would it be
an option to return WTF::CancellableFunction? WTF::CancellableFunction should
provide cancel().

I'm not sure if it's a good idea to decouple FunctionCanceller from the function
itself because people need to be careful about the lifetime of FunctionCanceller
and the function together. Otherwise, FunctionCanceller may be unintentionally
destructed before the function, which may unintentionally prevent the function
from running.

[tzik, 2016/07/27 13:56:53]

Hmm, since the Function will be posted to a message loop as a unique_ptr, and
its ownership is passed, we'll have to lose one of the object.
If we have CancellableFunction that the user keeps for cancellation, we need
another mechanism to get a Function, which will be posted to a message loop.
I think it'll not be simpler than my proposal.

[haraken, 2016/07/27 14:05:46]

Do you mean that the following pattern is complicated?

std::unique_ptr<Function<void()>> function = WTF::bind(&foo);
CancellableFunction cancellable = makeCancellable(std::move(function));
...;
postTask(cancellable.function());
...;
cancellable.cancel();

+//
+//   (*wrappedFunction)();  // Not cancelled. foo() is called.
+//   canceller.cancel();
+//   (*wrappedFunction)();  // Cancelled. foo() is not called.
+//
+//
+//   std::tie(wrappedFunction, canceller) = makeCancellable(bind(&foo));
+//   {
+//       // FunctionCanceller is movable. |wrappedFunction| will be cancelled
+//       // by anotherCanceller.cancel() rather than canceller.cancel().
+//       FunctionCanceller anotherCanceller = std::move(canceller);
+//
+//       // Destructor of FunctionCanceller implies cancel(), unless detach() is
+//       // called.
+//   }
+//
+template <typename... Params>
+std::tuple<std::unique_ptr<Function<void(Params...)>>, FunctionCanceller>
+makeCancellable(std::unique_ptr<Function<void(Params...)>> function)
+{
+    using Impl = internal::FunctionCancellerImpl<Params...>;
+    RefPtr<Impl> impl = adoptRef(new Impl(std::move(function)));
+    // Keep a FunctionCanceller instance in the wrappedFunction itself, so that the target function
+    // is destroyed when the Function instance is destroyed.
+    std::unique_ptr<Function<void(Params...)>> wrappedFunction = bind(&Impl::runUnlessCancelled, impl, FunctionCanceller(impl));
+    return std::make_tuple(std::move(wrappedFunction), FunctionCanceller(std::move(impl)));
+}
+
+} // namespace WTF
+
+#endif // WTF_MakeCancellable_h