The Tor Browser: ipc/chromium/src/base/observer_list.h@6474c204b198 (annotated)

ipc/chromium/src/base/observer_list.h@6474c204b198 (annotated)

ipc/chromium/src/base/observer_list.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // 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_H__
 #define BASE_OBSERVER_LIST_H__
 #include <algorithm>
 #include <limits>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/logging.h"
 #if defined(ANDROID) && defined(_STLP_STD_NAME)
 using _STLP_STD_NAME::find;
 #endif
 namespace base {
 ///////////////////////////////////////////////////////////////////////////////
 //
 // OVERVIEW:
 //
 //   A container for a list of observers.  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 observer removing itself
 //   or other observers from the list while observers are being notified.
 //
 // TYPICAL USAGE:
 //
 //   class MyWidget {
 //    public:
 //     ...
 //
 //     class Observer {
 //      public:
 //       virtual void OnFoo(MyWidget* w) = 0;
 //       virtual void OnBar(MyWidget* w, int x, int y) = 0;
 //     };
 //
 //     void AddObserver(Observer* obs) {
 //       observer_list_.AddObserver(obs);
 //     }
 //
 //     void RemoveObserver(Observer* obs) {
 //       observer_list_.RemoveObserver(obs);
 //     }
 //
 //     void NotifyFoo() {
 //       FOR_EACH_OBSERVER(Observer, observer_list_, OnFoo(this));
 //     }
 //
 //     void NotifyBar(int x, int y) {
 //       FOR_EACH_OBSERVER(Observer, observer_list_, OnBar(this, x, y));
 //     }
 //
 //    private:
 //     ObserverList<Observer> observer_list_;
 //   };
 //
 //
 ///////////////////////////////////////////////////////////////////////////////
 template <class ObserverType, bool check_empty = false>
 class ObserverList {
  public:
   // Enumeration of which observers are notified.
   enum NotificationType {
     // Specifies that any observers added during notification are notified.
     // This is the default type if non type is provided to the constructor.
     NOTIFY_ALL,
     // Specifies that observers added while sending out notification are not
     // notified.
     NOTIFY_EXISTING_ONLY
   };
   ObserverList() : notify_depth_(0), type_(NOTIFY_ALL) {}
   ObserverList(NotificationType type) : notify_depth_(0), type_(type) {}
   ~ObserverList() {
     // When check_empty is true, assert that the list is empty on destruction.
     if (check_empty) {
       Compact();
       DCHECK_EQ(observers_.size(), 0U);
     }
   }
   // Add an observer to the list.
   void AddObserver(ObserverType* obs) {
     DCHECK(find(observers_.begin(), observers_.end(), obs) == observers_.end())
         << "Observers can only be added once!";
     observers_.push_back(obs);
   }
   // Remove an observer from the list.
   void RemoveObserver(ObserverType* obs) {
     typename ListType::iterator it =
       std::find(observers_.begin(), observers_.end(), obs);
     if (it != observers_.end()) {
       if (notify_depth_) {
         *it = 0;
       } else {
         observers_.erase(it);
       }
     }
   }
   size_t size() const {
     return observers_.size();
   }
   ObserverType* GetElementAt(int index) const {
     return observers_[index];
   }
   // An iterator class that can be used to access the list of observers.  See
   // also the FOREACH_OBSERVER macro defined below.
   class Iterator {
    public:
     Iterator(const ObserverList<ObserverType>& list)
         : list_(list),
           index_(0),
           max_index_(list.type_ == NOTIFY_ALL ?
                      std::numeric_limits<size_t>::max() :
                      list.observers_.size()) {
       ++list_.notify_depth_;
     }
     ~Iterator() {
       if (--list_.notify_depth_ == 0)
         list_.Compact();
     }
     ObserverType* GetNext() {
       ListType& observers = list_.observers_;
       // Advance if the current element is null
       size_t max_index = std::min(max_index_, observers.size());
       while (index_ < max_index && !observers[index_])
         ++index_;
       return index_ < max_index ? observers[index_++] : NULL;
     }
    private:
     const ObserverList<ObserverType>& list_;
     size_t index_;
     size_t max_index_;
   };
  private:
   typedef std::vector<ObserverType*> ListType;
   void Compact() const {
     typename ListType::iterator it = observers_.begin();
     while (it != observers_.end()) {
       if (*it) {
         ++it;
       } else {
         it = observers_.erase(it);
       }
     }
   }
   // These are marked mutable to facilitate having NotifyAll be const.
   mutable ListType observers_;
   mutable int notify_depth_;
   NotificationType type_;
   friend class ObserverList::Iterator;
   DISALLOW_EVIL_CONSTRUCTORS(ObserverList);
 };
 } // namespace base
 #define FOR_EACH_OBSERVER(ObserverType, observer_list, func)		\
   do {									\
     base::ObserverList<ObserverType>::Iterator it(observer_list);	\
     ObserverType* obs;							\
     while ((obs = it.GetNext()) != NULL)				\
       obs->func;							\
   } while (0)
 #endif  // BASE_OBSERVER_LIST_H__

The Tor Browser / annotate

ipc/chromium/src/base/observer_list.h@6474c204b198 (annotated)

ipc/chromium/src/base/observer_list.h