1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef BASE_OBSERVER_LIST_THREADSAFE_H_ 6 #define BASE_OBSERVER_LIST_THREADSAFE_H_ 7 8 #include <vector> 9 #include <algorithm> 10 11 #include "base/basictypes.h" 12 #include "base/logging.h" 13 #include "base/message_loop.h" 14 #include "base/observer_list.h" 15 #include "base/ref_counted.h" 16 #include "base/task.h" 17 18 /////////////////////////////////////////////////////////////////////////////// 19 // 20 // OVERVIEW: 21 // 22 // A thread-safe container for a list of observers. 23 // This is similar to the observer_list (see observer_list.h), but it 24 // is more robust for multi-threaded situations. 25 // 26 // The following use cases are supported: 27 // * Observers can register for notifications from any thread. 28 // Callbacks to the observer will occur on the same thread where 29 // the observer initially called AddObserver() from. 30 // * Any thread may trigger a notification via NOTIFY_OBSERVERS. 31 // * Observers can remove themselves from the observer list inside 32 // of a callback. 33 // * If one thread is notifying observers concurrently with an observer 34 // removing itself from the observer list, the notifications will 35 // be silently dropped. 36 // 37 // The drawback of the threadsafe observer list is that notifications 38 // are not as real-time as the non-threadsafe version of this class. 39 // Notifications will always be done via PostTask() to another thread, 40 // whereas with the non-thread-safe observer_list, notifications happen 41 // synchronously and immediately. 42 // 43 // IMPLEMENTATION NOTES 44 // The ObserverListThreadSafe maintains an ObserverList for each thread 45 // which uses the ThreadSafeObserver. When Notifying the observers, 46 // we simply call PostTask to each registered thread, and then each thread 47 // will notify its regular ObserverList. 48 // 49 /////////////////////////////////////////////////////////////////////////////// 50 template <class ObserverType> 51 class ObserverListThreadSafe 52 : public base::RefCountedThreadSafe<ObserverListThreadSafe<ObserverType> > { 53 public: ObserverListThreadSafe()54 ObserverListThreadSafe() {} 55 ~ObserverListThreadSafe()56 ~ObserverListThreadSafe() { 57 typename ObserversListMap::const_iterator it; 58 for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it) 59 delete (*it).second; 60 observer_lists_.clear(); 61 } 62 63 // Add an observer to the list. AddObserver(ObserverType * obs)64 void AddObserver(ObserverType* obs) { 65 ObserverList<ObserverType>* list = NULL; 66 MessageLoop* loop = MessageLoop::current(); 67 // TODO(mbelshe): Get rid of this check. Its needed right now because 68 // Time currently triggers usage of the ObserverList. 69 // And unittests use time without a MessageLoop. 70 if (!loop) 71 return; // Some unittests may access this without a message loop. 72 { 73 AutoLock lock(list_lock_); 74 if (observer_lists_.find(loop) == observer_lists_.end()) 75 observer_lists_[loop] = new ObserverList<ObserverType>(); 76 list = observer_lists_[loop]; 77 } 78 list->AddObserver(obs); 79 } 80 81 // Remove an observer from the list. 82 // If there are pending notifications in-transit to the observer, they will 83 // be aborted. 84 // RemoveObserver MUST be called from the same thread which called 85 // AddObserver. RemoveObserver(ObserverType * obs)86 void RemoveObserver(ObserverType* obs) { 87 ObserverList<ObserverType>* list = NULL; 88 MessageLoop* loop = MessageLoop::current(); 89 if (!loop) 90 return; // On shutdown, it is possible that current() is already null. 91 { 92 AutoLock lock(list_lock_); 93 list = observer_lists_[loop]; 94 if (!list) { 95 NOTREACHED() << "RemoveObserver called on for unknown thread"; 96 return; 97 } 98 99 // If we're about to remove the last observer from the list, 100 // then we can remove this observer_list entirely. 101 if (list->size() == 1) 102 observer_lists_.erase(loop); 103 } 104 list->RemoveObserver(obs); 105 106 // If RemoveObserver is called from a notification, the size will be 107 // nonzero. Instead of deleting here, the NotifyWrapper will delete 108 // when it finishes iterating. 109 if (list->size() == 0) 110 delete list; 111 } 112 113 // Notify methods. 114 // Make a thread-safe callback to each Observer in the list. 115 // Note, these calls are effectively asynchronous. You cannot assume 116 // that at the completion of the Notify call that all Observers have 117 // been Notified. The notification may still be pending delivery. 118 template <class Method> Notify(Method m)119 void Notify(Method m) { 120 UnboundMethod<ObserverType, Method, Tuple0> method(m, MakeTuple()); 121 Notify<Method, Tuple0>(method); 122 } 123 124 template <class Method, class A> Notify(Method m,const A & a)125 void Notify(Method m, const A &a) { 126 UnboundMethod<ObserverType, Method, Tuple1<A> > method(m, MakeTuple(a)); 127 Notify<Method, Tuple1<A> >(method); 128 } 129 130 // TODO(mbelshe): Add more wrappers for Notify() with more arguments. 131 132 private: 133 template <class Method, class Params> Notify(const UnboundMethod<ObserverType,Method,Params> & method)134 void Notify(const UnboundMethod<ObserverType, Method, Params>& method) { 135 AutoLock lock(list_lock_); 136 typename ObserversListMap::iterator it; 137 for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it) { 138 MessageLoop* loop = (*it).first; 139 ObserverList<ObserverType>* list = (*it).second; 140 loop->PostTask(FROM_HERE, 141 NewRunnableMethod(this, 142 &ObserverListThreadSafe<ObserverType>:: 143 template NotifyWrapper<Method, Params>, list, method)); 144 } 145 } 146 147 // Wrapper which is called to fire the notifications for each thread's 148 // ObserverList. This function MUST be called on the thread which owns 149 // the unsafe ObserverList. 150 template <class Method, class Params> NotifyWrapper(ObserverList<ObserverType> * list,const UnboundMethod<ObserverType,Method,Params> & method)151 void NotifyWrapper(ObserverList<ObserverType>* list, 152 const UnboundMethod<ObserverType, Method, Params>& method) { 153 154 // Check that this list still needs notifications. 155 { 156 AutoLock lock(list_lock_); 157 typename ObserversListMap::iterator it = 158 observer_lists_.find(MessageLoop::current()); 159 160 // The ObserverList could have been removed already. In fact, it could 161 // have been removed and then re-added! If the master list's loop 162 // does not match this one, then we do not need to finish this 163 // notification. 164 if (it == observer_lists_.end() || it->second != list) 165 return; 166 } 167 168 { 169 typename ObserverList<ObserverType>::Iterator it(*list); 170 ObserverType* obs; 171 while ((obs = it.GetNext()) != NULL) 172 method.Run(obs); 173 } 174 175 // If there are no more observers on the list, we can now delete it. 176 if (list->size() == 0) { 177 #ifndef NDEBUG 178 { 179 AutoLock lock(list_lock_); 180 // Verify this list is no longer registered. 181 typename ObserversListMap::iterator it = 182 observer_lists_.find(MessageLoop::current()); 183 DCHECK(it == observer_lists_.end() || it->second != list); 184 } 185 #endif 186 delete list; 187 } 188 } 189 190 typedef std::map<MessageLoop*, ObserverList<ObserverType>*> ObserversListMap; 191 192 // These are marked mutable to facilitate having NotifyAll be const. 193 Lock list_lock_; // Protects the observer_lists_. 194 ObserversListMap observer_lists_; 195 196 DISALLOW_EVIL_CONSTRUCTORS(ObserverListThreadSafe); 197 }; 198 199 #endif // BASE_OBSERVER_LIST_THREADSAFE_H_ 200