rtc::Bind: Capture scoped_refptr reference arguments by value

webrtc/base/bind.h

 // This file was GENERATED by command:
 //     pump.py bind.h.pump
 // DO NOT EDIT BY HAND!!!
 
 /*
  *  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
@@ skipping 110 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
 
 template <class ObjectT, class MethodT, class R>
 class MethodFunctor0 {
  public:
   MethodFunctor0(MethodT method, ObjectT* object)
       : method_(method), object_(object) {}
   R operator()() const {
     return (object_->*method_)(); }
  private:
@@ skipping 60 matching lines @@
  public:
   MethodFunctor1(MethodT method, ObjectT* object,
                  P1 p1)
       : method_(method), object_(object),
       p1_(p1) {}
   R operator()() const {
     return (object_->*method_)(p1_); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
-  P1 p1_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
 };
 
 template <class FunctorT, class R,
           class P1>
 class Functor1 {
  public:
   Functor1(const FunctorT& functor, P1 p1)
       : functor_(functor),
       p1_(p1) {}
   R operator()() const {
     return functor_(p1_); }
  private:
   FunctorT functor_;
-  P1 p1_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
 };
 
 
 #define FP_T(x) R (ObjectT::*x)(P1)
 
 template <class ObjectT, class R,
           class P1>
 MethodFunctor1<ObjectT, FP_T(NONAME), R, P1>
 Bind(FP_T(method), ObjectT* object,
      typename detail::identity<P1>::type p1) {
@@ skipping 48 matching lines @@
                  P1 p1,
                  P2 p2)
       : method_(method), object_(object),
       p1_(p1),
       p2_(p2) {}
   R operator()() const {
     return (object_->*method_)(p1_, p2_); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
-  P1 p1_;
-  P2 p2_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
 };
 
 template <class FunctorT, class R,
           class P1,
           class P2>
 class Functor2 {
  public:
   Functor2(const FunctorT& functor, P1 p1, P2 p2)
       : functor_(functor),
       p1_(p1),
       p2_(p2) {}
   R operator()() const {
     return functor_(p1_, p2_); }
  private:
   FunctorT functor_;
-  P1 p1_;
-  P2 p2_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
 };
 
 
 #define FP_T(x) R (ObjectT::*x)(P1, P2)
 
 template <class ObjectT, class R,
           class P1,
           class P2>
 MethodFunctor2<ObjectT, FP_T(NONAME), R, P1, P2>
 Bind(FP_T(method), ObjectT* object,
@@ skipping 59 matching lines @@
                  P3 p3)
       : method_(method), object_(object),
       p1_(p1),
       p2_(p2),
       p3_(p3) {}
   R operator()() const {
     return (object_->*method_)(p1_, p2_, p3_); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
 };
 
 template <class FunctorT, class R,
           class P1,
           class P2,
           class P3>
 class Functor3 {
  public:
   Functor3(const FunctorT& functor, P1 p1, P2 p2, P3 p3)
       : functor_(functor),
       p1_(p1),
       p2_(p2),
       p3_(p3) {}
   R operator()() const {
     return functor_(p1_, p2_, p3_); }
  private:
   FunctorT functor_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
 };
 
 
 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3)
 
 template <class ObjectT, class R,
           class P1,
           class P2,
           class P3>
 MethodFunctor3<ObjectT, FP_T(NONAME), R, P1, P2, P3>
@@ skipping 70 matching lines @@
       : method_(method), object_(object),
       p1_(p1),
       p2_(p2),
       p3_(p3),
       p4_(p4) {}
   R operator()() const {
     return (object_->*method_)(p1_, p2_, p3_, p4_); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
-  P4 p4_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
+  typename detail::RemoveScopedPtrRef<P4>::type p4_;
 };
 
 template <class FunctorT, class R,
           class P1,
           class P2,
           class P3,
           class P4>
 class Functor4 {
  public:
   Functor4(const FunctorT& functor, P1 p1, P2 p2, P3 p3, P4 p4)
       : functor_(functor),
       p1_(p1),
       p2_(p2),
       p3_(p3),
       p4_(p4) {}
   R operator()() const {
     return functor_(p1_, p2_, p3_, p4_); }
  private:
   FunctorT functor_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
-  P4 p4_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
+  typename detail::RemoveScopedPtrRef<P4>::type p4_;
 };
 
 
 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4)
 
 template <class ObjectT, class R,
           class P1,
           class P2,
           class P3,
           class P4>
@@ skipping 81 matching lines @@
       p1_(p1),
       p2_(p2),
       p3_(p3),
       p4_(p4),
       p5_(p5) {}
   R operator()() const {
     return (object_->*method_)(p1_, p2_, p3_, p4_, p5_); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
-  P4 p4_;
-  P5 p5_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
+  typename detail::RemoveScopedPtrRef<P4>::type p4_;
+  typename detail::RemoveScopedPtrRef<P5>::type p5_;
 };
 
 template <class FunctorT, class R,
           class P1,
           class P2,
           class P3,
           class P4,
           class P5>
 class Functor5 {
  public:
   Functor5(const FunctorT& functor, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
       : functor_(functor),
       p1_(p1),
       p2_(p2),
       p3_(p3),
       p4_(p4),
       p5_(p5) {}
   R operator()() const {
     return functor_(p1_, p2_, p3_, p4_, p5_); }
  private:
   FunctorT functor_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
-  P4 p4_;
-  P5 p5_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
+  typename detail::RemoveScopedPtrRef<P4>::type p4_;
+  typename detail::RemoveScopedPtrRef<P5>::type p5_;
 };
 
 
 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5)
 
 template <class ObjectT, class R,
           class P1,
           class P2,
           class P3,
           class P4,
@@ skipping 92 matching lines @@
       p2_(p2),
       p3_(p3),
       p4_(p4),
       p5_(p5),
       p6_(p6) {}
   R operator()() const {
     return (object_->*method_)(p1_, p2_, p3_, p4_, p5_, p6_); }
  private:
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
-  P4 p4_;
-  P5 p5_;
-  P6 p6_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
+  typename detail::RemoveScopedPtrRef<P4>::type p4_;
+  typename detail::RemoveScopedPtrRef<P5>::type p5_;
+  typename detail::RemoveScopedPtrRef<P6>::type p6_;
 };
 
 template <class FunctorT, class R,
           class P1,
           class P2,
           class P3,
           class P4,
           class P5,
           class P6>
 class Functor6 {
  public:
   Functor6(const FunctorT& functor, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
       : functor_(functor),
       p1_(p1),
       p2_(p2),
       p3_(p3),
       p4_(p4),
       p5_(p5),
       p6_(p6) {}
   R operator()() const {
     return functor_(p1_, p2_, p3_, p4_, p5_, p6_); }
  private:
   FunctorT functor_;
-  P1 p1_;
-  P2 p2_;
-  P3 p3_;
-  P4 p4_;
-  P5 p5_;
-  P6 p6_;
+  typename detail::RemoveScopedPtrRef<P1>::type p1_;
+  typename detail::RemoveScopedPtrRef<P2>::type p2_;
+  typename detail::RemoveScopedPtrRef<P3>::type p3_;
+  typename detail::RemoveScopedPtrRef<P4>::type p4_;
+  typename detail::RemoveScopedPtrRef<P5>::type p5_;
+  typename detail::RemoveScopedPtrRef<P6>::type p6_;
 };
 
 
 #define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5, P6)
 
 template <class ObjectT, class R,
           class P1,
           class P2,
           class P3,
           class P4,
@@ skipping 77 matching lines @@
       function, p1, p2, p3, p4, p5, p6);
 }
 
 #undef FP_T
 
 }  // namespace rtc
 
 #undef NONAME
 
 #endif  // WEBRTC_BASE_BIND_H_