base/bind_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6
   7 #include "base/callback.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/weak_ptr.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using ::testing::Mock;
  15 using ::testing::Return;
  16 using ::testing::StrictMock;
  17
  18 namespace base {
  19 namespace {
  20
  21 class IncompleteType;
  22
  23 class NoRef {
  24  public:
  25   NoRef() {}
  26
  27   MOCK_METHOD0(VoidMethod0, void(void));
  28   MOCK_CONST_METHOD0(VoidConstMethod0, void(void));
  29
  30   MOCK_METHOD0(IntMethod0, int(void));
  31   MOCK_CONST_METHOD0(IntConstMethod0, int(void));
  32
  33  private:
  34   // Particularly important in this test to ensure no copies are made.
  35   DISALLOW_COPY_AND_ASSIGN(NoRef);
  36 };
  37
  38 class HasRef : public NoRef {
  39  public:
  40   HasRef() {}
  41
  42   MOCK_CONST_METHOD0(AddRef, void(void));
  43   MOCK_CONST_METHOD0(Release, bool(void));
  44
  45  private:
  46   // Particularly important in this test to ensure no copies are made.
  47   DISALLOW_COPY_AND_ASSIGN(HasRef);
  48 };
  49
  50 class HasRefPrivateDtor : public HasRef {
  51  private:
  52   ~HasRefPrivateDtor() {}
  53 };
  54
  55 static const int kParentValue = 1;
  56 static const int kChildValue = 2;
  57
  58 class Parent {
  59  public:
  60   void AddRef(void) const {}
  61   void Release(void) const {}
  62   virtual void VirtualSet() { value = kParentValue; }
  63   void NonVirtualSet() { value = kParentValue; }
  64   int value;
  65 };
  66
  67 class Child : public Parent {
  68  public:
  69   virtual void VirtualSet() OVERRIDE { value = kChildValue; }
  70   void NonVirtualSet() { value = kChildValue; }
  71 };
  72
  73 class NoRefParent {
  74  public:
  75   virtual void VirtualSet() { value = kParentValue; }
  76   void NonVirtualSet() { value = kParentValue; }
  77   int value;
  78 };
  79
  80 class NoRefChild : public NoRefParent {
  81   virtual void VirtualSet() OVERRIDE { value = kChildValue; }
  82   void NonVirtualSet() { value = kChildValue; }
  83 };
  84
  85 // Used for probing the number of copies that occur if a type must be coerced
  86 // during argument forwarding in the Run() methods.
  87 struct DerivedCopyCounter {
  88   DerivedCopyCounter(int* copies, int* assigns)
  89       : copies_(copies), assigns_(assigns) {
  90   }
  91   int* copies_;
  92   int* assigns_;
  93 };
  94
  95 // Used for probing the number of copies in an argument.
  96 class CopyCounter {
  97  public:
  98   CopyCounter(int* copies, int* assigns)
  99       : copies_(copies), assigns_(assigns) {
 100   }
 101
 102   CopyCounter(const CopyCounter& other)
 103       : copies_(other.copies_),
 104         assigns_(other.assigns_) {
 105     (*copies_)++;
 106   }
 107
 108   // Probing for copies from coercion.
 109   explicit CopyCounter(const DerivedCopyCounter& other)
 110       : copies_(other.copies_),
 111         assigns_(other.assigns_) {
 112     (*copies_)++;
 113   }
 114
 115   const CopyCounter& operator=(const CopyCounter& rhs) {
 116     copies_ = rhs.copies_;
 117     assigns_ = rhs.assigns_;
 118
 119     if (assigns_) {
 120       (*assigns_)++;
 121     }
 122
 123     return *this;
 124   }
 125
 126   int copies() const {
 127     return *copies_;
 128   }
 129
 130  private:
 131   int* copies_;
 132   int* assigns_;
 133 };
 134
 135 class DeleteCounter {
 136  public:
 137   explicit DeleteCounter(int* deletes)
 138       : deletes_(deletes) {
 139   }
 140
 141   ~DeleteCounter() {
 142     (*deletes_)++;
 143   }
 144
 145   void VoidMethod0() {}
 146
 147  private:
 148   int* deletes_;
 149 };
 150
 151 template <typename T>
 152 T PassThru(T scoper) {
 153   return scoper.Pass();
 154 }
 155
 156 // Some test functions that we can Bind to.
 157 template <typename T>
 158 T PolymorphicIdentity(T t) {
 159   return t;
 160 }
 161
 162 template <typename T>
 163 void VoidPolymorphic1(T t) {
 164 }
 165
 166 int Identity(int n) {
 167   return n;
 168 }
 169
 170 int ArrayGet(const int array[], int n) {
 171   return array[n];
 172 }
 173
 174 int Sum(int a, int b, int c, int d, int e, int f) {
 175   return a + b + c + d + e + f;
 176 }
 177
 178 const char* CStringIdentity(const char* s) {
 179   return s;
 180 }
 181
 182 int GetCopies(const CopyCounter& counter) {
 183   return counter.copies();
 184 }
 185
 186 int UnwrapNoRefParent(NoRefParent p) {
 187   return p.value;
 188 }
 189
 190 int UnwrapNoRefParentPtr(NoRefParent* p) {
 191   return p->value;
 192 }
 193
 194 int UnwrapNoRefParentConstRef(const NoRefParent& p) {
 195   return p.value;
 196 }
 197
 198 void RefArgSet(int &n) {
 199   n = 2;
 200 }
 201
 202 void PtrArgSet(int *n) {
 203   *n = 2;
 204 }
 205
 206 int FunctionWithWeakFirstParam(WeakPtr<NoRef> o, int n) {
 207   return n;
 208 }
 209
 210 int FunctionWithScopedRefptrFirstParam(const scoped_refptr<HasRef>& o, int n) {
 211   return n;
 212 }
 213
 214 void TakesACallback(const Closure& callback) {
 215   callback.Run();
 216 }
 217
 218 class BindTest : public ::testing::Test {
 219  public:
 220   BindTest() {
 221     const_has_ref_ptr_ = &has_ref_;
 222     const_no_ref_ptr_ = &no_ref_;
 223     static_func_mock_ptr = &static_func_mock_;
 224   }
 225
 226   virtual ~BindTest() {
 227   }
 228
 229   static void VoidFunc0(void) {
 230     static_func_mock_ptr->VoidMethod0();
 231   }
 232
 233   static int IntFunc0(void) { return static_func_mock_ptr->IntMethod0(); }
 234
 235  protected:
 236   StrictMock<NoRef> no_ref_;
 237   StrictMock<HasRef> has_ref_;
 238   const HasRef* const_has_ref_ptr_;
 239   const NoRef* const_no_ref_ptr_;
 240   StrictMock<NoRef> static_func_mock_;
 241
 242   // Used by the static functions to perform expectations.
 243   static StrictMock<NoRef>* static_func_mock_ptr;
 244
 245  private:
 246   DISALLOW_COPY_AND_ASSIGN(BindTest);
 247 };
 248
 249 StrictMock<NoRef>* BindTest::static_func_mock_ptr;
 250
 251 // Sanity check that we can instantiate a callback for each arity.
 252 TEST_F(BindTest, ArityTest) {
 253   Callback<int(void)> c0 = Bind(&Sum, 32, 16, 8, 4, 2, 1);
 254   EXPECT_EQ(63, c0.Run());
 255
 256   Callback<int(int)> c1 = Bind(&Sum, 32, 16, 8, 4, 2);
 257   EXPECT_EQ(75, c1.Run(13));
 258
 259   Callback<int(int,int)> c2 = Bind(&Sum, 32, 16, 8, 4);
 260   EXPECT_EQ(85, c2.Run(13, 12));
 261
 262   Callback<int(int,int,int)> c3 = Bind(&Sum, 32, 16, 8);
 263   EXPECT_EQ(92, c3.Run(13, 12, 11));
 264
 265   Callback<int(int,int,int,int)> c4 = Bind(&Sum, 32, 16);
 266   EXPECT_EQ(94, c4.Run(13, 12, 11, 10));
 267
 268   Callback<int(int,int,int,int,int)> c5 = Bind(&Sum, 32);
 269   EXPECT_EQ(87, c5.Run(13, 12, 11, 10, 9));
 270
 271   Callback<int(int,int,int,int,int,int)> c6 = Bind(&Sum);
 272   EXPECT_EQ(69, c6.Run(13, 12, 11, 10, 9, 14));
 273 }
 274
 275 // Test the Currying ability of the Callback system.
 276 TEST_F(BindTest, CurryingTest) {
 277   Callback<int(int,int,int,int,int,int)> c6 = Bind(&Sum);
 278   EXPECT_EQ(69, c6.Run(13, 12, 11, 10, 9, 14));
 279
 280   Callback<int(int,int,int,int,int)> c5 = Bind(c6, 32);
 281   EXPECT_EQ(87, c5.Run(13, 12, 11, 10, 9));
 282
 283   Callback<int(int,int,int,int)> c4 = Bind(c5, 16);
 284   EXPECT_EQ(94, c4.Run(13, 12, 11, 10));
 285
 286   Callback<int(int,int,int)> c3 = Bind(c4, 8);
 287   EXPECT_EQ(92, c3.Run(13, 12, 11));
 288
 289   Callback<int(int,int)> c2 = Bind(c3, 4);
 290   EXPECT_EQ(85, c2.Run(13, 12));
 291
 292   Callback<int(int)> c1 = Bind(c2, 2);
 293   EXPECT_EQ(75, c1.Run(13));
 294
 295   Callback<int(void)> c0 = Bind(c1, 1);
 296   EXPECT_EQ(63, c0.Run());
 297 }
 298
 299 // Test that currying the rvalue result of another Bind() works correctly.
 300 //   - rvalue should be usable as argument to Bind().
 301 //   - multiple runs of resulting Callback remain valid.
 302 TEST_F(BindTest, CurryingRvalueResultOfBind) {
 303   int n = 0;
 304   Closure cb = base::Bind(&TakesACallback, base::Bind(&PtrArgSet, &n));
 305
 306   // If we implement Bind() such that the return value has auto_ptr-like
 307   // semantics, the second call here will fail because ownership of
 308   // the internal BindState<> would have been transfered to a *temporary*
 309   // constructon of a Callback object on the first call.
 310   cb.Run();
 311   EXPECT_EQ(2, n);
 312
 313   n = 0;
 314   cb.Run();
 315   EXPECT_EQ(2, n);
 316 }
 317
 318 // Function type support.
 319 //   - Normal function.
 320 //   - Normal function bound with non-refcounted first argument.
 321 //   - Method bound to non-const object.
 322 //   - Method bound to scoped_refptr.
 323 //   - Const method bound to non-const object.
 324 //   - Const method bound to const object.
 325 //   - Derived classes can be used with pointers to non-virtual base functions.
 326 //   - Derived classes can be used with pointers to virtual base functions (and
 327 //     preserve virtual dispatch).
 328 TEST_F(BindTest, FunctionTypeSupport) {
 329   EXPECT_CALL(static_func_mock_, VoidMethod0());
 330   EXPECT_CALL(has_ref_, AddRef()).Times(5);
 331   EXPECT_CALL(has_ref_, Release()).Times(5);
 332   EXPECT_CALL(has_ref_, VoidMethod0()).Times(2);
 333   EXPECT_CALL(has_ref_, VoidConstMethod0()).Times(2);
 334
 335   Closure normal_cb = Bind(&VoidFunc0);
 336   Callback<NoRef*(void)> normal_non_refcounted_cb =
 337       Bind(&PolymorphicIdentity<NoRef*>, &no_ref_);
 338   normal_cb.Run();
 339   EXPECT_EQ(&no_ref_, normal_non_refcounted_cb.Run());
 340
 341   Closure method_cb = Bind(&HasRef::VoidMethod0, &has_ref_);
 342   Closure method_refptr_cb = Bind(&HasRef::VoidMethod0,
 343                                   make_scoped_refptr(&has_ref_));
 344   Closure const_method_nonconst_obj_cb = Bind(&HasRef::VoidConstMethod0,
 345                                               &has_ref_);
 346   Closure const_method_const_obj_cb = Bind(&HasRef::VoidConstMethod0,
 347                                            const_has_ref_ptr_);
 348   method_cb.Run();
 349   method_refptr_cb.Run();
 350   const_method_nonconst_obj_cb.Run();
 351   const_method_const_obj_cb.Run();
 352
 353   Child child;
 354   child.value = 0;
 355   Closure virtual_set_cb = Bind(&Parent::VirtualSet, &child);
 356   virtual_set_cb.Run();
 357   EXPECT_EQ(kChildValue, child.value);
 358
 359   child.value = 0;
 360   Closure non_virtual_set_cb = Bind(&Parent::NonVirtualSet, &child);
 361   non_virtual_set_cb.Run();
 362   EXPECT_EQ(kParentValue, child.value);
 363 }
 364
 365 // Return value support.
 366 //   - Function with return value.
 367 //   - Method with return value.
 368 //   - Const method with return value.
 369 TEST_F(BindTest, ReturnValues) {
 370   EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337));
 371   EXPECT_CALL(has_ref_, AddRef()).Times(3);
 372   EXPECT_CALL(has_ref_, Release()).Times(3);
 373   EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(31337));
 374   EXPECT_CALL(has_ref_, IntConstMethod0())
 375       .WillOnce(Return(41337))
 376       .WillOnce(Return(51337));
 377
 378   Callback<int(void)> normal_cb = Bind(&IntFunc0);
 379   Callback<int(void)> method_cb = Bind(&HasRef::IntMethod0, &has_ref_);
 380   Callback<int(void)> const_method_nonconst_obj_cb =
 381       Bind(&HasRef::IntConstMethod0, &has_ref_);
 382   Callback<int(void)> const_method_const_obj_cb =
 383       Bind(&HasRef::IntConstMethod0, const_has_ref_ptr_);
 384   EXPECT_EQ(1337, normal_cb.Run());
 385   EXPECT_EQ(31337, method_cb.Run());
 386   EXPECT_EQ(41337, const_method_nonconst_obj_cb.Run());
 387   EXPECT_EQ(51337, const_method_const_obj_cb.Run());
 388 }
 389
 390 // IgnoreResult adapter test.
 391 //   - Function with return value.
 392 //   - Method with return value.
 393 //   - Const Method with return.
 394 //   - Method with return value bound to WeakPtr<>.
 395 //   - Const Method with return bound to WeakPtr<>.
 396 TEST_F(BindTest, IgnoreResult) {
 397   EXPECT_CALL(static_func_mock_, IntMethod0()).WillOnce(Return(1337));
 398   EXPECT_CALL(has_ref_, AddRef()).Times(2);
 399   EXPECT_CALL(has_ref_, Release()).Times(2);
 400   EXPECT_CALL(has_ref_, IntMethod0()).WillOnce(Return(10));
 401   EXPECT_CALL(has_ref_, IntConstMethod0()).WillOnce(Return(11));
 402   EXPECT_CALL(no_ref_, IntMethod0()).WillOnce(Return(12));
 403   EXPECT_CALL(no_ref_, IntConstMethod0()).WillOnce(Return(13));
 404
 405   Closure normal_func_cb = Bind(IgnoreResult(&IntFunc0));
 406   normal_func_cb.Run();
 407
 408   Closure non_void_method_cb =
 409       Bind(IgnoreResult(&HasRef::IntMethod0), &has_ref_);
 410   non_void_method_cb.Run();
 411
 412   Closure non_void_const_method_cb =
 413       Bind(IgnoreResult(&HasRef::IntConstMethod0), &has_ref_);
 414   non_void_const_method_cb.Run();
 415
 416   WeakPtrFactory<NoRef> weak_factory(&no_ref_);
 417   WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
 418
 419   Closure non_void_weak_method_cb  =
 420       Bind(IgnoreResult(&NoRef::IntMethod0), weak_factory.GetWeakPtr());
 421   non_void_weak_method_cb.Run();
 422
 423   Closure non_void_weak_const_method_cb =
 424       Bind(IgnoreResult(&NoRef::IntConstMethod0), weak_factory.GetWeakPtr());
 425   non_void_weak_const_method_cb.Run();
 426
 427   weak_factory.InvalidateWeakPtrs();
 428   non_void_weak_const_method_cb.Run();
 429   non_void_weak_method_cb.Run();
 430 }
 431
 432 // Argument binding tests.
 433 //   - Argument binding to primitive.
 434 //   - Argument binding to primitive pointer.
 435 //   - Argument binding to a literal integer.
 436 //   - Argument binding to a literal string.
 437 //   - Argument binding with template function.
 438 //   - Argument binding to an object.
 439 //   - Argument binding to pointer to incomplete type.
 440 //   - Argument gets type converted.
 441 //   - Pointer argument gets converted.
 442 //   - Const Reference forces conversion.
 443 TEST_F(BindTest, ArgumentBinding) {
 444   int n = 2;
 445
 446   Callback<int(void)> bind_primitive_cb = Bind(&Identity, n);
 447   EXPECT_EQ(n, bind_primitive_cb.Run());
 448
 449   Callback<int*(void)> bind_primitive_pointer_cb =
 450       Bind(&PolymorphicIdentity<int*>, &n);
 451   EXPECT_EQ(&n, bind_primitive_pointer_cb.Run());
 452
 453   Callback<int(void)> bind_int_literal_cb = Bind(&Identity, 3);
 454   EXPECT_EQ(3, bind_int_literal_cb.Run());
 455
 456   Callback<const char*(void)> bind_string_literal_cb =
 457       Bind(&CStringIdentity, "hi");
 458   EXPECT_STREQ("hi", bind_string_literal_cb.Run());
 459
 460   Callback<int(void)> bind_template_function_cb =
 461       Bind(&PolymorphicIdentity<int>, 4);
 462   EXPECT_EQ(4, bind_template_function_cb.Run());
 463
 464   NoRefParent p;
 465   p.value = 5;
 466   Callback<int(void)> bind_object_cb = Bind(&UnwrapNoRefParent, p);
 467   EXPECT_EQ(5, bind_object_cb.Run());
 468
 469   IncompleteType* incomplete_ptr = reinterpret_cast<IncompleteType*>(123);
 470   Callback<IncompleteType*(void)> bind_incomplete_ptr_cb =
 471       Bind(&PolymorphicIdentity<IncompleteType*>, incomplete_ptr);
 472   EXPECT_EQ(incomplete_ptr, bind_incomplete_ptr_cb.Run());
 473
 474   NoRefChild c;
 475   c.value = 6;
 476   Callback<int(void)> bind_promotes_cb = Bind(&UnwrapNoRefParent, c);
 477   EXPECT_EQ(6, bind_promotes_cb.Run());
 478
 479   c.value = 7;
 480   Callback<int(void)> bind_pointer_promotes_cb =
 481       Bind(&UnwrapNoRefParentPtr, &c);
 482   EXPECT_EQ(7, bind_pointer_promotes_cb.Run());
 483
 484   c.value = 8;
 485   Callback<int(void)> bind_const_reference_promotes_cb =
 486       Bind(&UnwrapNoRefParentConstRef, c);
 487   EXPECT_EQ(8, bind_const_reference_promotes_cb.Run());
 488 }
 489
 490 // Unbound argument type support tests.
 491 //   - Unbound value.
 492 //   - Unbound pointer.
 493 //   - Unbound reference.
 494 //   - Unbound const reference.
 495 //   - Unbound unsized array.
 496 //   - Unbound sized array.
 497 //   - Unbound array-of-arrays.
 498 TEST_F(BindTest, UnboundArgumentTypeSupport) {
 499   Callback<void(int)> unbound_value_cb = Bind(&VoidPolymorphic1<int>);
 500   Callback<void(int*)> unbound_pointer_cb = Bind(&VoidPolymorphic1<int*>);
 501   Callback<void(int&)> unbound_ref_cb = Bind(&VoidPolymorphic1<int&>);
 502   Callback<void(const int&)> unbound_const_ref_cb =
 503       Bind(&VoidPolymorphic1<const int&>);
 504   Callback<void(int[])> unbound_unsized_array_cb =
 505       Bind(&VoidPolymorphic1<int[]>);
 506   Callback<void(int[2])> unbound_sized_array_cb =
 507       Bind(&VoidPolymorphic1<int[2]>);
 508   Callback<void(int[][2])> unbound_array_of_arrays_cb =
 509       Bind(&VoidPolymorphic1<int[][2]>);
 510 }
 511
 512 // Function with unbound reference parameter.
 513 //   - Original parameter is modified by callback.
 514 TEST_F(BindTest, UnboundReferenceSupport) {
 515   int n = 0;
 516   Callback<void(int&)> unbound_ref_cb = Bind(&RefArgSet);
 517   unbound_ref_cb.Run(n);
 518   EXPECT_EQ(2, n);
 519 }
 520
 521 // Functions that take reference parameters.
 522 //  - Forced reference parameter type still stores a copy.
 523 //  - Forced const reference parameter type still stores a copy.
 524 TEST_F(BindTest, ReferenceArgumentBinding) {
 525   int n = 1;
 526   int& ref_n = n;
 527   const int& const_ref_n = n;
 528
 529   Callback<int(void)> ref_copies_cb = Bind(&Identity, ref_n);
 530   EXPECT_EQ(n, ref_copies_cb.Run());
 531   n++;
 532   EXPECT_EQ(n - 1, ref_copies_cb.Run());
 533
 534   Callback<int(void)> const_ref_copies_cb = Bind(&Identity, const_ref_n);
 535   EXPECT_EQ(n, const_ref_copies_cb.Run());
 536   n++;
 537   EXPECT_EQ(n - 1, const_ref_copies_cb.Run());
 538 }
 539
 540 // Check that we can pass in arrays and have them be stored as a pointer.
 541 //  - Array of values stores a pointer.
 542 //  - Array of const values stores a pointer.
 543 TEST_F(BindTest, ArrayArgumentBinding) {
 544   int array[4] = {1, 1, 1, 1};
 545   const int (*const_array_ptr)[4] = &array;
 546
 547   Callback<int(void)> array_cb = Bind(&ArrayGet, array, 1);
 548   EXPECT_EQ(1, array_cb.Run());
 549
 550   Callback<int(void)> const_array_cb = Bind(&ArrayGet, *const_array_ptr, 1);
 551   EXPECT_EQ(1, const_array_cb.Run());
 552
 553   array[1] = 3;
 554   EXPECT_EQ(3, array_cb.Run());
 555   EXPECT_EQ(3, const_array_cb.Run());
 556 }
 557
 558 // Verify SupportsAddRefAndRelease correctly introspects the class type for
 559 // AddRef() and Release().
 560 //  - Class with AddRef() and Release()
 561 //  - Class without AddRef() and Release()
 562 //  - Derived Class with AddRef() and Release()
 563 //  - Derived Class without AddRef() and Release()
 564 //  - Derived Class with AddRef() and Release() and a private destructor.
 565 TEST_F(BindTest, SupportsAddRefAndRelease) {
 566   EXPECT_TRUE(internal::SupportsAddRefAndRelease<HasRef>::value);
 567   EXPECT_FALSE(internal::SupportsAddRefAndRelease<NoRef>::value);
 568
 569   // StrictMock<T> is a derived class of T.  So, we use StrictMock<HasRef> and
 570   // StrictMock<NoRef> to test that SupportsAddRefAndRelease works over
 571   // inheritance.
 572   EXPECT_TRUE(internal::SupportsAddRefAndRelease<StrictMock<HasRef> >::value);
 573   EXPECT_FALSE(internal::SupportsAddRefAndRelease<StrictMock<NoRef> >::value);
 574
 575   // This matters because the implementation creates a dummy class that
 576   // inherits from the template type.
 577   EXPECT_TRUE(internal::SupportsAddRefAndRelease<HasRefPrivateDtor>::value);
 578 }
 579
 580 // Unretained() wrapper support.
 581 //   - Method bound to Unretained() non-const object.
 582 //   - Const method bound to Unretained() non-const object.
 583 //   - Const method bound to Unretained() const object.
 584 TEST_F(BindTest, Unretained) {
 585   EXPECT_CALL(no_ref_, VoidMethod0());
 586   EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
 587
 588   Callback<void(void)> method_cb =
 589       Bind(&NoRef::VoidMethod0, Unretained(&no_ref_));
 590   method_cb.Run();
 591
 592   Callback<void(void)> const_method_cb =
 593       Bind(&NoRef::VoidConstMethod0, Unretained(&no_ref_));
 594   const_method_cb.Run();
 595
 596   Callback<void(void)> const_method_const_ptr_cb =
 597       Bind(&NoRef::VoidConstMethod0, Unretained(const_no_ref_ptr_));
 598   const_method_const_ptr_cb.Run();
 599 }
 600
 601 // WeakPtr() support.
 602 //   - Method bound to WeakPtr<> to non-const object.
 603 //   - Const method bound to WeakPtr<> to non-const object.
 604 //   - Const method bound to WeakPtr<> to const object.
 605 //   - Normal Function with WeakPtr<> as P1 can have return type and is
 606 //     not canceled.
 607 TEST_F(BindTest, WeakPtr) {
 608   EXPECT_CALL(no_ref_, VoidMethod0());
 609   EXPECT_CALL(no_ref_, VoidConstMethod0()).Times(2);
 610
 611   WeakPtrFactory<NoRef> weak_factory(&no_ref_);
 612   WeakPtrFactory<const NoRef> const_weak_factory(const_no_ref_ptr_);
 613
 614   Closure method_cb =
 615       Bind(&NoRef::VoidMethod0, weak_factory.GetWeakPtr());
 616   method_cb.Run();
 617
 618   Closure const_method_cb =
 619       Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
 620   const_method_cb.Run();
 621
 622   Closure const_method_const_ptr_cb =
 623       Bind(&NoRef::VoidConstMethod0, const_weak_factory.GetWeakPtr());
 624   const_method_const_ptr_cb.Run();
 625
 626   Callback<int(int)> normal_func_cb =
 627       Bind(&FunctionWithWeakFirstParam, weak_factory.GetWeakPtr());
 628   EXPECT_EQ(1, normal_func_cb.Run(1));
 629
 630   weak_factory.InvalidateWeakPtrs();
 631   const_weak_factory.InvalidateWeakPtrs();
 632
 633   method_cb.Run();
 634   const_method_cb.Run();
 635   const_method_const_ptr_cb.Run();
 636
 637   // Still runs even after the pointers are invalidated.
 638   EXPECT_EQ(2, normal_func_cb.Run(2));
 639 }
 640
 641 // ConstRef() wrapper support.
 642 //   - Binding w/o ConstRef takes a copy.
 643 //   - Binding a ConstRef takes a reference.
 644 //   - Binding ConstRef to a function ConstRef does not copy on invoke.
 645 TEST_F(BindTest, ConstRef) {
 646   int n = 1;
 647
 648   Callback<int(void)> copy_cb = Bind(&Identity, n);
 649   Callback<int(void)> const_ref_cb = Bind(&Identity, ConstRef(n));
 650   EXPECT_EQ(n, copy_cb.Run());
 651   EXPECT_EQ(n, const_ref_cb.Run());
 652   n++;
 653   EXPECT_EQ(n - 1, copy_cb.Run());
 654   EXPECT_EQ(n, const_ref_cb.Run());
 655
 656   int copies = 0;
 657   int assigns = 0;
 658   CopyCounter counter(&copies, &assigns);
 659   Callback<int(void)> all_const_ref_cb =
 660       Bind(&GetCopies, ConstRef(counter));
 661   EXPECT_EQ(0, all_const_ref_cb.Run());
 662   EXPECT_EQ(0, copies);
 663   EXPECT_EQ(0, assigns);
 664 }
 665
 666 TEST_F(BindTest, ScopedRefptr) {
 667   // BUG: The scoped_refptr should cause the only AddRef()/Release() pair. But
 668   // due to a bug in base::Bind(), there's an extra call when invoking the
 669   // callback.
 670   // https://code.google.com/p/chromium/issues/detail?id=251937
 671   EXPECT_CALL(has_ref_, AddRef()).Times(2);
 672   EXPECT_CALL(has_ref_, Release()).Times(2);
 673
 674   const scoped_refptr<StrictMock<HasRef> > refptr(&has_ref_);
 675
 676   Callback<int(void)> scoped_refptr_const_ref_cb =
 677       Bind(&FunctionWithScopedRefptrFirstParam, base::ConstRef(refptr), 1);
 678   EXPECT_EQ(1, scoped_refptr_const_ref_cb.Run());
 679 }
 680
 681 // Test Owned() support.
 682 TEST_F(BindTest, Owned) {
 683   int deletes = 0;
 684   DeleteCounter* counter = new DeleteCounter(&deletes);
 685
 686   // If we don't capture, delete happens on Callback destruction/reset.
 687   // return the same value.
 688   Callback<DeleteCounter*(void)> no_capture_cb =
 689       Bind(&PolymorphicIdentity<DeleteCounter*>, Owned(counter));
 690   ASSERT_EQ(counter, no_capture_cb.Run());
 691   ASSERT_EQ(counter, no_capture_cb.Run());
 692   EXPECT_EQ(0, deletes);
 693   no_capture_cb.Reset();  // This should trigger a delete.
 694   EXPECT_EQ(1, deletes);
 695
 696   deletes = 0;
 697   counter = new DeleteCounter(&deletes);
 698   base::Closure own_object_cb =
 699       Bind(&DeleteCounter::VoidMethod0, Owned(counter));
 700   own_object_cb.Run();
 701   EXPECT_EQ(0, deletes);
 702   own_object_cb.Reset();
 703   EXPECT_EQ(1, deletes);
 704 }
 705
 706 // Passed() wrapper support.
 707 //   - Passed() can be constructed from a pointer to scoper.
 708 //   - Passed() can be constructed from a scoper rvalue.
 709 //   - Using Passed() gives Callback Ownership.
 710 //   - Ownership is transferred from Callback to callee on the first Run().
 711 //   - Callback supports unbound arguments.
 712 TEST_F(BindTest, ScopedPtr) {
 713   int deletes = 0;
 714
 715   // Tests the Passed() function's support for pointers.
 716   scoped_ptr<DeleteCounter> ptr(new DeleteCounter(&deletes));
 717   Callback<scoped_ptr<DeleteCounter>(void)> unused_callback =
 718       Bind(&PassThru<scoped_ptr<DeleteCounter> >, Passed(&ptr));
 719   EXPECT_FALSE(ptr.get());
 720   EXPECT_EQ(0, deletes);
 721
 722   // If we never invoke the Callback, it retains ownership and deletes.
 723   unused_callback.Reset();
 724   EXPECT_EQ(1, deletes);
 725
 726   // Tests the Passed() function's support for rvalues.
 727   deletes = 0;
 728   DeleteCounter* counter = new DeleteCounter(&deletes);
 729   Callback<scoped_ptr<DeleteCounter>(void)> callback =
 730       Bind(&PassThru<scoped_ptr<DeleteCounter> >,
 731            Passed(scoped_ptr<DeleteCounter>(counter)));
 732   EXPECT_FALSE(ptr.get());
 733   EXPECT_EQ(0, deletes);
 734
 735   // Check that ownership can be transferred back out.
 736   scoped_ptr<DeleteCounter> result = callback.Run();
 737   ASSERT_EQ(counter, result.get());
 738   EXPECT_EQ(0, deletes);
 739
 740   // Resetting does not delete since ownership was transferred.
 741   callback.Reset();
 742   EXPECT_EQ(0, deletes);
 743
 744   // Ensure that we actually did get ownership.
 745   result.reset();
 746   EXPECT_EQ(1, deletes);
 747
 748   // Test unbound argument forwarding.
 749   Callback<scoped_ptr<DeleteCounter>(scoped_ptr<DeleteCounter>)> cb_unbound =
 750       Bind(&PassThru<scoped_ptr<DeleteCounter> >);
 751   ptr.reset(new DeleteCounter(&deletes));
 752   cb_unbound.Run(ptr.Pass());
 753 }
 754
 755 // Argument Copy-constructor usage for non-reference parameters.
 756 //   - Bound arguments are only copied once.
 757 //   - Forwarded arguments are only copied once.
 758 //   - Forwarded arguments with coercions are only copied twice (once for the
 759 //     coercion, and one for the final dispatch).
 760 TEST_F(BindTest, ArgumentCopies) {
 761   int copies = 0;
 762   int assigns = 0;
 763
 764   CopyCounter counter(&copies, &assigns);
 765
 766   Callback<void(void)> copy_cb =
 767       Bind(&VoidPolymorphic1<CopyCounter>, counter);
 768   EXPECT_GE(1, copies);
 769   EXPECT_EQ(0, assigns);
 770
 771   copies = 0;
 772   assigns = 0;
 773   Callback<void(CopyCounter)> forward_cb =
 774       Bind(&VoidPolymorphic1<CopyCounter>);
 775   forward_cb.Run(counter);
 776   EXPECT_GE(1, copies);
 777   EXPECT_EQ(0, assigns);
 778
 779   copies = 0;
 780   assigns = 0;
 781   DerivedCopyCounter dervied(&copies, &assigns);
 782   Callback<void(CopyCounter)> coerce_cb =
 783       Bind(&VoidPolymorphic1<CopyCounter>);
 784   coerce_cb.Run(CopyCounter(dervied));
 785   EXPECT_GE(2, copies);
 786   EXPECT_EQ(0, assigns);
 787 }
 788
 789 // Callback construction and assignment tests.
 790 //   - Construction from an InvokerStorageHolder should not cause ref/deref.
 791 //   - Assignment from other callback should only cause one ref
 792 //
 793 // TODO(ajwong): Is there actually a way to test this?
 794
 795 #if defined(OS_WIN)
 796 int __fastcall FastCallFunc(int n) {
 797   return n;
 798 }
 799
 800 int __stdcall StdCallFunc(int n) {
 801   return n;
 802 }
 803
 804 // Windows specific calling convention support.
 805 //   - Can bind a __fastcall function.
 806 //   - Can bind a __stdcall function.
 807 TEST_F(BindTest, WindowsCallingConventions) {
 808   Callback<int(void)> fastcall_cb = Bind(&FastCallFunc, 1);
 809   EXPECT_EQ(1, fastcall_cb.Run());
 810
 811   Callback<int(void)> stdcall_cb = Bind(&StdCallFunc, 2);
 812   EXPECT_EQ(2, stdcall_cb.Run());
 813 }
 814 #endif
 815
 816 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) && GTEST_HAS_DEATH_TEST
 817
 818 // Test null callbacks cause a DCHECK.
 819 TEST(BindDeathTest, NullCallback) {
 820   base::Callback<void(int)> null_cb;
 821   ASSERT_TRUE(null_cb.is_null());
 822   EXPECT_DEATH(base::Bind(null_cb, 42), "");
 823 }
 824
 825 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
 826         //     GTEST_HAS_DEATH_TEST
 827
 828 }  // namespace
 829 }  // namespace base