Add thread affinity and ASSERT() for same-thread restriction to WTF::Function

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
@@ skipping 23 matching lines @@
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/WeakPtr.h"
 #include <tuple>
 #include <utility>
 
 namespace WTF {
 
 // Functional.h provides a very simple way to bind a function pointer and arguments together into a function object
 // that can be stored, copied and invoked, similar to how boost::bind and std::bind in C++11.
+
+// Thread Safety:
 //
-// Use threadSafeBind() or createCrossThreadTask() if the function/task is
-// called on a (potentially) different thread from the current thread.
+// WTF::bind() and SameThreadClosure should be used for same-thread closures
+// only, i.e. the closures must be created, executed and destructed on
+// the same thread.
+// Use threadSafeBind() and CrossThreadClosure if the function/task is called
+// or destructed on a (potentially) different thread from the current thread.
 
 // WTF::bind() and move semantics
 // ==============================
 //
 // For unbound parameters (arguments supplied later on the bound functor directly), there are two ways to pass movable
 // arguments:
 //
 //     1) Pass by rvalue reference.
 //
 //            void yourFunction(Argument&& argument) { ... }
@@ skipping 127 matching lines @@
     static typename RetainPtr<T>::PtrType unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<> struct ParamStorageTraits<void*> {
     typedef void* StorageType;
 
     static StorageType wrap(void* value) { return value; }
     static void* unwrap(const StorageType& value) { return value; }
 };
 
-template<typename>
+enum FunctionThreadAffinity {
+    CrossThreadAffinity,
+    SameThreadAffinity
+};
+
+template<typename, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
 class Function;
 
-template<typename R, typename... Args>
-class Function<R(Args...)> {
+template<FunctionThreadAffinity threadAffinity, typename R, typename... Args>
+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() { }
 };
 
-template <typename BoundParametersTuple, typename FunctionWrapper, typename... UnboundParameters>
+#if ENABLE(ASSERT)
+template<typename R, typename... Args>
+class Function<R(Args...), SameThreadAffinity> {
+    USING_FAST_MALLOC(Function);
+    WTF_MAKE_NONCOPYABLE(Function);
+public:
+    virtual ~Function()
+    {
+        checkThread();
+    }
+    virtual R operator()(Args... args) = 0;
+protected:
+    Function()
+        : m_createdThread(currentThread())
+    {
+    }
+
+    void NEVER_INLINE checkThread()
+    {
+        // 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());
+    }
+
+private:
+    const ThreadIdentifier m_createdThread;
+};
+#endif
+
+template <FunctionThreadAffinity threadAffinity, typename BoundParametersTuple, typename FunctionWrapper, typename... UnboundParameters>
 class PartBoundFunctionImpl;
 
-template <typename... BoundParameters, typename FunctionWrapper, typename... UnboundParameters>
-class PartBoundFunctionImpl<std::tuple<BoundParameters...>, FunctionWrapper, UnboundParameters...> final : public Function<typename FunctionWrapper::ResultType(UnboundParameters...)> {
+template <FunctionThreadAffinity threadAffinity, typename... BoundParameters, typename FunctionWrapper, typename... UnboundParameters>
+class PartBoundFunctionImpl<threadAffinity, std::tuple<BoundParameters...>, FunctionWrapper, UnboundParameters...> final : public Function<typename FunctionWrapper::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(ParamStorageTraits<typename std::decay<BoundParameters>::type>::wrap(std::forward<BoundParameters>(bound))...)
     {
     }
 
     typename FunctionWrapper::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>
         typename FunctionWrapper::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.
         return m_functionWrapper(ParamStorageTraits<typename std::decay<BoundParameters>::type>::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;
 };
 
-template <typename... UnboundParameters, typename FunctionType, typename... BoundParameters>
-PassOwnPtr<Function<typename FunctionWrapper<FunctionType>::ResultType(UnboundParameters...)>> bind(FunctionType function, BoundParameters&&... boundParameters)
+template <FunctionThreadAffinity threadAffinity, typename... UnboundParameters, typename FunctionType, typename... BoundParameters>
+PassOwnPtr<Function<typename FunctionWrapper<FunctionType>::ResultType(UnboundParameters...), 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 BoundFunctionType = PartBoundFunctionImpl<std::tuple<BoundParameters&&...>, FunctionWrapper<FunctionType>, UnboundParameters...>;
+    using BoundFunctionType = PartBoundFunctionImpl<threadAffinity, std::tuple<BoundParameters&&...>, FunctionWrapper<FunctionType>, UnboundParameters...>;
     return adoptPtr(new BoundFunctionType(FunctionWrapper<FunctionType>(function), std::forward<BoundParameters>(boundParameters)...));
 }
 
-typedef Function<void()> Closure;
+template <typename... UnboundParameters, typename FunctionType, typename... BoundParameters>
+PassOwnPtr<Function<typename FunctionWrapper<FunctionType>::ResultType(UnboundParameters...), SameThreadAffinity>> bind(FunctionType function, BoundParameters&&... boundParameters)
+{
+    return bindInternal<SameThreadAffinity, UnboundParameters...>(function, std::forward<BoundParameters>(boundParameters)...);
+}
+
+typedef Function<void(), SameThreadAffinity> SameThreadClosure;
+typedef Function<void(), CrossThreadAffinity> CrossThreadClosure;
 
 } // namespace WTF
 
 using WTF::Function;
 using WTF::bind;
-using WTF::Closure;
+using WTF::SameThreadClosure;
+using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h