Update Bind to match its comments and always capture by value.

webrtc/base/bind.h.pump

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 43 matching lines @@
 //     bar = nullptr;
 //     // The functor stores an internal scoped_refptr<Bar>, so this is safe.
 //     functor();
 //   }
 //
 
 #ifndef WEBRTC_BASE_BIND_H_
 #define WEBRTC_BASE_BIND_H_
 
 #include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/template_util.h"
 
 #define NONAME
 
 namespace rtc {
 namespace detail {
 // This is needed because the template parameters in Bind can't be resolved
 // if they're used both as parameters of the function pointer type and as
 // parameters to Bind itself: the function pointer parameters are exact
 // matches to the function prototype, but the parameters to bind have
 // references stripped. This trick allows the compiler to dictate the Bind
@@ skipping 43 matching lines @@
 
 // PointerType<T>::type will be scoped_refptr<T> for ref counted types, and T*
 // otherwise.
 template <class T>
 struct PointerType {
   typedef typename TernaryTypeOperator<IsRefCounted<T>::value,
                                        scoped_refptr<T>,
                                        T*>::type type;
 };
 
-// RemoveScopedPtrRef will capture scoped_refptr by-value instead of
-// by-reference.
-template <class T> struct RemoveScopedPtrRef { typedef T type; };
-template <class T>
-struct RemoveScopedPtrRef<const scoped_refptr<T>&> {
-  typedef scoped_refptr<T> type;
-};
-template <class T>
-struct RemoveScopedPtrRef<scoped_refptr<T>&> {
-  typedef scoped_refptr<T> type;
-};
-
 }  // namespace detail
 
-$var n = 6
+$var n = 9
 $range i 0..n
 $for i [[
 $range j 1..i
 
 template <class ObjectT, class MethodT, class R$for j [[,
           class P$j]]>
 class MethodFunctor$i {
  public:
   MethodFunctor$i(MethodT method, ObjectT* object$for j [[,
                  P$j p$j]])
       : method_(method), object_(object)$for j [[,
       p$(j)_(p$j)]] {}
   R operator()() const {
     return (object_->*method_)($for j , [[p$(j)_]]); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;$for j [[
 
-  typename detail::RemoveScopedPtrRef<P$j>::type p$(j)_;]]
+  typename rtc::remove_reference<P$j>::type p$(j)_;]]
 
 };
 
 template <class FunctorT, class R$for j [[,
           class P$j]]>
 class Functor$i {
  public:
   $if i == 0 [[explicit ]]
 Functor$i(const FunctorT& functor$for j [[, P$j p$j]])
       : functor_(functor)$for j [[,
       p$(j)_(p$j)]] {}
   R operator()() const {
     return functor_($for j , [[p$(j)_]]); }
  private:
   FunctorT functor_;$for j [[
 
-  typename detail::RemoveScopedPtrRef<P$j>::type p$(j)_;]]
+  typename rtc::remove_reference<P$j>::type p$(j)_;]]
 
 };
 
 
 #define FP_T(x) R (ObjectT::*x)($for j , [[P$j]])
 
 template <class ObjectT, class R$for j [[,
           class P$j]]>
 MethodFunctor$i<ObjectT, FP_T(NONAME), R$for j [[, P$j]]>
 Bind(FP_T(method), ObjectT* object$for j [[,
@@ skipping 40 matching lines @@
 
 #undef FP_T
 
 ]]
 
 }  // namespace rtc
 
 #undef NONAME
 
 #endif  // WEBRTC_BASE_BIND_H_