Chromium Base学习笔记 —— Callback

Callback对象在传递过程中，必须是const-reference类型。

基本用法如下：

int Return5() { return 5; }
base::Callback<int(void)> func_cb = 
base::Bind(&Return5);
LOG(INFO) << func_cb.Run();  // Prints 5.

绑定类方法：

绑定类方法的时候，该Class必须继承自RefCounted。如果需要在Thread中传递，那么需要保证线程安全（RefCountedThreadSafe）

   class Ref : public base::RefCountedThreadSafe<Ref> {
    public:
     int Foo() { return 3; }
     void PrintBye() { LOG(INFO) << "bye."; }
   };
   scoped_refptr<Ref> ref = new Ref();
   base::Callback<void(void)> ref_cb = base::Bind(&Ref::Foo, ref);
   LOG(INFO) << ref_cb.Run();  // Prints out 3.

// MISSING FUNCTIONALITY
//  - Binding arrays to functions that take a non-const pointer.
//    Example:
//      void Foo(const char* ptr);
//      void Bar(char* ptr);
//      Bind(&Foo, "test");
//      Bind(&Bar, "test");  // This fails because ptr is not const.

使用Run方法运行：

void DoSomething(const base::Callback<void(int, std::string)>& callback) {
    callback.Run(5, "hello");
}

// 可以重复使用Callback：
void DoSomething(const base::Callback<double(double)>& callback) {
  double myresult = callback.Run(3.14159);
  myresult += callback.Run(2.71828);
}

1. PASSING UNBOUND INPUT PARAMETERS

void MyFunc(int i, const std::string& str) {}
base::Callback<void(int, const std::string&)> cb = base::Bind(&MyFunc);
cb.Run(23, "hello, world");

2. PASSING BOUND INPUT PARAMETERS

void MyFunc(int i, const std::string& str) {}
base::Callback<void(void)> cb = base::Bind(&MyFunc, 23, "hello world");
cb.Run();

//A callback with no unbound input parameters (base::Callback<void(void)>)
//is called a base::Closure. So we could have also written:

base::Closure cb = base::Bind(&MyFunc, 23, "hello world");

//   When calling member functions, bound parameters just go after the object
//   pointer.
//
base::Closure cb = base::Bind(&MyClass::MyFunc, this, 23, "hello world");

3. PARTIAL BINDING OF PARAMETERS

   void MyFunc(int i, const std::string& str) {}
   base::Callback<void(const std::string&)> cb = base::Bind(&MyFunc, 23);
   cb.Run("hello world");

高级用法：

1. 通过WeakPtr绑定类方法：不是线程安全的，只能在单线程中使用

base::Bind(&MyClass::Foo, GetWeakPtr());

2. 手动管理This的声明周期，也就是this的拥有权不归Callback所有

base::Bind(&MyClass::Foo, base::Unretained(this));

3. 与2相反，This指针归Callback所有，Callback被destroy的时候，this也会被delete掉。

//   MyClass* myclass = new MyClass;
//   base::Bind(&MyClass::Foo, base::Owned(myclass));

4. 忽略返回值的情况

int DoSomething(int arg) { cout << arg << endl; }
base::Callback<void<int>) cb =
     base::Bind(base::IgnoreResult(&DoSomething));

Quick reference for binding parameters to Bind()：

关于Closure：A callback with no parameters or no unbound parameters is called a Closure (base::Callback<void(void)> and base::Closure are the same thing).

（1）With No Parameters：

base::Callback<void(void)>

（2）No Unbound Parameters：

void MyFunc(int i, const std::string& str) {}
base::Callback<void(void)> cb = base::Bind(&MyFunc, 23, "hello world");
cb.Run();

PASSING PARAMETERS OWNED BY THE CALLBACK:

void Foo(int* arg) { cout << *arg << endl; }
int* pn = new int(1);
base::Closure foo_callback = base::Bind(&foo, base::Owned(pn));
//   The parameter will be deleted when the callback is destroyed, even if it's
//   not run (like if you post a task during shutdown).

PASSING PARAMETERS AS A scoped_ptr:

void TakesOwnership(scoped_ptr<Foo> arg) {}
scoped_ptr<Foo> f(new Foo);
// f becomes null during the following call.
base::Closure cb = base::Bind(&TakesOwnership, base::Passed(&f));
//   Ownership of the parameter will be with the callback until the it is run,
//   when ownership is passed to the callback function. This means the callback
//   can only be run once. If the callback is never run, it will delete the
//   object when it's destroyed.
//     arg的生命周期是TakesOwnership的函数执行结束

PASSING PARAMETERS AS A scoped_refptr：

void TakesOneRef(scoped_refptr<Foo> arg) {}
scoped_refptr<Foo> f(new Foo)
base::Closure cb = base::Bind(&TakesOneRef, f);
//   This should "just work." The closure will take a reference as long as it
//   is alive, and another reference will be taken for the called function.

PASSING PARAMETERS BY REFERENCE：

//   Const references are *copied* unless ConstRef is used. Example:
//
void foo(const int& arg) { printf("%d %p\n", arg, &arg); }
int n = 1;
base::Closure has_copy = base::Bind(&foo, n);
base::Closure has_ref = base::Bind(&foo, base::ConstRef(n));
n = 2;
foo(n);                        // Prints "2 0xaaaaaaaaaaaa"
has_copy.Run();                // Prints "1 0xbbbbbbbbbbbb"
has_ref.Run();                 // Prints "2 0xaaaaaaaaaaaa"
//   Normally parameters are copied in the closure. DANGER: ConstRef stores a
//   const reference instead, referencing the original parameter. This means
//   that you must ensure the object outlives the callback!
//   ConstRef存储的是参数的引用，而不是参数的拷贝。所以使用ConstRef要确保Run()之前参数是有效的。