Function-type templated CallbackRegistry

base/callback_registry_unittest.cc

Index: base/callback_registry_unittest.cc
diff --git a/base/callback_registry_unittest.cc b/base/callback_registry_unittest.cc
index 3459c073f1607079727953760feaa8b4a5a90ccc..a4455ab0caa10598f371c29c070957a7ced5ff01 100644
--- a/base/callback_registry_unittest.cc
+++ b/base/callback_registry_unittest.cc
@@ -18,7 +18,7 @@ class Listener {
   Listener() : total_(0), scaler_(1) {}
   explicit Listener(int scaler) : total_(0), scaler_(scaler) {}
   void IncrementTotal() { total_++; }
-  void IncrementByMultipleOfScaler(const int& x) { total_ += x * scaler_; }
+  void IncrementByMultipleOfScaler(int x) { total_ += x * scaler_; }
 
   int total_;
 
@@ -35,20 +35,20 @@ class Remover {
     removal_subscription_.reset();
   }
   void SetSubscriptionToRemove(
-      scoped_ptr<CallbackRegistry<void>::Subscription> sub) {
+      scoped_ptr<CallbackRegistry<void(void)>::Subscription> sub) {
     removal_subscription_ = sub.Pass();
   }
 
   int total_;
 
  private:
-  scoped_ptr<CallbackRegistry<void>::Subscription> removal_subscription_;
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> removal_subscription_;
   DISALLOW_COPY_AND_ASSIGN(Remover);
 };
 
 class Adder {
  public:
-  explicit Adder(CallbackRegistry<void>* cb_reg)
+  explicit Adder(CallbackRegistry<void(void)>* cb_reg)
       : added_(false),
         total_(0),
         cb_reg_(cb_reg) {}
@@ -65,20 +65,117 @@ class Adder {
   int total_;
 
  private:
-  CallbackRegistry<void>* cb_reg_;
-  scoped_ptr<CallbackRegistry<void>::Subscription> subscription_;
+  CallbackRegistry<void(void)>* cb_reg_;
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> subscription_;
   DISALLOW_COPY_AND_ASSIGN(Adder);
 };
 
+class Summer {
+ public:
+  Summer() : value_(0) {}
+
+  void AddOneParam(int a) { value_ = a; }
+  void AddTwoParam(int a, int b) { value_ = a + b; }
+  void AddThreeParam(int a, int b, int c) { value_ = a + b + c; }
+  void AddFourParam(int a, int b, int c, int d) { value_ = a + b + c + d; }
+  void AddFiveParam(int a, int b, int c, int d, int e) {
+    value_ = a + b + c + d + e;
+  }
+  void AddSixParam(int a, int b, int c, int d, int e , int f) {
+    value_ = a + b + c + d + e + f;
+  }
+
+  int value_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Summer);
+};
+
+
+// TODO(caitkp): Learn how non-compile unittests work. Put the following code
+// in there.
+/*class Foo {

[awong, 2013/09/20 20:06:25]

Look at base_unittests.nc and copy the pattern there.

Currently, it's disabled on trunk until someone has time to figure out how to
avoid it killing build times, but still better to have it than not.

+ public:
+  Foo() {}
+  ~Foo() {}
+};
+
+class ThisShouldNotWork {
+ public:
+  ThisShouldNotWork() {}
+
+  void GotAScopedFoo(scoped_ptr<Foo> f) { foo_ = f.Pass(); }
+
+  scoped_ptr<Foo> foo_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ThisShouldNotWork);
+};
+
+TEST(CallbackRegistryTest, ThisShouldNotWork) {
+  ThisShouldNotWork t;
+  CallbackRegistry<void(scoped_ptr<Foo>)> c1;
+  scoped_ptr<CallbackRegistry<void(scoped_ptr<Foo>)>::Subscription> sub =
+      c1.Add(Bind(&ThisShouldNotWork::GotAScopedFoo, Unretained(&t)));
+  c1.Notify(scoped_ptr<Foo>(new Foo()));
+}*/
+
+// Sanity check that we can instantiate a CallbackRegistry for each arity.
+TEST(CallbackRegistryTest, ArityTest) {
+  Summer s;
+
+  CallbackRegistry<void(int)> c1;
+  scoped_ptr<CallbackRegistry<void(int)>::Subscription> subscription1 =
+      c1.Add(Bind(&Summer::AddOneParam, Unretained(&s)));
+
+  c1.Notify(1);
+  EXPECT_EQ(1, s.value_);
+
+  CallbackRegistry<void(int, int)> c2;
+  scoped_ptr<CallbackRegistry<void(int, int)>::Subscription> subscription2 =
+      c2.Add(Bind(&Summer::AddTwoParam, Unretained(&s)));
+
+  c2.Notify(1, 2);
+  EXPECT_EQ(3, s.value_);
+
+  CallbackRegistry<void(int, int, int)> c3;
+  scoped_ptr<CallbackRegistry<void(int, int, int)>::Subscription>
+      subscription3 = c3.Add(Bind(&Summer::AddThreeParam, Unretained(&s)));
+
+  c3.Notify(1, 2, 3);
+  EXPECT_EQ(6, s.value_);
+
+  CallbackRegistry<void(int, int, int, int)> c4;
+  scoped_ptr<CallbackRegistry<void(int, int, int, int)>::Subscription>
+      subscription4 = c4.Add(Bind(&Summer::AddFourParam, Unretained(&s)));
+
+  c4.Notify(1, 2, 3, 4);
+  EXPECT_EQ(10, s.value_);
+
+  CallbackRegistry<void(int, int, int, int, int)> c5;
+  scoped_ptr<CallbackRegistry<void(int, int, int, int, int)>::Subscription>
+      subscription5 = c5.Add(Bind(&Summer::AddFiveParam, Unretained(&s)));
+
+  c5.Notify(1, 2, 3, 4, 5);
+  EXPECT_EQ(15, s.value_);
+
+  CallbackRegistry<void(int, int, int, int, int, int)> c6;
+  scoped_ptr<CallbackRegistry<void(int, int, int, int, int, int)>::Subscription>
+      subscription6 = c6.Add(Bind(&Summer::AddSixParam, Unretained(&s)));
+
+  c6.Notify(1, 2, 3, 4, 5, 6);
+  EXPECT_EQ(21, s.value_);
+}
+
 // Sanity check that closures added to the list will be run, and those removed
 // from the list will not be run.
 TEST(CallbackRegistryTest, BasicTest) {
-  CallbackRegistry<void> cb_reg;
+  CallbackRegistry<void(void)> cb_reg;
   Listener a, b, c;
 
-  scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> a_subscription =
       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
-  scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> b_subscription =
       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
 
   EXPECT_TRUE(a_subscription.get());
@@ -91,7 +188,7 @@ TEST(CallbackRegistryTest, BasicTest) {
 
   b_subscription.reset();
 
-  scoped_ptr<CallbackRegistry<void>::Subscription> c_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> c_subscription =
       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c)));
 
   cb_reg.Notify();
@@ -108,12 +205,12 @@ TEST(CallbackRegistryTest, BasicTest) {
 // Sanity check that callbacks with details added to the list will be run, with
 // the correct details, and those removed from the list will not be run.
 TEST(CallbackRegistryTest, BasicTestWithParams) {
-  CallbackRegistry<int> cb_reg;
+  CallbackRegistry<void(int)> cb_reg;
   Listener a(1), b(-1), c(1);
 
-  scoped_ptr<CallbackRegistry<int>::Subscription> a_subscription =
+  scoped_ptr<CallbackRegistry<void(int)>::Subscription> a_subscription =
       cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a)));
-  scoped_ptr<CallbackRegistry<int>::Subscription> b_subscription =
+  scoped_ptr<CallbackRegistry<void(int)>::Subscription> b_subscription =
       cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b)));
 
   EXPECT_TRUE(a_subscription.get());
@@ -126,7 +223,7 @@ TEST(CallbackRegistryTest, BasicTestWithParams) {
 
   b_subscription.reset();
 
-  scoped_ptr<CallbackRegistry<int>::Subscription> c_subscription =
+  scoped_ptr<CallbackRegistry<void(int)>::Subscription> c_subscription =
       cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c)));
 
   cb_reg.Notify(10);
@@ -143,23 +240,23 @@ TEST(CallbackRegistryTest, BasicTestWithParams) {
 // Test the a callback can remove itself or a different callback from the list
 // during iteration without invalidating the iterator.
 TEST(CallbackRegistryTest, RemoveCallbacksDuringIteration) {
-  CallbackRegistry<void> cb_reg;
+  CallbackRegistry<void(void)> cb_reg;
   Listener a, b;
   Remover remover_1, remover_2;
 
-  scoped_ptr<CallbackRegistry<void>::Subscription> remover_1_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> remover_1_sub =
       cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
           Unretained(&remover_1)));
-  scoped_ptr<CallbackRegistry<void>::Subscription> remover_2_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> remover_2_sub =
       cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
           Unretained(&remover_2)));
-  scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> a_subscription =
       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
-  scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> b_subscription =
       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
 
   // |remover_1| will remove itself.
-  remover_1.SetSubscriptionToRemove(remover_1_subscription.Pass());
+  remover_1.SetSubscriptionToRemove(remover_1_sub.Pass());
   // |remover_2| will remove a.
   remover_2.SetSubscriptionToRemove(a_subscription.Pass());
 
@@ -185,12 +282,12 @@ TEST(CallbackRegistryTest, RemoveCallbacksDuringIteration) {
 // without invalidating the iterator. The newly added callback should be run on
 // the current iteration as will all other callbacks in the list.
 TEST(CallbackRegistryTest, AddCallbacksDuringIteration) {
-  CallbackRegistry<void> cb_reg;
+  CallbackRegistry<void(void)> cb_reg;
   Adder a(&cb_reg);
   Listener b;
-  scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> a_subscription =
       cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a)));
-  scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription =
+  scoped_ptr<CallbackRegistry<void(void)>::Subscription> b_subscription =
       cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
 
   cb_reg.Notify();
@@ -207,7 +304,7 @@ TEST(CallbackRegistryTest, AddCallbacksDuringIteration) {
 
 // Sanity check: notifying an empty list is a no-op.
 TEST(CallbackRegistryTest, EmptyList) {
-  CallbackRegistry<void> cb_reg;
+  CallbackRegistry<void(void)> cb_reg;
 
   cb_reg.Notify();
 }