Reland of WTF::bind: Handle movable objects in unbound arguments.

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 27 matching lines @@
 #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.
 //
 // Use threadSafeBind() or createCrossThreadTask() if the function/task is
 // called on a (potentially) different thread from the current thread.
 
-// Bind and rvalue references:
+// WTF::bind() and move semantics
+// ==============================
 //
-// For unbound parameters (arguments supplied later on the bound functor), we don't support moving-in and moving-out
-// at this moment, but we are willing to support that soon.
+// 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) { ... }
+//            OwnPtr<Function<void(Argument&&)>> functor = bind<Argument&&>(yourFunction);
+//
+//     2) Pass by value.
+//
+//            void yourFunction(Argument argument) { ... }
+//            OwnPtr<Function<void(Argument)>> functor = bind<Argument>(yourFunction);
+//
+// Note that with the latter there will be *two* move constructions happening, because there needs to be at least one
+// intermediary function call taking an argument of type "Argument" (i.e. passed by value). The former case does not
+// require any move constructions inbetween.
 //
 // For bound parameters (arguments supplied on the creation of a functor), you can move your argument into the internal
 // storage of the functor by supplying an rvalue to that argument (this is done in wrap() of ParamStorageTraits).
 // However, to make the functor be able to get called multiple times, the stored object does not get moved out
 // automatically when the underlying function is actually invoked. If you want to move the argument throughout the
 // process, you can do so by receiving the argument as a non-const lvalue reference and applying std::move() to it:
 //
 //     void yourFunction(Argument& argument)
 //     {
 //         std::move(argument); // Move out the argument from the internal storage.
@@ skipping 145 matching lines @@
     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(unbound..., base::MakeIndexSequence<sizeof...(BoundParameters)>());
+        return callInternal(base::MakeIndexSequence<sizeof...(BoundParameters)>(), std::forward<UnboundParameters>(unbound)...);
     }
 
 private:
-    template <std::size_t... boundIndices>
-    typename FunctionWrapper::ResultType callInternal(UnboundParameters... unbound, const base::IndexSequence<boundIndices...>&)
+    template <std::size_t... boundIndices, typename... IncomingUnboundParameters>
+        typename FunctionWrapper::ResultType callInternal(const base::IndexSequence<boundIndices...>&, IncomingUnboundParameters&&... unbound)
     {
         // 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))..., unbound...);
+        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)
 {
     // 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...>;
     return adoptPtr(new BoundFunctionType(FunctionWrapper<FunctionType>(function), std::forward<BoundParameters>(boundParameters)...));
 }
 
 typedef Function<void()> Closure;
 
 } // namespace WTF
 
 using WTF::Function;
 using WTF::bind;
 using WTF::Closure;
 
 #endif // WTF_Functional_h