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

base/bind_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 
 #if defined(BASE_CALLBACK_H_)
 // We explicitly do not want to include callback.h so people are not tempted
 // to use bind.h in a headerfile for getting the Callback types.
 #error "base/bind.h should avoid pulling in callback.h by default."
@@ skipping 165 matching lines @@
 }
 
 int UnwrapNoRefParentConstRef(const NoRefParent& p) {
   return p.value;
 }
 
 void RefArgSet(int &n) {
   n = 2;
 }
 
+int FunctionWithWeakFirstParam(WeakPtr<NoRef> o, int n) {
+  return n;
+}
+
 // Only useful in no-compile tests.
 int UnwrapNoRefParentRef(Parent& p) {
   return p.value;
 }
 
 class BindTest : public ::testing::Test {
  public:
   BindTest() {
     const_has_ref_ptr_ = &has_ref_;
     const_no_ref_ptr_ = &no_ref_;
@@ skipping 248 matching lines @@
   // inheritance.
   EXPECT_TRUE(internal::SupportsAddRefAndRelease<StrictMock<HasRef> >::value);
   EXPECT_FALSE(internal::SupportsAddRefAndRelease<StrictMock<NoRef> >::value);
 
   // This matters because the implementation creates a dummy class that
   // inherits from the template type.
   EXPECT_TRUE(internal::SupportsAddRefAndRelease<HasRefPrivateDtor>::value);
 }
 
 // Unretained() wrapper support.
-//   - Method bound to Unretained() non-object.
+//   - Method bound to Unretained() non-const object.
 //   - Const method bound to Unretained() non-const object.
 //   - Const method bound to Unretained() const object.
 TEST_F(BindTest, Unretained) {
   EXPECT_CALL(no_ref_, VoidMethod0());
   EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
 
   Callback<void(void)> method_cb =
       Bind(&NoRef::VoidMethod0, Unretained(&no_ref_));
   method_cb.Run();
 
   Callback<void(void)> const_method_cb =
       Bind(&NoRef::VoidConstMethod0, Unretained(&no_ref_));
   const_method_cb.Run();
 
   Callback<void(void)> const_method_const_ptr_cb =
       Bind(&NoRef::VoidConstMethod0, Unretained(const_no_ref_ptr_));
   const_method_const_ptr_cb.Run();
 }
 
+// WeakPtr() support.
+//   - Method bound to WeakPtr<> to non-const object.
+//   - Const method bound to WeakPtr<> to non-const object.
+//   - Const method bound to WeakPtr<> to const object.
+//   - Normal Function with WeakPtr<> as P1 can have return type and is
+//     not canceled.
+TEST_F(BindTest, WeakPtr) {
+  EXPECT_CALL(no_ref_, VoidMethod0());
+  EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
+
+  WeakPtrFactory<NoRef> weak_factory(&no_ref_);
+  WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
+
+  Callback<void(void)> method_cb =
+      Bind(&NoRef::VoidMethod0, weak_factory.GetWeakPtr());
+  method_cb.Run();
+
+  Callback<void(void)> const_method_cb =
+      Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
+  const_method_cb.Run();
+
+  Callback<void(void)> const_method_const_ptr_cb =
+      Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
+  const_method_const_ptr_cb.Run();
+
+  Callback<int(int)> normal_func_cb =
+      Bind(&FunctionWithWeakFirstParam, weak_factory.GetWeakPtr());
+  EXPECT_EQ(1, normal_func_cb.Run(1));
+
+  weak_factory.InvalidateWeakPtrs();
+  const_weak_factory.InvalidateWeakPtrs();
+
+  method_cb.Run();
+  const_method_cb.Run();
+  const_method_const_ptr_cb.Run();
+
+  // Still runs even after the pointers are invalidated.
+  EXPECT_EQ(2, normal_func_cb.Run(2));
+}
+
 // ConstRef() wrapper support.
 //   - Binding w/o ConstRef takes a copy.
 //   - Binding a ConstRef takes a reference.
 //   - Binding ConstRef to a function ConstRef does not copy on invoke.
 TEST_F(BindTest, ConstRef) {
   int n = 1;
 
   Callback<int(void)> copy_cb = Bind(&Identity, n);
   Callback<int(void)> const_ref_cb = Bind(&Identity, ConstRef(n));
   EXPECT_EQ(n, copy_cb.Run());
@@ skipping 136 matching lines @@
   // HasRef p[10];
   // Callback<void(void)> method_bound_to_array_cb =
   //     Bind(&HasRef::VoidConstMethod0, p);
   // method_bound_to_array_cb.Run();
 
   // - Refcounted types should not be bound as a raw pointer.
   // HasRef for_raw_ptr;
   // Callback<void(void)> ref_count_as_raw_ptr =
   //     Bind(&VoidPolymorphic1<HasRef*>, &for_raw_ptr);
 
+  // - WeakPtrs cannot be bound to methods with return types.
+  // HasRef for_raw_ptr;
+  // WeakPtrFactory<NoRef> weak_factory(&no_ref_);
+  // Callback<int(void)> weak_ptr_with_non_void_return_type =
+  //     Bind(&NoRef::IntMethod0, weak_factory.GetWeakPtr());
+
 }
 
 #if defined(OS_WIN)
 int __fastcall FastCallFunc(int n) {
   return n;
 }
 
 int __stdcall StdCallFunc(int n) {
   return n;
 }
 
 // Windows specific calling convention support.
 //   - Can bind a __fastcall function.
 //   - Can bind a __stdcall function.
 TEST_F(BindTest, WindowsCallingConventions) {
   Callback<int(void)> fastcall_cb = Bind(&FastCallFunc, 1);
   EXPECT_EQ(1, fastcall_cb.Run());
 
   Callback<int(void)> stdcall_cb = Bind(&StdCallFunc, 2);
   EXPECT_EQ(2, stdcall_cb.Run());
 }
 #endif
 
 }  // namespace
 }  // namespace base