Support binding WeakPtr<> to methods with void return types.

base/bind_internal.h

Index: base/bind_internal.h
diff --git a/base/bind_internal.h b/base/bind_internal.h
index 606e2b098c5928d2bb28e32d81eb914a1b73c56d..fa58e10debaf0e08b0e7ea30cade43e32311e4eb 100644
--- a/base/bind_internal.h
+++ b/base/bind_internal.h
@@ -16,6 +16,7 @@
 #include "base/callback_internal.h"
 #include "base/template_util.h"
 #include "build/build_config.h"
+#include "base/memory/weak_ptr.h"

[willchan no longer on Chromium, 2011/05/14 01:25:10]

Again, sort alphabetically :)

[awong, 2011/05/16 20:01:27]

Done.

 
 #if defined(OS_WIN)
 #include "base/bind_internal_win.h"
@@ -39,10 +40,21 @@ namespace internal {
 //                 a calback.
 //   InvokerStorageN<> -- Provides storage for the bound parameters, and
 //                        typedefs to the above.
+//   IsWeakMethod<> -- Determines if we are binding a method to a WeakPtr<>.
 //
 // More details about the design of each class is included in a comment closer
 // to their defition.
 
+
+// IsWeakMethod determines if we are binding a method to a WeakPtr<> for an
+// object.  It is used to select an InvokerN that will no-op itself in the
+// event the WeakPtr<> for the target object is invalidated.
+template <bool IsMethod, typename T>
+struct IsWeakMethod : public false_type {};
+
+template <typename T>
+struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
+
 // FunctionTraits<>
 //
 // The FunctionTraits<> template determines the type of function, and also
@@ -75,6 +87,8 @@ struct FunctionTraits<R(*)()> {
   typedef R (*NormalizedSig)();
   typedef false_type IsMethod;
 
+  typedef R Return;
+
 };
 
 // Method: Arity 0.
@@ -83,6 +97,8 @@ struct FunctionTraits<R(T::*)()> {
   typedef R (T::*NormalizedSig)();
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
 
@@ -94,6 +110,8 @@ struct FunctionTraits<R(T::*)() const> {
   typedef R (T::*NormalizedSig)();
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
 
@@ -104,6 +122,9 @@ template <typename R, typename X1>
 struct FunctionTraits<R(*)(X1)> {
   typedef R (*NormalizedSig)(X1);
   typedef false_type IsMethod;
+
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef X1 B1;
 
@@ -115,6 +136,8 @@ struct FunctionTraits<R(T::*)(X1)> {
   typedef R (T::*NormalizedSig)(X1);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -127,6 +150,8 @@ struct FunctionTraits<R(T::*)(X1) const> {
   typedef R (T::*NormalizedSig)(X1);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -138,6 +163,9 @@ template <typename R, typename X1, typename X2>
 struct FunctionTraits<R(*)(X1, X2)> {
   typedef R (*NormalizedSig)(X1, X2);
   typedef false_type IsMethod;
+
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef X1 B1;
   typedef X2 B2;
@@ -150,6 +178,8 @@ struct FunctionTraits<R(T::*)(X1, X2)> {
   typedef R (T::*NormalizedSig)(X1, X2);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -163,6 +193,8 @@ struct FunctionTraits<R(T::*)(X1, X2) const> {
   typedef R (T::*NormalizedSig)(X1, X2);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -175,6 +207,9 @@ template <typename R, typename X1, typename X2, typename X3>
 struct FunctionTraits<R(*)(X1, X2, X3)> {
   typedef R (*NormalizedSig)(X1, X2, X3);
   typedef false_type IsMethod;
+
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef X1 B1;
   typedef X2 B2;
@@ -188,6 +223,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3)> {
   typedef R (T::*NormalizedSig)(X1, X2, X3);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -202,6 +239,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3) const> {
   typedef R (T::*NormalizedSig)(X1, X2, X3);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -215,6 +254,9 @@ template <typename R, typename X1, typename X2, typename X3, typename X4>
 struct FunctionTraits<R(*)(X1, X2, X3, X4)> {
   typedef R (*NormalizedSig)(X1, X2, X3, X4);
   typedef false_type IsMethod;
+
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef X1 B1;
   typedef X2 B2;
@@ -230,6 +272,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4)> {
   typedef R (T::*NormalizedSig)(X1, X2, X3, X4);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -246,6 +290,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4) const> {
   typedef R (T::*NormalizedSig)(X1, X2, X3, X4);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -261,6 +307,9 @@ template <typename R, typename X1, typename X2, typename X3, typename X4,
 struct FunctionTraits<R(*)(X1, X2, X3, X4, X5)> {
   typedef R (*NormalizedSig)(X1, X2, X3, X4, X5);
   typedef false_type IsMethod;
+
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef X1 B1;
   typedef X2 B2;
@@ -277,6 +326,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4, X5)> {
   typedef R (T::*NormalizedSig)(X1, X2, X3, X4, X5);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -294,6 +345,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4, X5) const> {
   typedef R (T::*NormalizedSig)(X1, X2, X3, X4, X5);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -310,6 +363,9 @@ template <typename R, typename X1, typename X2, typename X3, typename X4,
 struct FunctionTraits<R(*)(X1, X2, X3, X4, X5, X6)> {
   typedef R (*NormalizedSig)(X1, X2, X3, X4, X5, X6);
   typedef false_type IsMethod;
+
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef X1 B1;
   typedef X2 B2;
@@ -327,6 +383,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4, X5, X6)> {
   typedef R (T::*NormalizedSig)(X1, X2, X3, X4, X5, X6);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -345,6 +403,8 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4, X5, X6) const> {
   typedef R (T::*NormalizedSig)(X1, X2, X3, X4, X5, X6);
   typedef true_type IsMethod;
 
+  typedef R Return;
+
   // Target type for each bound parameter.
   typedef T B1;
   typedef X1 B2;
@@ -376,12 +436,12 @@ struct FunctionTraits<R(T::*)(X1, X2, X3, X4, X5, X6) const> {
 // templates classes in the system to only have as many specializations as
 // the max arity of function we wish to support.
 
-template <typename StorageType, typename NormalizedSig>
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker0;
 
 // Function: Arity 0 -> 0.
 template <typename StorageType, typename R>
-struct Invoker0<StorageType, R(*)()> {
+struct Invoker0<false, StorageType, R(*)()> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_();
@@ -390,7 +450,7 @@ struct Invoker0<StorageType, R(*)()> {
 
 // Function: Arity 1 -> 1.
 template <typename StorageType, typename R,typename X1>
-struct Invoker0<StorageType, R(*)(X1)> {
+struct Invoker0<false, StorageType, R(*)(X1)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -400,7 +460,7 @@ struct Invoker0<StorageType, R(*)(X1)> {
 
 // Function: Arity 2 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2>
-struct Invoker0<StorageType, R(*)(X1, X2)> {
+struct Invoker0<false, StorageType, R(*)(X1, X2)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2) {
@@ -412,7 +472,7 @@ struct Invoker0<StorageType, R(*)(X1, X2)> {
 // Function: Arity 3 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
-struct Invoker0<StorageType, R(*)(X1, X2, X3)> {
+struct Invoker0<false, StorageType, R(*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -425,7 +485,7 @@ struct Invoker0<StorageType, R(*)(X1, X2, X3)> {
 // Function: Arity 4 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
-struct Invoker0<StorageType, R(*)(X1, X2, X3, X4)> {
+struct Invoker0<false, StorageType, R(*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -439,7 +499,7 @@ struct Invoker0<StorageType, R(*)(X1, X2, X3, X4)> {
 // Function: Arity 5 -> 5.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
-struct Invoker0<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+struct Invoker0<false, StorageType, R(*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -454,7 +514,7 @@ struct Invoker0<StorageType, R(*)(X1, X2, X3, X4, X5)> {
 // Function: Arity 6 -> 6.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker0<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker0<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -467,12 +527,12 @@ struct Invoker0<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   }
 };
 
-template <typename StorageType, typename NormalizedSig>
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker1;
 
 // Function: Arity 1 -> 0.
 template <typename StorageType, typename R,typename X1>
-struct Invoker1<StorageType, R(*)(X1)> {
+struct Invoker1<false, StorageType, R(*)(X1)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_(Unwrap(invoker->p1_));
@@ -481,16 +541,28 @@ struct Invoker1<StorageType, R(*)(X1)> {
 
 // Method: Arity 0 -> 0.
 template <typename StorageType, typename R, typename T>
-struct Invoker1<StorageType, R(T::*)()> {
+struct Invoker1<false, StorageType, R(T::*)()> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return (Unwrap(invoker->p1_)->*invoker->f_)();
   }
 };
 
+// WeakPtr Method: Arity 0 -> 0.
+template <typename StorageType, typename T>
+struct Invoker1<true, StorageType, void(T::*)()> {
+  static void DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {

[willchan no longer on Chromium, 2011/05/14 01:25:10]

It's non-obvious from reading the code that this is a WeakPtr. 'true' for IsWeak
isn't obvious if you're just reading this specific point. For clarity's sake, I
suggest you break this down.

const WeakPtr& ptr = invoker->p1_;
...

[awong, 2011/05/16 20:01:27]

Made a stab at it.  I need to take another pass through and rename some
variables plug break apart expressions.  In particular, this
StorageType::P1Traits::StorageType is confusing to read. :-/

But would like to do that in a different CL.

[willchan no longer on Chromium, 2011/05/16 22:01:26]

OK.

+      return;
+    }
+    (invoker->p1_->*invoker->f_)();
+  }
+};
+
 // Function: Arity 2 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2>
-struct Invoker1<StorageType, R(*)(X1, X2)> {
+struct Invoker1<false, StorageType, R(*)(X1, X2)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -500,7 +572,7 @@ struct Invoker1<StorageType, R(*)(X1, X2)> {
 
 // Method: Arity 1 -> 1.
 template <typename StorageType, typename R, typename T, typename X1>
-struct Invoker1<StorageType, R(T::*)(X1)> {
+struct Invoker1<false, StorageType, R(T::*)(X1)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -508,10 +580,23 @@ struct Invoker1<StorageType, R(T::*)(X1)> {
   }
 };
 
+// WeakPtr Method: Arity 1 -> 1.
+template <typename StorageType, typename T, typename X1>
+struct Invoker1<true, StorageType, void(T::*)(X1)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X1>::ForwardType x1) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(x1);
+  }
+};
+
 // Function: Arity 3 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
-struct Invoker1<StorageType, R(*)(X1, X2, X3)> {
+struct Invoker1<false, StorageType, R(*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3) {
@@ -523,7 +608,7 @@ struct Invoker1<StorageType, R(*)(X1, X2, X3)> {
 // Method: Arity 2 -> 2.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2>
-struct Invoker1<StorageType, R(T::*)(X1, X2)> {
+struct Invoker1<false, StorageType, R(T::*)(X1, X2)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2) {
@@ -532,10 +617,24 @@ struct Invoker1<StorageType, R(T::*)(X1, X2)> {
   }
 };
 
+// WeakPtr Method: Arity 2 -> 2.
+template <typename StorageType, typename T, typename X1, typename X2>
+struct Invoker1<true, StorageType, void(T::*)(X1, X2)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X1>::ForwardType x1,
+      typename internal::ParamTraits<X2>::ForwardType x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(x1, x2);
+  }
+};
+
 // Function: Arity 4 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
-struct Invoker1<StorageType, R(*)(X1, X2, X3, X4)> {
+struct Invoker1<false, StorageType, R(*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3,
@@ -548,7 +647,7 @@ struct Invoker1<StorageType, R(*)(X1, X2, X3, X4)> {
 // Method: Arity 3 -> 3.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3>
-struct Invoker1<StorageType, R(T::*)(X1, X2, X3)> {
+struct Invoker1<false, StorageType, R(T::*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -558,10 +657,26 @@ struct Invoker1<StorageType, R(T::*)(X1, X2, X3)> {
   }
 };
 
+// WeakPtr Method: Arity 3 -> 3.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3>
+struct Invoker1<true, StorageType, void(T::*)(X1, X2, X3)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X1>::ForwardType x1,
+      typename internal::ParamTraits<X2>::ForwardType x2,
+      typename internal::ParamTraits<X3>::ForwardType x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(x1, x2, x3);
+  }
+};
+
 // Function: Arity 5 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
-struct Invoker1<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+struct Invoker1<false, StorageType, R(*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3,
@@ -575,7 +690,7 @@ struct Invoker1<StorageType, R(*)(X1, X2, X3, X4, X5)> {
 // Method: Arity 4 -> 4.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4>
-struct Invoker1<StorageType, R(T::*)(X1, X2, X3, X4)> {
+struct Invoker1<false, StorageType, R(T::*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -586,10 +701,27 @@ struct Invoker1<StorageType, R(T::*)(X1, X2, X3, X4)> {
   }
 };
 
+// WeakPtr Method: Arity 4 -> 4.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker1<true, StorageType, void(T::*)(X1, X2, X3, X4)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X1>::ForwardType x1,
+      typename internal::ParamTraits<X2>::ForwardType x2,
+      typename internal::ParamTraits<X3>::ForwardType x3,
+      typename internal::ParamTraits<X4>::ForwardType x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(x1, x2, x3, x4);
+  }
+};
+
 // Function: Arity 6 -> 5.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker1<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker1<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3,
@@ -604,7 +736,7 @@ struct Invoker1<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
 // Method: Arity 5 -> 5.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4, typename X5>
-struct Invoker1<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+struct Invoker1<false, StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X1>::ForwardType x1,
       typename internal::ParamTraits<X2>::ForwardType x2,
@@ -616,12 +748,30 @@ struct Invoker1<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   }
 };
 
-template <typename StorageType, typename NormalizedSig>
+// WeakPtr Method: Arity 5 -> 5.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker1<true, StorageType, void(T::*)(X1, X2, X3, X4, X5)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X1>::ForwardType x1,
+      typename internal::ParamTraits<X2>::ForwardType x2,
+      typename internal::ParamTraits<X3>::ForwardType x3,
+      typename internal::ParamTraits<X4>::ForwardType x4,
+      typename internal::ParamTraits<X5>::ForwardType x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(x1, x2, x3, x4, x5);
+  }
+};
+
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker2;
 
 // Function: Arity 2 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2>
-struct Invoker2<StorageType, R(*)(X1, X2)> {
+struct Invoker2<false, StorageType, R(*)(X1, X2)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_));
@@ -630,17 +780,29 @@ struct Invoker2<StorageType, R(*)(X1, X2)> {
 
 // Method: Arity 1 -> 0.
 template <typename StorageType, typename R, typename T, typename X1>
-struct Invoker2<StorageType, R(T::*)(X1)> {
+struct Invoker2<false, StorageType, R(T::*)(X1)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_));
   }
 };
 
+// WeakPtr Method: Arity 1 -> 0.
+template <typename StorageType, typename T, typename X1>
+struct Invoker2<true, StorageType, void(T::*)(X1)> {
+  static void DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_));
+  }
+};
+
 // Function: Arity 3 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
-struct Invoker2<StorageType, R(*)(X1, X2, X3)> {
+struct Invoker2<false, StorageType, R(*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -651,7 +813,7 @@ struct Invoker2<StorageType, R(*)(X1, X2, X3)> {
 // Method: Arity 2 -> 1.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2>
-struct Invoker2<StorageType, R(T::*)(X1, X2)> {
+struct Invoker2<false, StorageType, R(T::*)(X1, X2)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -659,10 +821,23 @@ struct Invoker2<StorageType, R(T::*)(X1, X2)> {
   }
 };
 
+// WeakPtr Method: Arity 2 -> 1.
+template <typename StorageType, typename T, typename X1, typename X2>
+struct Invoker2<true, StorageType, void(T::*)(X1, X2)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X2>::ForwardType x2) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), x2);
+  }
+};
+
 // Function: Arity 4 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
-struct Invoker2<StorageType, R(*)(X1, X2, X3, X4)> {
+struct Invoker2<false, StorageType, R(*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3,
       typename internal::ParamTraits<X4>::ForwardType x4) {
@@ -674,7 +849,7 @@ struct Invoker2<StorageType, R(*)(X1, X2, X3, X4)> {
 // Method: Arity 3 -> 2.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3>
-struct Invoker2<StorageType, R(T::*)(X1, X2, X3)> {
+struct Invoker2<false, StorageType, R(T::*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3) {
@@ -683,10 +858,25 @@ struct Invoker2<StorageType, R(T::*)(X1, X2, X3)> {
   }
 };
 
+// WeakPtr Method: Arity 3 -> 2.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3>
+struct Invoker2<true, StorageType, void(T::*)(X1, X2, X3)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X2>::ForwardType x2,
+      typename internal::ParamTraits<X3>::ForwardType x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), x2, x3);
+  }
+};
+
 // Function: Arity 5 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
-struct Invoker2<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+struct Invoker2<false, StorageType, R(*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3,
       typename internal::ParamTraits<X4>::ForwardType x4,
@@ -699,7 +889,7 @@ struct Invoker2<StorageType, R(*)(X1, X2, X3, X4, X5)> {
 // Method: Arity 4 -> 3.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4>
-struct Invoker2<StorageType, R(T::*)(X1, X2, X3, X4)> {
+struct Invoker2<false, StorageType, R(T::*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3,
@@ -710,10 +900,26 @@ struct Invoker2<StorageType, R(T::*)(X1, X2, X3, X4)> {
   }
 };
 
+// WeakPtr Method: Arity 4 -> 3.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker2<true, StorageType, void(T::*)(X1, X2, X3, X4)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X2>::ForwardType x2,
+      typename internal::ParamTraits<X3>::ForwardType x3,
+      typename internal::ParamTraits<X4>::ForwardType x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), x2, x3, x4);
+  }
+};
+
 // Function: Arity 6 -> 4.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker2<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker2<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3,
       typename internal::ParamTraits<X4>::ForwardType x4,
@@ -728,7 +934,7 @@ struct Invoker2<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
 // Method: Arity 5 -> 4.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4, typename X5>
-struct Invoker2<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+struct Invoker2<false, StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X2>::ForwardType x2,
       typename internal::ParamTraits<X3>::ForwardType x3,
@@ -740,13 +946,30 @@ struct Invoker2<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   }
 };
 
-template <typename StorageType, typename NormalizedSig>
+// WeakPtr Method: Arity 5 -> 4.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker2<true, StorageType, void(T::*)(X1, X2, X3, X4, X5)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X2>::ForwardType x2,
+      typename internal::ParamTraits<X3>::ForwardType x3,
+      typename internal::ParamTraits<X4>::ForwardType x4,
+      typename internal::ParamTraits<X5>::ForwardType x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), x2, x3, x4, x5);
+  }
+};
+
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker3;
 
 // Function: Arity 3 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3>
-struct Invoker3<StorageType, R(*)(X1, X2, X3)> {
+struct Invoker3<false, StorageType, R(*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
@@ -757,7 +980,7 @@ struct Invoker3<StorageType, R(*)(X1, X2, X3)> {
 // Method: Arity 2 -> 0.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2>
-struct Invoker3<StorageType, R(T::*)(X1, X2)> {
+struct Invoker3<false, StorageType, R(T::*)(X1, X2)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
@@ -765,10 +988,22 @@ struct Invoker3<StorageType, R(T::*)(X1, X2)> {
   }
 };
 
+// WeakPtr Method: Arity 2 -> 0.
+template <typename StorageType, typename T, typename X1, typename X2>
+struct Invoker3<true, StorageType, void(T::*)(X1, X2)> {
+  static void DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_));
+  }
+};
+
 // Function: Arity 4 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
-struct Invoker3<StorageType, R(*)(X1, X2, X3, X4)> {
+struct Invoker3<false, StorageType, R(*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X4>::ForwardType x4) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -780,7 +1015,7 @@ struct Invoker3<StorageType, R(*)(X1, X2, X3, X4)> {
 // Method: Arity 3 -> 1.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3>
-struct Invoker3<StorageType, R(T::*)(X1, X2, X3)> {
+struct Invoker3<false, StorageType, R(T::*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -789,10 +1024,25 @@ struct Invoker3<StorageType, R(T::*)(X1, X2, X3)> {
   }
 };
 
+// WeakPtr Method: Arity 3 -> 1.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3>
+struct Invoker3<true, StorageType, void(T::*)(X1, X2, X3)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X3>::ForwardType x3) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        x3);
+  }
+};
+
 // Function: Arity 5 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
-struct Invoker3<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+struct Invoker3<false, StorageType, R(*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X4>::ForwardType x4,
       typename internal::ParamTraits<X5>::ForwardType x5) {
@@ -805,7 +1055,7 @@ struct Invoker3<StorageType, R(*)(X1, X2, X3, X4, X5)> {
 // Method: Arity 4 -> 2.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4>
-struct Invoker3<StorageType, R(T::*)(X1, X2, X3, X4)> {
+struct Invoker3<false, StorageType, R(T::*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3,
       typename internal::ParamTraits<X4>::ForwardType x4) {
@@ -815,10 +1065,26 @@ struct Invoker3<StorageType, R(T::*)(X1, X2, X3, X4)> {
   }
 };
 
+// WeakPtr Method: Arity 4 -> 2.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker3<true, StorageType, void(T::*)(X1, X2, X3, X4)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X3>::ForwardType x3,
+      typename internal::ParamTraits<X4>::ForwardType x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        x3, x4);
+  }
+};
+
 // Function: Arity 6 -> 3.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker3<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker3<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X4>::ForwardType x4,
       typename internal::ParamTraits<X5>::ForwardType x5,
@@ -832,7 +1098,7 @@ struct Invoker3<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
 // Method: Arity 5 -> 3.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4, typename X5>
-struct Invoker3<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+struct Invoker3<false, StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X3>::ForwardType x3,
       typename internal::ParamTraits<X4>::ForwardType x4,
@@ -843,13 +1109,30 @@ struct Invoker3<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   }
 };
 
-template <typename StorageType, typename NormalizedSig>
+// WeakPtr Method: Arity 5 -> 3.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker3<true, StorageType, void(T::*)(X1, X2, X3, X4, X5)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X3>::ForwardType x3,
+      typename internal::ParamTraits<X4>::ForwardType x4,
+      typename internal::ParamTraits<X5>::ForwardType x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        x3, x4, x5);
+  }
+};
+
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker4;
 
 // Function: Arity 4 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4>
-struct Invoker4<StorageType, R(*)(X1, X2, X3, X4)> {
+struct Invoker4<false, StorageType, R(*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
@@ -860,7 +1143,7 @@ struct Invoker4<StorageType, R(*)(X1, X2, X3, X4)> {
 // Method: Arity 3 -> 0.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3>
-struct Invoker4<StorageType, R(T::*)(X1, X2, X3)> {
+struct Invoker4<false, StorageType, R(T::*)(X1, X2, X3)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
@@ -868,10 +1151,24 @@ struct Invoker4<StorageType, R(T::*)(X1, X2, X3)> {
   }
 };
 
+// WeakPtr Method: Arity 3 -> 0.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3>
+struct Invoker4<true, StorageType, void(T::*)(X1, X2, X3)> {
+  static void DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        Unwrap(invoker->p4_));
+  }
+};
+
 // Function: Arity 5 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
-struct Invoker4<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+struct Invoker4<false, StorageType, R(*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X5>::ForwardType x5) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -883,7 +1180,7 @@ struct Invoker4<StorageType, R(*)(X1, X2, X3, X4, X5)> {
 // Method: Arity 4 -> 1.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4>
-struct Invoker4<StorageType, R(T::*)(X1, X2, X3, X4)> {
+struct Invoker4<false, StorageType, R(T::*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X4>::ForwardType x4) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -892,10 +1189,25 @@ struct Invoker4<StorageType, R(T::*)(X1, X2, X3, X4)> {
   }
 };
 
+// WeakPtr Method: Arity 4 -> 1.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker4<true, StorageType, void(T::*)(X1, X2, X3, X4)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X4>::ForwardType x4) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        Unwrap(invoker->p4_), x4);
+  }
+};
+
 // Function: Arity 6 -> 2.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker4<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker4<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X5>::ForwardType x5,
       typename internal::ParamTraits<X6>::ForwardType x6) {
@@ -908,7 +1220,7 @@ struct Invoker4<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
 // Method: Arity 5 -> 2.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4, typename X5>
-struct Invoker4<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+struct Invoker4<false, StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X4>::ForwardType x4,
       typename internal::ParamTraits<X5>::ForwardType x5) {
@@ -918,13 +1230,29 @@ struct Invoker4<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   }
 };
 
-template <typename StorageType, typename NormalizedSig>
+// WeakPtr Method: Arity 5 -> 2.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker4<true, StorageType, void(T::*)(X1, X2, X3, X4, X5)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X4>::ForwardType x4,
+      typename internal::ParamTraits<X5>::ForwardType x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        Unwrap(invoker->p4_), x4, x5);
+  }
+};
+
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker5;
 
 // Function: Arity 5 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5>
-struct Invoker5<StorageType, R(*)(X1, X2, X3, X4, X5)> {
+struct Invoker5<false, StorageType, R(*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
@@ -935,7 +1263,7 @@ struct Invoker5<StorageType, R(*)(X1, X2, X3, X4, X5)> {
 // Method: Arity 4 -> 0.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4>
-struct Invoker5<StorageType, R(T::*)(X1, X2, X3, X4)> {
+struct Invoker5<false, StorageType, R(T::*)(X1, X2, X3, X4)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
@@ -943,10 +1271,24 @@ struct Invoker5<StorageType, R(T::*)(X1, X2, X3, X4)> {
   }
 };
 
+// WeakPtr Method: Arity 4 -> 0.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4>
+struct Invoker5<true, StorageType, void(T::*)(X1, X2, X3, X4)> {
+  static void DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        Unwrap(invoker->p4_), Unwrap(invoker->p5_));
+  }
+};
+
 // Function: Arity 6 -> 1.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker5<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker5<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X6>::ForwardType x6) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -958,7 +1300,7 @@ struct Invoker5<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
 // Method: Arity 5 -> 1.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4, typename X5>
-struct Invoker5<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+struct Invoker5<false, StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base,
       typename internal::ParamTraits<X5>::ForwardType x5) {
     StorageType* invoker = static_cast<StorageType*>(base);
@@ -967,13 +1309,28 @@ struct Invoker5<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   }
 };
 
-template <typename StorageType, typename NormalizedSig>
+// WeakPtr Method: Arity 5 -> 1.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker5<true, StorageType, void(T::*)(X1, X2, X3, X4, X5)> {
+  static void DoInvoke(InvokerStorageBase* base,
+      typename internal::ParamTraits<X5>::ForwardType x5) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        Unwrap(invoker->p4_), Unwrap(invoker->p5_), x5);
+  }
+};
+
+template <bool IsWeak, typename StorageType, typename NormalizedSig>
 struct Invoker6;
 
 // Function: Arity 6 -> 0.
 template <typename StorageType, typename R,typename X1, typename X2,
     typename X3, typename X4, typename X5, typename X6>
-struct Invoker6<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
+struct Invoker6<false, StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return invoker->f_(Unwrap(invoker->p1_), Unwrap(invoker->p2_),
@@ -985,7 +1342,7 @@ struct Invoker6<StorageType, R(*)(X1, X2, X3, X4, X5, X6)> {
 // Method: Arity 5 -> 0.
 template <typename StorageType, typename R, typename T, typename X1,
     typename X2, typename X3, typename X4, typename X5>
-struct Invoker6<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
+struct Invoker6<false, StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   static R DoInvoke(InvokerStorageBase* base) {
     StorageType* invoker = static_cast<StorageType*>(base);
     return (Unwrap(invoker->p1_)->*invoker->f_)(Unwrap(invoker->p2_),
@@ -994,6 +1351,19 @@ struct Invoker6<StorageType, R(T::*)(X1, X2, X3, X4, X5)> {
   }
 };
 
+// WeakPtr Method: Arity 5 -> 0.
+template <typename StorageType, typename T, typename X1, typename X2,
+    typename X3, typename X4, typename X5>
+struct Invoker6<true, StorageType, void(T::*)(X1, X2, X3, X4, X5)> {
+  static void DoInvoke(InvokerStorageBase* base) {
+    StorageType* invoker = static_cast<StorageType*>(base);
+    if (!invoker->p1_.get()) {
+      return;
+    }
+    (invoker->p1_->*invoker->f_)(Unwrap(invoker->p2_), Unwrap(invoker->p3_),
+        Unwrap(invoker->p4_), Unwrap(invoker->p5_), Unwrap(invoker->p6_));
+  }
+};
 
 // InvokerStorageN<>
 //
@@ -1014,8 +1384,9 @@ class InvokerStorage0 : public InvokerStorageBase {
  public:
   typedef InvokerStorage0 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker0<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker0<false, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
 
 
 
@@ -1033,8 +1404,12 @@ class InvokerStorage1 : public InvokerStorageBase {
  public:
   typedef InvokerStorage1 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker1<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker1<IsWeakMethod<IsMethod::value, P1>::value, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
+  COMPILE_ASSERT(!(IsWeakMethod<IsMethod::value, P1>::value) ||
+                 is_void<typename TargetTraits::Return>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
 
   // For methods, we need to be careful for parameter 1.  We skip the
   // scoped_refptr check because the binder itself takes care of this. We also
@@ -1073,8 +1448,12 @@ class InvokerStorage2 : public InvokerStorageBase {
  public:
   typedef InvokerStorage2 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker2<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker2<IsWeakMethod<IsMethod::value, P1>::value, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
+  COMPILE_ASSERT(!(IsWeakMethod<IsMethod::value, P1>::value) ||
+                 is_void<typename TargetTraits::Return>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
 
   // For methods, we need to be careful for parameter 1.  We skip the
   // scoped_refptr check because the binder itself takes care of this. We also
@@ -1118,8 +1497,12 @@ class InvokerStorage3 : public InvokerStorageBase {
  public:
   typedef InvokerStorage3 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker3<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker3<IsWeakMethod<IsMethod::value, P1>::value, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
+  COMPILE_ASSERT(!(IsWeakMethod<IsMethod::value, P1>::value) ||
+                 is_void<typename TargetTraits::Return>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
 
   // For methods, we need to be careful for parameter 1.  We skip the
   // scoped_refptr check because the binder itself takes care of this. We also
@@ -1168,8 +1551,12 @@ class InvokerStorage4 : public InvokerStorageBase {
  public:
   typedef InvokerStorage4 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker4<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker4<IsWeakMethod<IsMethod::value, P1>::value, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
+  COMPILE_ASSERT(!(IsWeakMethod<IsMethod::value, P1>::value) ||
+                 is_void<typename TargetTraits::Return>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
 
   // For methods, we need to be careful for parameter 1.  We skip the
   // scoped_refptr check because the binder itself takes care of this. We also
@@ -1224,8 +1611,12 @@ class InvokerStorage5 : public InvokerStorageBase {
  public:
   typedef InvokerStorage5 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker5<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker5<IsWeakMethod<IsMethod::value, P1>::value, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
+  COMPILE_ASSERT(!(IsWeakMethod<IsMethod::value, P1>::value) ||
+                 is_void<typename TargetTraits::Return>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
 
   // For methods, we need to be careful for parameter 1.  We skip the
   // scoped_refptr check because the binder itself takes care of this. We also
@@ -1286,8 +1677,12 @@ class InvokerStorage6 : public InvokerStorageBase {
  public:
   typedef InvokerStorage6 StorageType;
   typedef FunctionTraits<Sig> TargetTraits;
-  typedef Invoker6<StorageType, typename TargetTraits::NormalizedSig> Invoker;
   typedef typename TargetTraits::IsMethod IsMethod;
+  typedef Invoker6<IsWeakMethod<IsMethod::value, P1>::value, StorageType,
+                   typename TargetTraits::NormalizedSig> Invoker;
+  COMPILE_ASSERT(!(IsWeakMethod<IsMethod::value, P1>::value) ||
+                 is_void<typename TargetTraits::Return>::value,
+                 weak_ptrs_can_only_bind_to_methods_without_return_values);
 
   // For methods, we need to be careful for parameter 1.  We skip the
   // scoped_refptr check because the binder itself takes care of this. We also