Add a CallbackRegistry class to base/ to manage callbacks

base/callback_list.h

+// Copyright 2013 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.
+
+#ifndef BASE_CALLBACK_LIST_H_
+#define BASE_CALLBACK_LIST_H_
+
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/memory/weak_ptr.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// OVERVIEW:
+//
+//   A container for a list of callbacks.  Unlike a normal STL vector or list,
+//   this container can be modified during iteration without invalidating the
+//   iterator.  So, it safely handles the case of an callback removing itself
+//   or other callback from the list while callbacks are being run.
+//
+// TYPICAL USAGE:
+//
+//   class MyWidget {
+//    public:
+//     ...
+//
+//     typedef base::Callback<void(Foo*)> OnFooCallback;
+//
+//     base::Closure RegisterCallback(const OnFooCallback& cb) {
+//       return callback_list_.RegisterCallback(cb);
+//     }
+//
+//    private:
+//     void NotifyFoo(Foo* foo) {
+//       FOR_EACH_CALLBACK(OnFooCallback, callback_list_, foo);

[awong, 2013/08/24 04:11:07]

Is there a way to make this into something like

callback_list_->Run(foo)?

and avoid the macro?

[Cait (Slow), 2013/08/26 23:49:27]

Done.

+//     }
+//
+//     CallbackList<OnFooCallback> callback_list_;
+//   };
+//
+//
+//  class MyWidgetListener {
+//    public:
+//
+//     MyWidgetListener::MyWidgetListener() {
+//       remove_foo_callback_ = MyWidget::GetCurrent()->RegisterCallback(
+//           base::Bind(&MyWidgetListener::OnFoo, this));
+//     }
+//
+//     MyWidgetListener::~MyWidgetListener() {
+//       remove_foo_callback_.Run();
+//     }
+//
+//     void OnFoo(Foo* foo) {
+//       // Do something.
+//     }
+//
+//    private:
+//     base::Closure remove_foo_callback_;
+//   };
+//
+///////////////////////////////////////////////////////////////////////////////
+
+template <class SIG>

[awong, 2013/08/24 04:11:07]

nit: The convention in base/callback.h is to use "Sig" not "SIG".  Please make
this consistent.

Also, is this CallbackType?

[Cait (Slow), 2013/08/26 23:49:27]

Done.

+class CallbackListBase {
+ public:
+  // Enumeration of which callbacks are called.
+  enum NotificationType {
+    // Specifies that any callbacks added during notification are called.
+    // This is the default type if no type is provided to the constructor.
+    NOTIFY_ALL,
+
+    // Specifies that callbacks added while sending out notifications are not
+    // called.
+    NOTIFY_EXISTING_ONLY
+  };
+
+  // An iterator class that can be used to access the list of callbacks.  See
+  // also the FOR_EACH_CALLBACK macro defined below.
+  class Iterator {
+   public:
+    Iterator(CallbackListBase<SIG>& list)

[awong, 2013/08/24 04:11:07]

Taking things by reference is disallowed by style guide.  Can we do this via
pointer?

[Cait (Slow), 2013/08/26 23:49:27]

Done.

+        : list_(list.GetWeakPtr()),
+          index_(0),
+          max_index_(list.type_ == NOTIFY_ALL ?
+                     std::numeric_limits<size_t>::max() :
+                     list.callbacks_.size()) {
+      ++list_->active_iterator_count_;
+    }
+
+    ~Iterator() {
+      if (list_.get() && --list_->active_iterator_count_ == 0)
+        list_->Compact();
+    }
+
+    SIG GetNext() {
+      if (!list_.get())
+        return SIG();
+      ListType& callbacks = list_->callbacks_;
+      size_t max_index = std::min(max_index_, callbacks.size());
+      while (index_ < max_index && callbacks[index_].is_null())
+        ++index_;
+      return index_ < max_index ? callbacks[index_++] : SIG();
+    }
+
+   private:
+    base::WeakPtr<CallbackListBase<SIG> > list_;
+    size_t index_;
+    size_t max_index_;
+  };
+
+  CallbackListBase()
+      : active_iterator_count_(0),
+        type_(NOTIFY_ALL),
+        weak_factory_(this) {}
+
+  explicit CallbackListBase(NotificationType type)
+      : active_iterator_count_(0),
+        type_(type),
+        weak_factory_(this) {}
+
+  // Add a callback to the list. A callback should not be added to
+  // the same list more than once. The returned closure (used to remove the
+  // callback from the list) is guaranteed to be safe to run.
+  base::Closure RegisterCallback(const SIG& cb) {
+    DCHECK(!cb.is_null());
+    for (size_t i = 0; i < callbacks_.size(); i++) {
+      if (callbacks_[i].Equals(cb)) {
+        NOTREACHED() << "Callbacks can only be added once!";
+        return base::Bind(&base::DoNothing);
+      }
+    }
+    callbacks_.push_back(cb);
+    base::Closure removal_cb = base::Bind(
+        &CallbackListBase::RemoveCallback, GetWeakPtr(), cb);
+    return removal_cb;
+  }
+
+  // Remove an callback from the list if it is in the list.
+  void RemoveCallback(const SIG& cb) {
+    for (size_t i = 0; i < callbacks_.size(); i++) {
+      if (callbacks_[i].Equals(cb)) {
+        if (active_iterator_count_)
+          callbacks_[i].Reset();
+        else
+          callbacks_.erase(callbacks_.begin() + i);
+        return;
+      }
+    }
+  }
+
+  bool HasCallback(const SIG& cb) const {
+    for (size_t i = 0; i < callbacks_.size(); ++i) {
+      if (callbacks_[i].Equals(cb))
+        return true;
+    }
+    return false;
+  }
+
+  void Clear() {
+    if (active_iterator_count_) {
+      for (size_t i = 0; i < callbacks_.size(); ++i)
+        callbacks_[i].Reset();
+    } else {
+      callbacks_.clear();
+    }
+  }
+
+ protected:
+  base::WeakPtr<CallbackListBase<SIG> > GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+  void Compact() {
+    for (size_t i = 0; i < callbacks_.size(); i++) {
+      if (callbacks_[i].is_null()) {
+        callbacks_.erase(callbacks_.begin() + i);
+      }
+    }
+  }
+
+  size_t size() const { return callbacks_.size(); }
+
+ private:
+  friend class CallbackListBase::Iterator;
+  typedef std::vector<SIG> ListType;
+
+  ListType callbacks_;
+  int active_iterator_count_;
+  NotificationType type_;
+  base::WeakPtrFactory<CallbackListBase<SIG> > weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackListBase);
+};
+
+template <class SIG, bool check_empty = false>
+class CallbackList : public CallbackListBase<SIG> {
+ public:
+  typedef typename CallbackListBase<SIG>::NotificationType NotificationType;
+
+  CallbackList() {}
+  explicit CallbackList(NotificationType type)
+      : CallbackListBase<SIG>(type) {}
+
+  ~CallbackList() {
+    // When check_empty is true, assert that the list is empty on destruction.
+    if (check_empty) {

[awong, 2013/08/24 04:11:07]

If you're taking this as a template constant parameter, there's no reason for
this to be a runtime check.  You can specialize the destructor implementation
separately.

Though, is it possible to just define one single behavior?  I'd be nicer to
always assert the list is empty on destruction.

[Cait (Slow), 2013/08/26 23:49:27]

Done.

+      CallbackListBase<SIG>::Compact();
+      DCHECK_EQ(0U, CallbackListBase<SIG>::size());
+    }
+  }
+
+  bool might_have_callbacks() const {
+    return CallbackListBase<SIG>::size() != 0;
+  }
+};
+
+#define FOR_EACH_CALLBACK(CallbackType, callback_list, ...)          \
+  do {                                                               \
+    if ((callback_list).might_have_callbacks()) {                    \
+      CallbackListBase<CallbackType>::Iterator it(callback_list);    \
+      CallbackType cb;                                               \
+      while(!(cb = it.GetNext()).is_null())                          \
+        cb.Run(__VA_ARGS__);                                         \
+    }                                                                \
+  } while (0)
+
+#endif  // BASE_CALLBACK_LIST_H_