Callback support for unbound reference and array arguments.

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 156 matching lines @@
 }
 
 int UnwrapNoRefParentPtr(NoRefParent* p) {
   return p->value;
 }
 
 int UnwrapNoRefParentConstRef(const NoRefParent& p) {
   return p.value;
 }
 
+void RefArgSet(int &n) {
+  n = 2;
+}
+
 // 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 157 matching lines @@
   Callback<int(void)> bind_pointer_promotes_cb =
       Bind(&UnwrapNoRefParentPtr, &c);
   EXPECT_EQ(7, bind_pointer_promotes_cb.Run());
 
   c.value = 8;
   Callback<int(void)> bind_const_reference_promotes_cb =
       Bind(&UnwrapNoRefParentConstRef, c);
   EXPECT_EQ(8, bind_const_reference_promotes_cb.Run());
 }
 
+// Unbound argument type support tests.
+//   - Unbound value.
+//   - Unbound pointer.
+//   - Unbound reference.
+//   - Unbound const reference.
+//   - Unbound unsized array.
+//   - Unbound sized array.
+//   - Unbound array-of-arrays.
+TEST_F(BindTest, UnboundArgumentTypeSupport) {
+  Callback<void(int)> unbound_value_cb = Bind(&VoidPolymorphic1<int>);
+  Callback<void(int*)> unbound_pointer_cb = Bind(&VoidPolymorphic1<int*>);
+  Callback<void(int&)> unbound_ref_cb = Bind(&VoidPolymorphic1<int&>);
+  Callback<void(const int&)> unbound_const_ref_cb =
+      Bind(&VoidPolymorphic1<const int&>);
+  Callback<void(int[])> unbound_unsized_array_cb =
+      Bind(&VoidPolymorphic1<int[]>);
+  Callback<void(int[2])> unbound_sized_array_cb =
+      Bind(&VoidPolymorphic1<int[2]>);
+  Callback<void(int[][2])> unbound_array_of_arrays_cb =
+      Bind(&VoidPolymorphic1<int[][2]>);
+}
+
+// Function with unbound reference parameter.
+//   - Original paraemter is modified by callback.
+TEST_F(BindTest, UnboundReferenceSupport) {
+  int n = 0;
+  Callback<void(int&)> unbound_ref_cb = Bind(&RefArgSet);
+  unbound_ref_cb.Run(n);
+  EXPECT_EQ(2, n);
+}
+
 // Functions that take reference parameters.
 //  - Forced reference parameter type still stores a copy.
 //  - Forced const reference parameter type still stores a copy.
 TEST_F(BindTest, ReferenceArgumentBinding) {
   int n = 1;
   int& ref_n = n;
   const int& const_ref_n = n;
 
   Callback<int(void)> ref_copies_cb = Bind(&Identity, ref_n);
   EXPECT_EQ(n, ref_copies_cb.Run());
@@ skipping 199 matching lines @@
   // ref_cb.Run();
 
   // - A method should not be bindable with an array of objects.
   //
   // This is likely not wanted behavior. We specifically check for it though
   // because it is possible, depending on how you implement prebinding, to
   // implicitly convert an array type to a pointer type.
   //
   // HasRef p[10];
   // Callback<void(void)> method_bound_to_array_cb =
-  //    Bind(&HasRef::VoidConstMethod0, p);
+  //     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);
-  // ASSERT_EQ(&for_raw_ptr, ref_count_as_raw_ptr.Run());
 
 }
 
 #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