Add WTF::makeCancellable

third_party/WebKit/Source/wtf/MakeCancellable.h

Index: third_party/WebKit/Source/wtf/MakeCancellable.h
diff --git a/third_party/WebKit/Source/wtf/MakeCancellable.h b/third_party/WebKit/Source/wtf/MakeCancellable.h
new file mode 100644
index 0000000000000000000000000000000000000000..b298e7eaaa6e537198496caf09de5ff76da8f0ca
--- /dev/null
+++ b/third_party/WebKit/Source/wtf/MakeCancellable.h
@@ -0,0 +1,109 @@
+// 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 WTF_EXPORT FunctionCanceller : public RefCounted<FunctionCanceller> {
+public:
+    virtual void cancel() = 0;
+
+protected:
+    FunctionCanceller();
+    virtual ~FunctionCanceller();
+    friend RefCounted<FunctionCanceller>;
+
+    DISALLOW_COPY_AND_ASSIGN(FunctionCanceller);
+};
+
+class WTF_EXPORT ScopedFunctionCanceller {

[Yuta Kitamura, 2016/07/29 05:58:28]

A brief comment about the usage of this class would
be nice. The semantics of detach and cancel might not
be too obvious from its name.

When I first saw cancel(), I wasn't sure whether
cancel() cancels the function or cancels the
functionality of the canceller object. A small example
would definitely help resolving such a misunderstanding.

[tzik, 2016/07/29 13:47:11]

Done.

+public:
+    ScopedFunctionCanceller();
+    explicit ScopedFunctionCanceller(PassRefPtr<FunctionCanceller>);
+
+    ScopedFunctionCanceller(ScopedFunctionCanceller&&);
+    ScopedFunctionCanceller& operator=(ScopedFunctionCanceller&&);
+    ScopedFunctionCanceller(const ScopedFunctionCanceller&) = delete;
+    ScopedFunctionCanceller& operator=(const ScopedFunctionCanceller&) = delete;
+
+    ~ScopedFunctionCanceller();
+    void detach();
+    void cancel();
+
+private:
+    RefPtr<FunctionCanceller> m_canceller;
+};
+
+namespace internal {
+
+template <typename... Params>
+class FunctionCancellerImpl final : public FunctionCanceller {
+public:
+    FunctionCancellerImpl(std::unique_ptr<Function<void(Params...)>> function)
+        : m_function(std::move(function))
+    {
+        DCHECK(m_function);
+    }
+
+    void runUnlessCancelled(const ScopedFunctionCanceller&, 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
+
+// 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
+// if the FunctionCanceller::cancel() is not called.
+//
+// Example:
+//   void foo() {}
+//   std::unique_ptr<Function<void()>> function = WTF::bind(&foo);
+//
+//   std::unique_ptr<Function<void()>> wrappedFunction;
+//   RefPtr<FunctionCanceller> canceller;
+//   std::tie(wrappedFunction, canceller) = makeCancellable(std::move(function));
+//
+//   (*wrappedFunction)();  // Not cancelled. foo() is called.
+//   canceller->cancel();
+//   (*wrappedFunction)();  // Cancelled. foo() is not called.
+//
+template <typename... Params>
+std::tuple<std::unique_ptr<Function<void(Params...)>>, PassRefPtr<FunctionCanceller>>
+makeCancellable(std::unique_ptr<Function<void(Params...)>> function)
+{
+    using Canceller = internal::FunctionCancellerImpl<Params...>;
+    RefPtr<Canceller> canceller = adoptRef(new Canceller(std::move(function)));
+    // Keep a ScopedFunctionCanceller instance in |wrappedFunction|, so that the
+    // destruction of |wrappedFunction| implies the destruction of |function|.
+    std::unique_ptr<Function<void(Params...)>> wrappedFunction = bind(&Canceller::runUnlessCancelled, canceller, ScopedFunctionCanceller(canceller));

[Yuta Kitamura, 2016/07/29 00:57:42]

I'm still unsure about the merit of cancelling on the
destruction of a wrapped function.

I think my doubt boils down to the following question:
is cancelling observable from the user? After the
wrapped function is destructed, the user can no longer
call the function, thus the user won't be able to
observe the effect of cancel anyway.

Is there anything I have missed?

[tzik, 2016/07/29 05:25:40]

My concern is that, without the auto destruction, makeCancellable unnecessarily
extends the lifetime of the inner function. That may even make a circular
reference in an example below. And it's also for the behavior parity to
WorkerEventQueue::EventDispatcherTask and others, which we are going to replace
with makeCancellable.

struct Foo : GarbageCollectedFinalized<Foo> {
  FunctionCanceller m_canceller;
  void bar();
};

Foo* foo = new Foo();
Closure f = bind(&Foo::bar, wrapPersistent(foo));
Closure g;
std::tie(g, foo->m_canceller) = makeCancellable(std::move(f));
g = nullptr;

On the example above, if we don't destroy |f| on the destruction of |g|, they
form a circular strong reference of
foo -> m_canceller -> m_function -> foo, and that causes a memory leak.

[Yuta Kitamura, 2016/07/29 05:58:28]

OK, that makes sense.

Maybe you could add some more comments for future
readers? The current comment is not clear about the
intention of forced cancelling.

[tzik, 2016/07/29 13:47:11]

Done.

+    return std::make_tuple(std::move(wrappedFunction), canceller.release());
+}
+
+} // namespace WTF
+
+#endif // WTF_MakeCancellable_h