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"

[scherkus (not reviewing), 2011/02/01 01:00:10]

include order

[awong, 2011/02/01 01:21:38]

Will fix in next pass...I'm about to regenerate these files based on pump, so
they're going to look pretty different.

 
 #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;

[scherkus (not reviewing), 2011/02/01 01:00:10]

move this to private section?

[awong, 2011/02/01 01:21:38]

Yep. This will get recreated by pump in a bit.

+ 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);
+  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

[scherkus (not reviewing), 2011/02/01 01:00:10]

:)

[awong, 2011/02/01 01:21:38]

*sigh*  Yeah, I wish I had a better method for this.

+TEST(Callback, Prebind_one_arg_nocompile) {
+  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