Make WTF::Function be a base::Callback wrapper (5/5)

third_party/WebKit/Source/wtf/Functional.h

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_Functional_h
 #define WTF_Functional_h
 
 #include "base/bind.h"
+#include "base/threading/thread_checker.h"
 #include "base/tuple.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/TypeTraits.h"
 #include "wtf/WeakPtr.h"
 #include <tuple>
@@ skipping 108 matching lines @@
     return UnretainedWrapper<T, SameThreadAffinity>(value);
 }
 
 template <typename T>
 UnretainedWrapper<T, CrossThreadAffinity> crossThreadUnretained(T* value)
 {
     static_assert(!WTF::IsGarbageCollectedType<T>::value, "crossThreadUnretained() + GCed type is forbidden");
     return UnretainedWrapper<T, CrossThreadAffinity>(value);
 }
 
-// A FunctionWrapper is a class template that can wrap a function pointer or a member function pointer and
-// provide a unified interface for calling that function.
-template <typename>
-class FunctionWrapper;
-
-// Bound static functions:
-template <typename R, typename... Parameters>
-class FunctionWrapper<R(*)(Parameters...)> {
-    DISALLOW_NEW();
-public:
-    typedef R ResultType;
-    static const size_t numberOfArguments = sizeof...(Parameters);
-
-    explicit FunctionWrapper(R(*function)(Parameters...))
-        : m_function(function)
-    {
-    }
-
-    template <typename... IncomingParameters>
-    R operator()(IncomingParameters&&... parameters)
-    {
-        return m_function(std::forward<IncomingParameters>(parameters)...);
-    }
-
-private:
-    R(*m_function)(Parameters...);
-};
-
-// Bound member functions:
-
-template <typename R, typename C, typename... Parameters>
-class FunctionWrapper<R(C::*)(Parameters...)> {
-    DISALLOW_NEW();
-public:
-    typedef R ResultType;
-    // + 1 is for |this| as an argument.
-    static const size_t numberOfArguments = sizeof...(Parameters) + 1;
-
-    explicit FunctionWrapper(R(C::*function)(Parameters...))
-        : m_function(function)
-    {
-    }
-
-    template <typename Receiver, typename... IncomingParameters>
-    R operator()(Receiver&& receiver, IncomingParameters&&... parameters)
-    {
-        if (base::IsWeakReceiver<typename std::decay<Receiver>::type>::value && !receiver) {
-            return R();
-        }
-
-        C& c = *receiver;
-        return (c.*m_function)(std::forward<IncomingParameters>(parameters)...);
-    }
-
-private:
-    R(C::*m_function)(Parameters...);
-};
-
 template <typename T>
 struct ParamStorageTraits {
     typedef T StorageType;
 
     static_assert(!std::is_pointer<T>::value, "Raw pointers are not allowed to bind into WTF::Function. Wrap it with either wrapPersistent, wrapWeakPersistent, wrapCrossThreadPersistent, wrapCrossThreadWeakPersistent, RefPtr or unretained.");
     static_assert(!IsSubclassOfTemplate<T, blink::Member>::value && !IsSubclassOfTemplate<T, blink::WeakMember>::value, "Member and WeakMember are not allowed to bind into WTF::Function. Wrap it with either wrapPersistent, wrapWeakPersistent, wrapCrossThreadPersistent or wrapCrossThreadWeakPersistent.");
 };
 
 template <typename T>
 struct ParamStorageTraits<PassRefPtr<T>> {
@@ skipping 33 matching lines @@
 struct ParamStorageTraits<UnretainedWrapper<T, threadAffinity>> {
     typedef UnretainedWrapper<T, threadAffinity> StorageType;
 };
 
 template <typename T, FunctionThreadAffinity threadAffinity>
 T* Unwrap(const UnretainedWrapper<T, threadAffinity>& wrapped)
 {
     return wrapped.value();
 }
 
-
-template<typename, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
+template<typename Signature, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
 class Function;
 
-template<FunctionThreadAffinity threadAffinity, typename R, typename... Args>
+template<typename R, typename... Args, FunctionThreadAffinity threadAffinity>
 class Function<R(Args...), threadAffinity> {
     USING_FAST_MALLOC(Function);
     WTF_MAKE_NONCOPYABLE(Function);
 public:
-    virtual ~Function() { }
-    virtual R operator()(Args... args) = 0;
-protected:
-    Function() = default;
-    void checkThread() { }
-};
+    Function(base::Callback<R(Args...)> callback)
+        : m_callback(std::move(callback)) { }
 
-#if ENABLE(ASSERT)
-template<typename R, typename... Args>
-class Function<R(Args...), SameThreadAffinity> {
-    USING_FAST_MALLOC(Function);
-    WTF_MAKE_NONCOPYABLE(Function);
-public:
-    virtual ~Function()
+    ~Function()
     {
-        checkThread();
-    }
-    virtual R operator()(Args... args) = 0;
-protected:
-    Function()
-        : m_createdThread(currentThread())
-    {
+        DCHECK(m_threadChecker.CalledOnValidThread());
     }
 
-    void NEVER_INLINE checkThread()
+    R operator()(Args... args)
     {
-        // Function with SameThreadAffinity, including SameThreadClosure
-        // created by WTF::bind() or blink::createSameThreadTask(),
-        // must be called and destructed on the thread where it is created.
-        // If it is intended to be used cross-thread, use
-        // blink::threadSafeBind() or blink::createCrossThreadTask() instead.
-        RELEASE_ASSERT(m_createdThread == currentThread());
+        DCHECK(m_threadChecker.CalledOnValidThread());
+        return m_callback.Run(std::forward<Args>(args)...);
     }
 
 private:
-    const ThreadIdentifier m_createdThread;
-};
-#endif
-
-template <FunctionThreadAffinity threadAffinity, typename BoundParametersTuple, typename FunctionWrapper, typename UnboundRunType>
-class PartBoundFunctionImpl;
-
-template <FunctionThreadAffinity threadAffinity, typename... BoundParameters, typename FunctionWrapper, typename ResultType, typename... UnboundParameters>
-class PartBoundFunctionImpl<threadAffinity, std::tuple<BoundParameters...>, FunctionWrapper, ResultType(UnboundParameters...)> final : public Function<ResultType(UnboundParameters...), threadAffinity> {
-public:
-    // We would like to use StorageTraits<UnboundParameters>... with StorageTraits defined as below in order to obtain
-    // storage traits of UnboundParameters, but unfortunately MSVC can't handle template using declarations correctly.
-    // So, sadly, we have write down the full type signature in all places where storage traits are needed.
-    //
-    // template <typename T>
-    // using StorageTraits = ParamStorageTraits<typename std::decay<T>::type>;
-
-    // Note that BoundParameters can be const T&, T&& or a mix of these.
-    explicit PartBoundFunctionImpl(FunctionWrapper functionWrapper, BoundParameters... bound)
-        : m_functionWrapper(functionWrapper)
-        , m_bound(std::forward<BoundParameters>(bound)...)
-    {
-    }
-
-    ResultType operator()(UnboundParameters... unbound) override
-    {
-        // What we really want to do is to call m_functionWrapper(m_bound..., unbound...), but to do that we need to
-        // pass a list of indices to a worker function template.
-        return callInternal(base::MakeIndexSequence<sizeof...(BoundParameters)>(), std::forward<UnboundParameters>(unbound)...);
-    }
-
-private:
-    template <std::size_t... boundIndices, typename... IncomingUnboundParameters>
-    ResultType callInternal(const base::IndexSequence<boundIndices...>&, IncomingUnboundParameters&&... unbound)
-    {
-        this->checkThread();
-        // Get each element in m_bound, unwrap them, and call the function with the desired arguments.
-        using base::internal::Unwrap;
-        return m_functionWrapper(Unwrap(std::get<boundIndices>(m_bound))..., std::forward<IncomingUnboundParameters>(unbound)...);
-    }
-
-    FunctionWrapper m_functionWrapper;
-    std::tuple<typename ParamStorageTraits<typename std::decay<BoundParameters>::type>::StorageType...> m_bound;
+    using MaybeThreadChecker = typename std::conditional<
+        threadAffinity == SameThreadAffinity,
+        base::ThreadChecker,
+        base::ThreadCheckerDoNothing>::type;
+    MaybeThreadChecker m_threadChecker;
+    base::Callback<R(Args...)> m_callback;
 };
 
 template <FunctionThreadAffinity threadAffinity, typename FunctionType, typename... BoundParameters>
 std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, threadAffinity>> bindInternal(FunctionType function, BoundParameters&&... boundParameters)
 {
     // Bound parameters' types are wrapped with std::tuple so we can pass two template parameter packs (bound
     // parameters and unbound) to PartBoundFunctionImpl. Note that a tuple of this type isn't actually created;
     // std::tuple<> is just for carrying the bound parameters' types. Any other class template taking a type parameter
     // pack can be used instead of std::tuple. std::tuple is used just because it's most convenient for this purpose.
     using UnboundRunType = base::MakeUnboundRunType<FunctionType, BoundParameters...>;
-    using BoundFunctionType = PartBoundFunctionImpl<threadAffinity, std::tuple<BoundParameters&&...>, FunctionWrapper<FunctionType>, UnboundRunType>;
-    return wrapUnique(new BoundFunctionType(FunctionWrapper<FunctionType>(function), std::forward<BoundParameters>(boundParameters)...));
+    return wrapUnique(new Function<UnboundRunType, threadAffinity>(base::Bind(function, typename ParamStorageTraits<typename std::decay<BoundParameters>::type>::StorageType(std::forward<BoundParameters>(boundParameters))...)));

[Yuta Kitamura, 2016/06/27 06:46:36]

This line makes my brain cause a traffic jam... Let me confirm
my understanding. Are these true or false?

1. The former "wrap()" is now replaced with a constructor call
   of StorageType.
2. The former "unwrap()" is replaced with Unwrap(), which is
   dealt by base::Bind().

[tzik, 2016/06/27 06:53:43]

Agree. It's too long to look at a glance...
1. Yes, wrap is replaced with the constructor call. Ideally, we should add
another traits to specify the storage type to base::Bind and should get rid of
the constructor call...
2. Yes, exactly.

 }
 
-
-
 template <typename FunctionType, typename... BoundParameters>
 std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, SameThreadAffinity>> bind(FunctionType function, BoundParameters&&... boundParameters)
 {
     return bindInternal<SameThreadAffinity>(function, std::forward<BoundParameters>(boundParameters)...);
 }
 
 typedef Function<void(), SameThreadAffinity> SameThreadClosure;
 typedef Function<void(), CrossThreadAffinity> CrossThreadClosure;
 
 } // namespace WTF
 
 using WTF::bind;
 
 using WTF::passed;
 using WTF::unretained;
 using WTF::crossThreadUnretained;
 
 using WTF::Function;
 using WTF::SameThreadClosure;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h