Unified callback system.

base/callback_unittest.cc

 // Copyright (c) 2009 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/callback.h"
+#include "base/prebind.h"
 #include "base/scoped_ptr.h"
+#include "base/logging.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class HelperObject {
  public:
   HelperObject() : next_number_(0) { }
   int GetNextNumber() { return ++next_number_; }
   void GetNextNumberArg(int* number) { *number = GetNextNumber(); }
@@ skipping 14 matching lines @@
   EXPECT_EQ(number, 1);
 }
 
 TEST(Callback, ReturnValue) {
   HelperObject obj;
   scoped_ptr<CallbackWithReturnValue<int>::Type> callback(
       NewCallbackWithReturnValue(&obj, &HelperObject::GetNextNumber));
 
   EXPECT_EQ(callback->Run(), 1);
 }
+
+void one_arg(int n) {
+  LOG(ERROR) << __func__ << " " << n;
+}
+
+void two_arg(int n, int m) {
+  LOG(ERROR) << __func__ << " " << n << " " << m;
+}
+
+class Foo {
+ public:
+  void no_arg(void) {
+    LOG(ERROR) << __func__;
+  }
+
+  void no_arg_const() const {
+    LOG(ERROR) << __func__;
+  }
+
+  void one_arg(int n) {
+    LOG(ERROR) << __func__ << n;
+  }
+
+  void one_arg_const(int n) const {
+    LOG(ERROR) << __func__ << n;
+  }
+};
+
+class RefFoo {
+  int n;
+ public:
+  RefFoo() : n(0) {}
+  ~RefFoo() { if (n != 0) ADD_FAILURE() << "imbalanced ref: " << n; }
+  void AddRef() {
+    n++;
+  }
+  void Release() {
+    n--;
+  }
+
+  void no_arg(void) {
+    LOG(ERROR) << __func__;
+  }
+
+  void no_arg_const() const {
+    LOG(ERROR) << __func__;
+  }
+
+  void one_arg(int n) {
+    LOG(ERROR) << __func__ << n;
+  }
+
+  void one_arg_const(int n) const {
+    LOG(ERROR) << __func__ << n;
+  }
+};
+
+class Bar : public Foo {};
+
+TEST(Callback, Prebind_AllBound) {
+  RefFoo f;  // Must be declared before func for proper destruction order.
+  base::Callback<void(void)> func = base::Prebind(&one_arg, 1);
+  func.Run();
+
+  func = base::Prebind(&RefFoo::no_arg, &f);
+  func.Run();
+
+  func = base::Prebind(&RefFoo::no_arg_const, &f);
+  func.Run();
+}
+
+TEST(Callback, Prebind_OneUnbound) {
+  RefFoo f;  // Must be declared before func for proper destruction order.
+  base::Callback<void(int)> func = base::Prebind(&two_arg, 1);
+  func.Run(2);
+
+  func = base::Prebind(&RefFoo::one_arg, &f);

[akalin, 2011/02/01 11:29:27]

you may already know this, but you could overload operator= for Callback to
eliminate the temporary Callback created here (and copy)

[awong, 2011/02/01 23:20:45]

Oh....I actually forgot about that. Good point.  I should do that.

+  func.Run(4);
+
+  func = base::Prebind(&RefFoo::one_arg_const, &f);
+  func.Run(6);
+}
+
+TEST(Callback, Prebind_AllBoundNoref) {
+  Foo f;
+  base::Callback<void(void)> func =
+      base::Prebind(&Foo::no_arg, base::Unretained(&f));
+  func.Run();
+
+  func = base::Prebind(&Foo::no_arg_const, base::Unretained(&f));
+  func.Run();
+}
+
+TEST(Callback, Prebind_OneUnboundNoRef) {
+  Foo f;
+  base::Callback<void(int)> func =
+      base::Prebind(&Foo::one_arg, base::Unretained(&f));
+  func.Run(4);
+
+  func = base::Prebind(&Foo::one_arg_const, base::Unretained(&f));
+  func.Run(6);
+}
+
+#if 0
+TEST(Callback, Prebind_one_arg_nocompile) {

[akalin, 2011/02/01 11:29:27]

Just to be clear, are these two functions supposed to compile but currently
don't?

[awong, 2011/02/01 23:20:45]

No, these are funcitons that I want explicitly to not compile.  About to redo
the unittests to be more readable and will add a nice comment then.

There's a few features from tr1::bind that I'm explicitly going to disallow
until someone screams. In particular, I want

Callback<void(void)> c;
Callback<int(void)> r_c;
c = r_c;  // This should fail.  It works in tr1.

Also, full currying is currently not implemented. Didn't seem to be worth its
weight in templates.

+  Bar b;
+  func = base::Prebind(&Foo::no_arg_const, &b);
+  func.Run();
+}
+
+TEST(Callback, Prebind_ref_with_unretained_nocompile) {
+  RefFoo f;
+  func = base::Prebind(&Foo::one_arg, base::Unretained(&f));
+  func.Run(4);
+
+  func = base::Prebind(&Foo::one_arg_const, base::Unretained(&f));
+  func.Run(6);
+}
+#endif