Readd base::UnwrapTraits to support rvalue-reference wrappers

base/bind_helpers.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
 // It also defines a set of simple functions and utilities that people want
 // when using Callback<> and Bind().
@@ skipping 156 matching lines @@
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 
 namespace base {
 
 template <typename T>
 struct IsWeakReceiver;
 
+template <typename>
+struct BindUnwrapTraits;
+
 namespace internal {
 
 template <typename T>
 class UnretainedWrapper {
  public:
   explicit UnretainedWrapper(T* o) : ptr_(o) {}
   T* get() const { return ptr_; }
  private:
   T* ptr_;
 };
@@ skipping 81 matching lines @@
     CHECK(is_valid_);
     is_valid_ = false;
     return std::move(scoper_);
   }
 
  private:
   mutable bool is_valid_;
   mutable T scoper_;
 };
 
-// Unwrap the stored parameters for the wrappers above.
 template <typename T>
-T&& Unwrap(T&& o) {
-  return std::forward<T>(o);
-}
+using Unwrapper = BindUnwrapTraits<typename std::decay<T>::type>;
 
 template <typename T>
-T* Unwrap(const UnretainedWrapper<T>& unretained) {
-  return unretained.get();
-}
-
-template <typename T>
-const T& Unwrap(const ConstRefWrapper<T>& const_ref) {
-  return const_ref.get();
-}
-
-template <typename T>
-T* Unwrap(const RetainedRefWrapper<T>& o) {
-  return o.get();
-}
-
-template <typename T>
-T* Unwrap(const OwnedWrapper<T>& o) {
-  return o.get();
-}
-
-template <typename T>
-T Unwrap(const PassedWrapper<T>& o) {
-  return o.Take();
+auto Unwrap(T&& o) -> decltype(Unwrapper<T>::Unwrap(std::forward<T>(o))) {
+  return Unwrapper<T>::Unwrap(std::forward<T>(o));

[dcheng, 2016/08/23 05:25:38]

Just curious, but can't we just invoke the template directly rather than
forwarding it through this helper?

[tzik, 2016/08/23 07:01:09]

It's possible, but it makes the caller a bit more complicated.
I.e.
  Unwrap(base::get<indices>(std::forward<BoundArgsTuple>(bound)))...
in Invoker::RunImpl will be
  BindUnwrapTraits<
      typename std::tuple_element<indices, DecayedArgsTuple>::type
  >::Unwrap(std::get<indices>(std::forward<BoundArgsTuple>(bound)))...

And, it's used in DispatchTo{Method,Function} in tuple.h, which I don't want to
touch now.

 }
 
 // IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
 // method.  It is used internally by Bind() to select the correct
 // InvokeHelper that will no-op itself in the event the WeakPtr<> for
 // the target object is invalidated.
 //
 // The first argument should be the type of the object that will be received by
 // the method.
 template <bool is_method, typename... Args>
@@ skipping 173 matching lines @@
 //   base::Bind(&Foo::bar, oo).Run();
 template <typename T>
 struct IsWeakReceiver : std::false_type {};
 
 template <typename T>
 struct IsWeakReceiver<internal::ConstRefWrapper<T>> : IsWeakReceiver<T> {};
 
 template <typename T>
 struct IsWeakReceiver<WeakPtr<T>> : std::true_type {};
 
+// An injection point to control how bound objects passed to the target
+// function. BindUnwrapTraits<>::Unwrap() is called for each bound objects right
+// before the target function is invoked.
+template <typename>
+struct BindUnwrapTraits {
+  template <typename T>
+  static T&& Unwrap(T&& o) { return std::forward<T>(o); }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::UnretainedWrapper<T>> {
+  static T* Unwrap(const internal::UnretainedWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::ConstRefWrapper<T>> {
+  static const T& Unwrap(const internal::ConstRefWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::RetainedRefWrapper<T>> {
+  static T* Unwrap(const internal::RetainedRefWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::OwnedWrapper<T>> {
+  static T* Unwrap(const internal::OwnedWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::PassedWrapper<T>> {
+  static T Unwrap(const internal::PassedWrapper<T>& o) {
+    return o.Take();
+  }
+};
+
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_