From 5d6e58e76e7750a86eed2da8f0c2b62b58d8356b Mon Sep 17 00:00:00 2001
From: Jelena Marusic <jmarusic@webrtc.org>
Date: Mon, 13 Jul 2015 11:16:39 +0200
Subject: [PATCH] Improvements to rtc::Bind

BUG=webrtc:4690

Support for rtc::scoped_ptr as return type.
Support for up to 6 input parameters.

R=pthatcher@webrtc.org, solenberg@webrtc.org

Review URL: https://codereview.webrtc.org/1226153003 .

Cr-Commit-Position: refs/heads/master@{#9569}
---
 webrtc/base/bind.h           | 136 +++++++++++++++++++++++++++++++++++
 webrtc/base/messagehandler.h |  16 ++++-
 2 files changed, 151 insertions(+), 1 deletion(-)

diff --git a/webrtc/base/bind.h b/webrtc/base/bind.h
index 2e3104edfd..0db11747aa 100644
--- a/webrtc/base/bind.h
+++ b/webrtc/base/bind.h
@@ -578,6 +578,142 @@ Bind(FP_T(function),
       function, p1, p2, p3, p4, p5);
 }
 
+#undef FP_T
+template <class ObjectT,
+          class MethodT,
+          class R,
+          class P1,
+          class P2,
+          class P3,
+          class P4,
+          class P5,
+          class P6>
+class MethodFunctor6 {
+ public:
+  MethodFunctor6(MethodT method,
+                 ObjectT* object,
+                 P1 p1,
+                 P2 p2,
+                 P3 p3,
+                 P4 p4,
+                 P5 p5,
+                 P6 p6)
+      : method_(method),
+        object_(object),
+        p1_(p1),
+        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_;
+  ObjectT* object_;
+  P1 p1_;
+  P2 p2_;
+  P3 p3_;
+  P4 p4_;
+  P5 p5_;
+  P6 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_;
+};
+
+#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,
+          class P5,
+          class P6>
+MethodFunctor6<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5, P6> Bind(
+    FP_T(method),
+    ObjectT* object,
+    typename detail::identity<P1>::type p1,
+    typename detail::identity<P2>::type p2,
+    typename detail::identity<P3>::type p3,
+    typename detail::identity<P4>::type p4,
+    typename detail::identity<P5>::type p5,
+    typename detail::identity<P6>::type p6) {
+  return MethodFunctor6<ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5, P6>(
+      method, object, p1, p2, p3, p4, p5, p6);
+}
+
+#undef FP_T
+#define FP_T(x) R (ObjectT::*x)(P1, P2, P3, P4, P5, P6) const
+
+template <class ObjectT,
+          class R,
+          class P1,
+          class P2,
+          class P3,
+          class P4,
+          class P5,
+          class P6>
+MethodFunctor6<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5, P6> Bind(
+    FP_T(method),
+    const ObjectT* object,
+    typename detail::identity<P1>::type p1,
+    typename detail::identity<P2>::type p2,
+    typename detail::identity<P3>::type p3,
+    typename detail::identity<P4>::type p4,
+    typename detail::identity<P5>::type p5,
+    typename detail::identity<P6>::type p6) {
+  return MethodFunctor6<const ObjectT, FP_T(NONAME), R, P1, P2, P3, P4, P5, P6>(
+      method, object, p1, p2, p3, p4, p5, p6);
+}
+
+#undef FP_T
+#define FP_T(x) R (*x)(P1, P2, P3, P4, P5, P6)
+
+template <class R, class P1, class P2, class P3, class P4, class P5, class P6>
+Functor6<FP_T(NONAME), R, P1, P2, P3, P4, P5, P6> Bind(
+    FP_T(function),
+    typename detail::identity<P1>::type p1,
+    typename detail::identity<P2>::type p2,
+    typename detail::identity<P3>::type p3,
+    typename detail::identity<P4>::type p4,
+    typename detail::identity<P5>::type p5,
+    typename detail::identity<P5>::type p6) {
+  return Functor6<FP_T(NONAME), R, P1, P2, P3, P4, P5, P6>(function, p1, p2, p3,
+                                                           p4, p5, p6);
+}
+
 #undef FP_T
 
 }  // namespace rtc
diff --git a/webrtc/base/messagehandler.h b/webrtc/base/messagehandler.h
index 123c850973..b0a82179a2 100644
--- a/webrtc/base/messagehandler.h
+++ b/webrtc/base/messagehandler.h
@@ -12,6 +12,7 @@
 #define WEBRTC_BASE_MESSAGEHANDLER_H_
 
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace rtc {
 
@@ -47,6 +48,20 @@ class FunctorMessageHandler : public MessageHandler {
   ReturnT result_;
 };
 
+// Specialization for rtc::scoped_ptr<ReturnT>.
+template <class ReturnT, class FunctorT>
+class FunctorMessageHandler<class rtc::scoped_ptr<ReturnT>, FunctorT>
+    : public MessageHandler {
+ public:
+  explicit FunctorMessageHandler(const FunctorT& functor) : functor_(functor) {}
+  virtual void OnMessage(Message* msg) { result_ = functor_().Pass(); }
+  rtc::scoped_ptr<ReturnT> result() { return result_.Pass(); }
+
+ private:
+  FunctorT functor_;
+  rtc::scoped_ptr<ReturnT> result_;
+};
+
 // Specialization for ReturnT of void.
 template <class FunctorT>
 class FunctorMessageHandler<void, FunctorT> : public MessageHandler {
@@ -62,7 +77,6 @@ class FunctorMessageHandler<void, FunctorT> : public MessageHandler {
   FunctorT functor_;
 };
 
-
 } // namespace rtc
 
 #endif // WEBRTC_BASE_MESSAGEHANDLER_H_