The Tor Browser: comparison ipc/chromium/src/base/observer_list

--1:000000000000
+:e474f6f1fe77
+// Copyright (c) 2006-2008 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_OBSERVER_LIST_THREADSAFE_H_
+#define BASE_OBSERVER_LIST_THREADSAFE_H_
+#include <vector>
+#include <algorithm>
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/observer_list.h"
+#include "base/ref_counted.h"
+#include "base/task.h"
+namespace base {
+///////////////////////////////////////////////////////////////////////////////
+//
+// OVERVIEW:
+//
+//   A thread-safe container for a list of observers.
+//   This is similar to the observer_list (see observer_list.h), but it
+//   is more robust for multi-threaded situations.
+//
+//   The following use cases are supported:
+//    * Observers can register for notifications from any thread.
+//      Callbacks to the observer will occur on the same thread where
+//      the observer initially called AddObserver() from.
+//    * Any thread may trigger a notification via NOTIFY_OBSERVERS.
+//    * Observers can remove themselves from the observer list inside
+//      of a callback.
+//    * If one thread is notifying observers concurrently with an observer
+//      removing itself from the observer list, the notifications will
+//      be silently dropped.
+//
+//   The drawback of the threadsafe observer list is that notifications
+//   are not as real-time as the non-threadsafe version of this class.
+//   Notifications will always be done via PostTask() to another thread,
+//   whereas with the non-thread-safe observer_list, notifications happen
+//   synchronously and immediately.
+//
+//   IMPLEMENTATION NOTES
+//   The ObserverListThreadSafe maintains an ObserverList for each thread
+//   which uses the ThreadSafeObserver.  When Notifying the observers,
+//   we simply call PostTask to each registered thread, and then each thread
+//   will notify its regular ObserverList.
+//
+///////////////////////////////////////////////////////////////////////////////
+template <class ObserverType>
+class ObserverListThreadSafe
+: public base::RefCountedThreadSafe<ObserverListThreadSafe<ObserverType> > {
+public:
+ObserverListThreadSafe() {}
+~ObserverListThreadSafe() {
+typename ObserversListMap::const_iterator it;
+for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it)
+delete (*it).second;
+observer_lists_.clear();
+}
+// Add an observer to the list.
+void AddObserver(ObserverType* obs) {
+ObserverList<ObserverType>* list = NULL;
+MessageLoop* loop = MessageLoop::current();
+// TODO(mbelshe): Get rid of this check.  Its needed right now because
+//                Time currently triggers usage of the ObserverList.
+//                And unittests use time without a MessageLoop.
+if (!loop)
+return;  // Some unittests may access this without a message loop.
+{
+AutoLock lock(list_lock_);
+if (observer_lists_.find(loop) == observer_lists_.end())
+observer_lists_[loop] = new ObserverList<ObserverType>();
+list = observer_lists_[loop];
+}
+list->AddObserver(obs);
+}
+// Remove an observer from the list.
+// If there are pending notifications in-transit to the observer, they will
+// be aborted.
+// RemoveObserver MUST be called from the same thread which called
+// AddObserver.
+void RemoveObserver(ObserverType* obs) {
+ObserverList<ObserverType>* list = NULL;
+MessageLoop* loop = MessageLoop::current();
+if (!loop)
+return;  // On shutdown, it is possible that current() is already null.
+{
+AutoLock lock(list_lock_);
+list = observer_lists_[loop];
+if (!list) {
+NOTREACHED() << "RemoveObserver called on for unknown thread";
+return;
+}
+// If we're about to remove the last observer from the list,
+// then we can remove this observer_list entirely.
+if (list->size() == 1)
+observer_lists_.erase(loop);
+}
+list->RemoveObserver(obs);
+// If RemoveObserver is called from a notification, the size will be
+// nonzero.  Instead of deleting here, the NotifyWrapper will delete
+// when it finishes iterating.
+if (list->size() == 0)
+delete list;
+}
+// Notify methods.
+// Make a thread-safe callback to each Observer in the list.
+// Note, these calls are effectively asynchronous.  You cannot assume
+// that at the completion of the Notify call that all Observers have
+// been Notified.  The notification may still be pending delivery.
+template <class Method>
+void Notify(Method m) {
+UnboundMethod<ObserverType, Method, Tuple0> method(m, MakeTuple());
+Notify<Method, Tuple0>(method);
+}
+template <class Method, class A>
+void Notify(Method m, const A &a) {
+UnboundMethod<ObserverType, Method, Tuple1<A> > method(m, MakeTuple(a));
+Notify<Method, Tuple1<A> >(method);
+}
+// TODO(mbelshe):  Add more wrappers for Notify() with more arguments.
+private:
+template <class Method, class Params>
+void Notify(const UnboundMethod<ObserverType, Method, Params>& method) {
+AutoLock lock(list_lock_);
+typename ObserversListMap::iterator it;
+for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it) {
+MessageLoop* loop = (*it).first;
+ObserverList<ObserverType>* list = (*it).second;
+loop->PostTask(FROM_HERE,
+NewRunnableMethod(this,
+&ObserverListThreadSafe<ObserverType>::
+template NotifyWrapper<Method, Params>, list, method));
+}
+}
+// Wrapper which is called to fire the notifications for each thread's
+// ObserverList.  This function MUST be called on the thread which owns
+// the unsafe ObserverList.
+template <class Method, class Params>
+void NotifyWrapper(ObserverList<ObserverType>* list,
+const UnboundMethod<ObserverType, Method, Params>& method) {
+// Check that this list still needs notifications.
+{
+AutoLock lock(list_lock_);
+typename ObserversListMap::iterator it =
+observer_lists_.find(MessageLoop::current());
+// The ObserverList could have been removed already.  In fact, it could
+// have been removed and then re-added!  If the master list's loop
+// does not match this one, then we do not need to finish this
+// notification.
+if (it == observer_lists_.end() || it->second != list)
+return;
+}
+{
+typename ObserverList<ObserverType>::Iterator it(*list);
+ObserverType* obs;
+while ((obs = it.GetNext()) != NULL)
+method.Run(obs);
+}
+// If there are no more observers on the list, we can now delete it.
+if (list->size() == 0) {
+#ifndef NDEBUG
+{
+AutoLock lock(list_lock_);
+// Verify this list is no longer registered.
+typename ObserversListMap::iterator it =
+observer_lists_.find(MessageLoop::current());
+DCHECK(it == observer_lists_.end() || it->second != list);
+}
+#endif
+delete list;
+}
+}
+typedef std::map<MessageLoop*, ObserverList<ObserverType>*> ObserversListMap;
+// These are marked mutable to facilitate having NotifyAll be const.
+Lock list_lock_;  // Protects the observer_lists_.
+ObserversListMap observer_lists_;
+DISALLOW_EVIL_CONSTRUCTORS(ObserverListThreadSafe);
+};
+} // namespace base
+#endif  // BASE_OBSERVER_LIST_THREADSAFE_H_

The Tor Browser / file comparison

comparison: ipc/chromium/src/base/observer_list_threadsafe.h

ipc/chromium/src/base/observer_list_threadsafe.h