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 42 matching lines @@
 //     auto functor = rtc::Bind(&Bar::Test, bar);
 //     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 <ciso646>  // Small include to detect c++ std lib.
+#if defined(_LIBCPP_VERSION) || defined(_MSC_VER)
+#include <type_traits>

[magjed_webrtc, 2015/10/22 23:54:31]

I'm surprised this compiles on all webrtc bots, but I still think all C++11
library features are banned, no? Are you sure it will be possible to roll this
change into Chromium?
You could also implement this yourself with just one more template
specialization:
template <class T&> struct RemoveAllRef { typedef T type; };

[noahric, 2015/10/23 00:34:27]

Ah, yeah, good point. And I realized I was being dumb and don't actually need a
specialization anymore for scoped_refptr specifically. For some reason, in my
head, I thought it was removing references inside the scoped_ptr, which doesn't
make sense.

Though this was also removing const-ness. Is that still desirable? It shouldn't
actually make a difference if the field is const or not, so I updated the
bind_unittest's static_assert to expect ::type's const-ness to match the
inferred template type.

Let me know if you want me to put it back and add specializations for also
stripping out const.

Thanks!

[magjed_webrtc, 2015/10/23 05:17:01]

I don't remember why I stripped const-ness, but I think I got some compiler
error because AddRef() and Release() used to be non-const methods in WebRTC, and
this was a workaround.

If it compiles without stripping const-ness, it's not desirable :)

[noahric, 2015/10/23 06:02:16]

Gotcha. Seems to be fine now that they are const and the ref field is mutable.

+#define STD_REMOVE_REFERENCE std::remove_reference
+#else
+#include <tr1/type_traits>
+#define STD_REMOVE_REFERENCE std::tr1::remove_reference
+#endif
+
 #include "webrtc/base/scoped_ref_ptr.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
@@ skipping 44 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; };
+// RemoveAllRef will capture scoped_refptr by-value instead of
+// by-reference. It will additionally capture non-refptr T types by value.
 template <class T>
-struct RemoveScopedPtrRef<const scoped_refptr<T>&> {
+struct RemoveAllRef {
+  typedef typename STD_REMOVE_REFERENCE<T>::type type;
+};
+template <class T>
+struct RemoveAllRef<const scoped_refptr<T>&> {
   typedef scoped_refptr<T> type;
 };
 template <class T>
-struct RemoveScopedPtrRef<scoped_refptr<T>&> {
+struct RemoveAllRef<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 detail::RemoveAllRef<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 detail::RemoveAllRef<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_