Remove overloads for Callback in bind_helpers.h

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 326 matching lines @@
  public:
   explicit RetainedRefWrapper(T* o) : ptr_(o) {}
   explicit RetainedRefWrapper(scoped_refptr<T> o) : ptr_(std::move(o)) {}
   T* get() const { return ptr_.get(); }
  private:
   scoped_refptr<T> ptr_;
 };
 
 template <typename T>
 struct IgnoreResultHelper {
-  explicit IgnoreResultHelper(T functor) : functor_(functor) {}
+  explicit IgnoreResultHelper(T functor) : functor_(std::move(functor)) {}

[Yuta Kitamura, 2016/06/29 00:07:55]

Do you expect |T| to be something like Callback<T>? Is
there any other thing?

[tzik, 2016/06/29 02:49:08]

T is a Functor. That can be Callback<>, function pointers, method pointers, or
IgnoreResult<>.

 
   T functor_;
 };
 
-template <typename T>
-struct IgnoreResultHelper<Callback<T> > {
-  explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
-
-  const Callback<T>& functor_;
-};
-
 // An alternate implementation is to avoid the destructive copy, and instead
 // specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
 // a class that is essentially a std::unique_ptr<>.
 //
 // The current implementation has the benefit though of leaving ParamTraits<>
 // fully in callback_internal.h as well as avoiding type conversions during
 // storage.
 template <typename T>
 class OwnedWrapper {
  public:
@@ skipping 45 matching lines @@
     return std::move(scoper_);
   }
 
  private:
   mutable bool is_valid_;
   mutable T scoper_;
 };
 
 // Unwrap the stored parameters for the wrappers above.
 template <typename T>
-const T& Unwrap(const T& o) {
-  return o;
+T&& Unwrap(T&& o) {

[Yuta Kitamura, 2016/06/29 00:07:55]

aside: If the argument can be an rvalue reference, WTF's
PassedWrapper's mutable can be removed by using rref?

[tzik, 2016/06/29 02:49:08]

No. The constness of the internal storage is from Invoker::Run(), which uses
const StorageType.

+  return std::forward<T>(o);
 }
 
 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();
@@ skipping 168 matching lines @@
 static inline internal::PassedWrapper<T> Passed(T&& scoper) {
   return internal::PassedWrapper<T>(std::move(scoper));
 }
 template <typename T>
 static inline internal::PassedWrapper<T> Passed(T* scoper) {
   return internal::PassedWrapper<T>(std::move(*scoper));
 }
 
 template <typename T>
 static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
-  return internal::IgnoreResultHelper<T>(data);
-}
-
-template <typename T>
-static inline internal::IgnoreResultHelper<Callback<T> >
-IgnoreResult(const Callback<T>& data) {
-  return internal::IgnoreResultHelper<Callback<T> >(data);
+  return internal::IgnoreResultHelper<T>(std::move(data));
 }
 
 BASE_EXPORT void DoNothing();
 
 template<typename T>
 void DeletePointer(T* obj) {
   delete obj;
 }
 
 // An injection point to control |this| pointer behavior on a method invocation.
@@ skipping 12 matching lines @@
 
 template <typename T>
 struct IsWeakReceiver<internal::ConstRefWrapper<T>> : IsWeakReceiver<T> {};
 
 template <typename T>
 struct IsWeakReceiver<WeakPtr<T>> : std::true_type {};
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_