Remove unbound base::Bind overload

base/bind_unittest.cc

 // Copyright (c) 2012 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"
 
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 144 matching lines @@
 T PassThru(T scoper) {
   return scoper;
 }
 
 // Some test functions that we can Bind to.
 template <typename T>
 T PolymorphicIdentity(T t) {
   return t;
 }
 
-template <typename T>
-void VoidPolymorphic1(T t) {
-}
+template <typename... Ts>
+struct VoidPolymorphic {

[danakj, 2015/12/16 20:00:41]

I'm not opposed, but why wrap the method in a struct here instead of just making
the function variadic?

[tzik, 2015/12/17 01:42:36]

This is for gcc compilation error.

Taking the function pointer of a function template with variadic template makes
its instantiation ambiguous, since we can give template parameters partially for
function template, unlike for class template.

E.g. For |foo| below, foo<int> may mean "Ts contains only one parameter, which
is int." 
or "Ts contains two parameters, the first one is int and the second should be
deduced from the function arguments".
I didn't look into the spec, but clang and cl take the first and gcc rejects to
select that.

template <typename... Ts>
void foo(Ts...) {}

foo<int>(); // Ts = <int>
foo<int>(1, 2); // Ts = <int, int>
&foo<int>; // ??

[danakj, 2015/12/18 00:08:58]

Ah, cool. Thanks!

+  static void Run(Ts... t) {}
+};
 
 int Identity(int n) {
   return n;
 }
 
 int ArrayGet(const int array[], int n) {
   return array[n];
 }
 
 int Sum(int a, int b, int c, int d, int e, int f) {
@@ skipping 314 matching lines @@
 
 // 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(int)> unbound_value_cb = Bind(&VoidPolymorphic<int>::Run);
+  Callback<void(int*)> unbound_pointer_cb = Bind(&VoidPolymorphic<int*>::Run);
+  Callback<void(int&)> unbound_ref_cb = Bind(&VoidPolymorphic<int&>::Run);
   Callback<void(const int&)> unbound_const_ref_cb =
-      Bind(&VoidPolymorphic1<const int&>);
+      Bind(&VoidPolymorphic<const int&>::Run);
   Callback<void(int[])> unbound_unsized_array_cb =
-      Bind(&VoidPolymorphic1<int[]>);
+      Bind(&VoidPolymorphic<int[]>::Run);
   Callback<void(int[2])> unbound_sized_array_cb =
-      Bind(&VoidPolymorphic1<int[2]>);
+      Bind(&VoidPolymorphic<int[2]>::Run);
   Callback<void(int[][2])> unbound_array_of_arrays_cb =
-      Bind(&VoidPolymorphic1<int[][2]>);
+      Bind(&VoidPolymorphic<int[][2]>::Run);
+
+  Callback<void(int&)> unbound_ref_with_bound_arg =
+      Bind(&VoidPolymorphic<int, int&>::Run, 1);
 }
 
 // Function with unbound reference parameter.
 //   - Original parameter 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);
 }
@@ skipping 280 matching lines @@
 //   - Forwarded arguments are only copied once.
 //   - Forwarded arguments with coercions are only copied twice (once for the
 //     coercion, and one for the final dispatch).
 TEST_F(BindTest, ArgumentCopies) {
   int copies = 0;
   int assigns = 0;
 
   CopyCounter counter(&copies, &assigns);
 
   Callback<void(void)> copy_cb =
-      Bind(&VoidPolymorphic1<CopyCounter>, counter);
+      Bind(&VoidPolymorphic<CopyCounter>::Run, counter);
   EXPECT_GE(1, copies);
   EXPECT_EQ(0, assigns);
 
   copies = 0;
   assigns = 0;
   Callback<void(CopyCounter)> forward_cb =
-      Bind(&VoidPolymorphic1<CopyCounter>);
+      Bind(&VoidPolymorphic<CopyCounter>::Run);
   forward_cb.Run(counter);
   EXPECT_GE(1, copies);
   EXPECT_EQ(0, assigns);
 
   copies = 0;
   assigns = 0;
   DerivedCopyCounter derived(&copies, &assigns);
   Callback<void(CopyCounter)> coerce_cb =
-      Bind(&VoidPolymorphic1<CopyCounter>);
+      Bind(&VoidPolymorphic<CopyCounter>::Run);
   coerce_cb.Run(CopyCounter(derived));
   EXPECT_GE(2, copies);
   EXPECT_EQ(0, assigns);
 }
 
 // Callback construction and assignment tests.
 //   - Construction from an InvokerStorageHolder should not cause ref/deref.
 //   - Assignment from other callback should only cause one ref
 //
 // TODO(ajwong): Is there actually a way to test this?
@@ skipping 26 matching lines @@
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DEATH(base::Bind(null_cb, 42), "");
 }
 
 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
         //     GTEST_HAS_DEATH_TEST
 
 }  // namespace
 }  // namespace base