Adding rtc::Unretained to allow avoiding rtc::Bind reference capture.

webrtc/base/bind.h

 /*
  *  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.
  */
 
 // Bind() is an overloaded function that converts method calls into function
 // objects (aka functors). The method object is captured as a scoped_refptr<> if
 // possible, and as a raw pointer otherwise. Any arguments to the method are
 // captured by value. The return value of Bind is a stateful, nullary function
 // object. Care should be taken about the lifetime of objects captured by
 // Bind(); the returned functor knows nothing about the lifetime of a non
 // ref-counted method object or any arguments passed by pointer, and calling the
 // functor with a destroyed object will surely do bad things.
 //
+// To prevent the method object from being captured as a scoped_refptr<>, you
+// can use Unretained. But this should only be done when absolutely necessary,
+// and when the caller knows the extra reference isn't needed.
+//
 // Example usage:
 //   struct Foo {
 //     int Test1() { return 42; }
 //     int Test2() const { return 52; }
 //     int Test3(int x) { return x*x; }
 //     float Test4(int x, float y) { return x + y; }
 //   };
 //
 //   int main() {
 //     Foo foo;
@@ skipping 88 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;
 };
 
+template <typename T>
+class UnretainedWrapper {
+ public:
+  explicit UnretainedWrapper(T* o) : ptr_(o) {}
+  T* get() const { return ptr_; }
+
+ private:
+  T* ptr_;
+};
+
 }  // namespace detail
 
+template <typename T>
+static inline detail::UnretainedWrapper<T> Unretained(T* o) {
+  return detail::UnretainedWrapper<T>(o);
+}
+
 template <class ObjectT, class MethodT, class R, typename... Args>
 class MethodFunctor {
  public:
   MethodFunctor(MethodT method, ObjectT* object, Args... args)
       : method_(method), object_(object), args_(args...) {}
   R operator()() const {
     return CallMethod(typename sequence_generator<sizeof...(Args)>::type());
   }
 
  private:
   // Use sequence_generator (see template_util.h) to expand a MethodFunctor
   // with 2 arguments to (std::get<0>(args_), std::get<1>(args_)), for
   // instance.
   template <int... S>
   R CallMethod(sequence<S...>) const {
     return (object_->*method_)(std::get<S>(args_)...);
   }
 
   MethodT method_;
   typename detail::PointerType<ObjectT>::type object_;
   typename std::tuple<typename std::remove_reference<Args>::type...> args_;
 };
 
+template <class ObjectT, class MethodT, class R, typename... Args>
+class UnretainedMethodFunctor {
+ public:
+  UnretainedMethodFunctor(MethodT method,
+                          detail::UnretainedWrapper<ObjectT> object,
+                          Args... args)
+      : method_(method), object_(object.get()), args_(args...) {}
+  R operator()() const {
+    return CallMethod(typename sequence_generator<sizeof...(Args)>::type());
+  }
+
+ private:
+  // Use sequence_generator (see template_util.h) to expand an
+  // UnretainedMethodFunctor with 2 arguments to (std::get<0>(args_),
+  // std::get<1>(args_)), for instance.
+  template <int... S>
+  R CallMethod(sequence<S...>) const {
+    return (object_->*method_)(std::get<S>(args_)...);
+  }
+
+  MethodT method_;
+  ObjectT* object_;
+  typename std::tuple<typename std::remove_reference<Args>::type...> args_;
+};
+
 template <class FunctorT, class R, typename... Args>
 class Functor {
  public:
   Functor(const FunctorT& functor, Args... args)
       : functor_(functor), args_(args...) {}
   R operator()() const {
     return CallFunction(typename sequence_generator<sizeof...(Args)>::type());
   }
 
  private:
@@ skipping 13 matching lines @@
 
 template <class ObjectT, class R, typename... Args>
 MethodFunctor<ObjectT, FP_T(NONAME), R, Args...> Bind(
     FP_T(method),
     ObjectT* object,
     typename detail::identity<Args>::type... args) {
   return MethodFunctor<ObjectT, FP_T(NONAME), R, Args...>(method, object,
                                                           args...);
 }
 
+template <class ObjectT, class R, typename... Args>
+MethodFunctor<ObjectT, FP_T(NONAME), R, Args...> Bind(
+    FP_T(method),
+    const scoped_refptr<ObjectT>& object,
+    typename detail::identity<Args>::type... args) {
+  return MethodFunctor<ObjectT, FP_T(NONAME), R, Args...>(method, object.get(),
+                                                          args...);
+}
+
+template <class ObjectT, class R, typename... Args>
+UnretainedMethodFunctor<ObjectT, FP_T(NONAME), R, Args...> Bind(
+    FP_T(method),
+    detail::UnretainedWrapper<ObjectT> object,
+    typename detail::identity<Args>::type... args) {
+  return UnretainedMethodFunctor<ObjectT, FP_T(NONAME), R, Args...>(
+      method, object, args...);
+}
+
 #undef FP_T
 #define FP_T(x) R (ObjectT::*x)(Args...) const
 
 template <class ObjectT, class R, typename... Args>
 MethodFunctor<const ObjectT, FP_T(NONAME), R, Args...> Bind(
     FP_T(method),
     const ObjectT* object,
     typename detail::identity<Args>::type... args) {
   return MethodFunctor<const ObjectT, FP_T(NONAME), R, Args...>(method, object,
                                                                 args...);
 }
-
-#undef FP_T
-#define FP_T(x) R (ObjectT::*x)(Args...)
-
 template <class ObjectT, class R, typename... Args>
-MethodFunctor<ObjectT, FP_T(NONAME), R, Args...> Bind(
+UnretainedMethodFunctor<const ObjectT, FP_T(NONAME), R, Args...> Bind(
     FP_T(method),
-    const scoped_refptr<ObjectT>& object,
+    detail::UnretainedWrapper<const ObjectT> object,
     typename detail::identity<Args>::type... args) {
-  return MethodFunctor<ObjectT, FP_T(NONAME), R, Args...>(method, object.get(),
-                                                          args...);
+  return UnretainedMethodFunctor<const ObjectT, FP_T(NONAME), R, Args...>(
+      method, object, args...);
 }
 
 #undef FP_T
 #define FP_T(x) R (*x)(Args...)
 
 template <class R, typename... Args>
 Functor<FP_T(NONAME), R, Args...> Bind(
     FP_T(function),
     typename detail::identity<Args>::type... args) {
   return Functor<FP_T(NONAME), R, Args...>(function, args...);
 }
 
 #undef FP_T
 
 }  // namespace rtc
 
 #undef NONAME
 
 #endif  // WEBRTC_BASE_BIND_H_