Add support for std::unique_ptr as this pointer in WTF::bind()

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 42 matching lines @@
 
 // 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) { ... }
-//            OwnPtr<Function<void(Argument&&)>> functor = bind<Argument&&>(yourFunction);
+//            std::unique_ptr<Function<void(Argument&&)>> functor = bind<Argument&&>(yourFunction);
 //
 //     2) Pass by value.
 //
 //            void yourFunction(Argument argument) { ... }
-//            OwnPtr<Function<void(Argument)>> functor = bind<Argument>(yourFunction);
+//            std::unique_ptr<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 make an argument "auto-passed",
 // you can do so by wrapping your bound argument with passed() function, as shown below:
 //
 //     void yourFunction(Argument argument)
 //     {
 //         // |argument| is passed from the internal storage of functor.
 //         ...
 //     }
 //
 //     ...
-//     OwnPtr<Function<void()>> functor = bind(yourFunction, passed(Argument()));
+//     std::unique_ptr<Function<void()>> functor = bind(yourFunction, passed(Argument()));
 //     ...
 //     (*functor)();
 //
 // The underlying function must receive the argument wrapped by passed() by rvalue reference or by value.
 //
 // Obviously, if you create a functor this way, you shouldn't call the functor twice or more; after the second call,
 // the passed argument may be invalid.
 
 template <typename T>
 class PassedWrapper final {
@@ skipping 61 matching lines @@
         return (c->*m_function)(std::forward<IncomingParameters>(parameters)...);
     }
 
     template <typename... IncomingParameters>
     R operator()(const PassOwnPtr<C>& c, IncomingParameters&&... parameters)
     {
         return (c.get()->*m_function)(std::forward<IncomingParameters>(parameters)...);
     }
 
     template <typename... IncomingParameters>
+    R operator()(const std::unique_ptr<C>& c, IncomingParameters&&... parameters)
+    {
+        return (c.get()->*m_function)(std::forward<IncomingParameters>(parameters)...);
+    }
+
+    template <typename... IncomingParameters>
     R operator()(const WeakPtr<C>& c, IncomingParameters&&... parameters)
     {
         C* obj = c.get();
         if (!obj)
             return R();
         return (obj->*m_function)(std::forward<IncomingParameters>(parameters)...);
     }
 
 private:
     R(C::*m_function)(Parameters...);
@@ skipping 158 matching lines @@
 
 } // namespace WTF
 
 using WTF::passed;
 using WTF::Function;
 using WTF::bind;
 using WTF::SameThreadClosure;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h