Remove ParamStorageTraits::wrap and move unwrap to global scope (3/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
@@ skipping 97 matching lines @@
 enum FunctionThreadAffinity {
     CrossThreadAffinity,
     SameThreadAffinity
 };
 
 template <typename T>
 class PassedWrapper final {
 public:
     explicit PassedWrapper(T&& scoper) : m_scoper(std::move(scoper)) { }
     PassedWrapper(PassedWrapper&& other) : m_scoper(std::move(other.m_scoper)) { }
-    T moveOut() { return std::move(m_scoper); }
+    T moveOut() const { return std::move(m_scoper); }
 
 private:
-    T m_scoper;
+    mutable T m_scoper;
 };
 
 template <typename T>
 PassedWrapper<T> passed(T&& value)
 {
     static_assert(!std::is_reference<T>::value,
         "You must pass an rvalue to passed() so it can be moved. Add std::move() if necessary.");
     static_assert(!std::is_const<T>::value, "|value| must not be const so it can be moved.");
     return PassedWrapper<T>(std::move(value));
 }
@@ skipping 79 matching lines @@
 private:
     R(C::*m_function)(Parameters...);
 };
 
 template <typename T>
 struct ParamStorageTraits {
     typedef T StorageType;
 
     static_assert(!std::is_pointer<T>::value, "Raw pointer is not allowed to bind into WTF::Function. Wrap it with either Persistent, WeakPersistent, CrossThreadPersistent, CrossThreadWeakPersistent, RefPtr or unretained.");
     static_assert(!IsSubclassOfTemplate<T, blink::Member>::value, "Member is not allowed to bind into WTF::Function. Wrap it with either Persistent, WeakPersistent, CrossThreadPersistent or CrossThreadWeakPersistenst.");
-
-    static StorageType wrap(const T& value) { return value; } // Copy.
-    static StorageType wrap(T&& value) { return std::move(value); }
-
-    // Don't move out, because the functor may be called multiple times.
-    static const T& unwrap(const StorageType& value) { return value; }
 };
 
 template <typename T>
 struct ParamStorageTraits<PassRefPtr<T>> {
     typedef RefPtr<T> StorageType;
-
-    static StorageType wrap(PassRefPtr<T> value) { return value; }
-    static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template <typename T>
 struct ParamStorageTraits<RefPtr<T>> {
     typedef RefPtr<T> StorageType;
+};
 
-    static StorageType wrap(RefPtr<T> value) { return value.release(); }
-    static T* unwrap(const StorageType& value) { return value.get(); }
-};
+template <typename T>
+T* Unwrap(const RefPtr<T>& wrapped)
+{
+    return wrapped.get();
+}
 
 template <typename> class RetainPtr;
 
 template <typename T>
 struct ParamStorageTraits<RetainPtr<T>> {
     typedef RetainPtr<T> StorageType;
-
-    static StorageType wrap(const RetainPtr<T>& value) { return value; }
-    static typename RetainPtr<T>::PtrType unwrap(const StorageType& value) { return value.get(); }
 };
 
 template <typename T>
 struct ParamStorageTraits<PassedWrapper<T>> {
     typedef PassedWrapper<T> StorageType;
+};
 
-    static StorageType wrap(PassedWrapper<T>&& value) { return std::move(value); }
-    static T unwrap(StorageType& value) { return value.moveOut(); }
-};
+template <typename T>
+T Unwrap(const PassedWrapper<T>& wrapped)

[Yuta Kitamura, 2016/06/24 12:21:09]

Is the "const&" the part of API requirement of Unwrap?

This Unwrap() does mutate the argument, so if it's possible
to make the argument non-const lvalue reference, that'd be
better.

[tzik, 2016/06/24 13:04:20]

Yes, it's going to be required.
This will be used by base::Callback once we rewrite WTF::bind on top of
base::Bind, and base::Callback will pass the value of internal storage by
const-ref when it's invoked in multi-call mode.

+{
+    return wrapped.moveOut();
+}
 
 template <typename T, FunctionThreadAffinity threadAffinity>
 struct ParamStorageTraits<UnretainedWrapper<T, threadAffinity>> {
     typedef UnretainedWrapper<T, threadAffinity> StorageType;
+};
 
-    static StorageType wrap(const UnretainedWrapper<T, threadAffinity>& value) { return value; }
-    static T* unwrap(const StorageType& value) { return value.value(); }
-};
+template <typename T, FunctionThreadAffinity threadAffinity>
+T* Unwrap(const UnretainedWrapper<T, threadAffinity>& wrapped)
+{
+    return wrapped.value();
+}
+
 
 template<typename, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
 class Function;
 
 template<FunctionThreadAffinity threadAffinity, typename R, typename... Args>
 class Function<R(Args...), threadAffinity> {
     USING_FAST_MALLOC(Function);
     WTF_MAKE_NONCOPYABLE(Function);
 public:
     virtual ~Function() { }
@@ skipping 44 matching lines @@
     // 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))...)
+        , 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.
-        return m_functionWrapper(ParamStorageTraits<typename std::decay<BoundParameters>::type>::unwrap(std::get<boundIndices>(m_bound))..., std::forward<IncomingUnboundParameters>(unbound)...);
+        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;
 };
 
 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
@@ skipping 22 matching lines @@
 
 using WTF::passed;
 using WTF::unretained;
 using WTF::crossThreadUnretained;
 
 using WTF::Function;
 using WTF::SameThreadClosure;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h