The Tor Browser: security/sandbox/chromium/base/observer

security/sandbox/chromium/base/observer_list.h@925c144e1f1f (annotated)

security/sandbox/chromium/base/observer_list.h

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 // Copyright (c) 2011 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"
 #include "base/memory/weak_ptr.h"
 ///////////////////////////////////////////////////////////////////////////////
 //
 // 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 <typename ObserverType>
 class ObserverListThreadSafe;
 template <class ObserverType>
 class ObserverListBase
     : public base::SupportsWeakPtr<ObserverListBase<ObserverType> > {
  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
   };
   // An iterator class that can be used to access the list of observers.  See
   // also the FOR_EACH_OBSERVER macro defined below.
   class Iterator {
    public:
     Iterator(ObserverListBase<ObserverType>& list)
         : list_(list.AsWeakPtr()),
           index_(0),
           max_index_(list.type_ == NOTIFY_ALL ?
                      std::numeric_limits<size_t>::max() :
                      list.observers_.size()) {
       ++list_->notify_depth_;
     }
     ~Iterator() {
       if (list_.get() && --list_->notify_depth_ == 0)
         list_->Compact();
     }
     ObserverType* GetNext() {
       if (!list_.get())
         return NULL;
       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:
     base::WeakPtr<ObserverListBase<ObserverType> > list_;
     size_t index_;
     size_t max_index_;
   };
   ObserverListBase() : notify_depth_(0), type_(NOTIFY_ALL) {}
   explicit ObserverListBase(NotificationType type)
       : notify_depth_(0), type_(type) {}
   // Add an observer to the list.  An observer should not be added to
   // the same list more than once.
   void AddObserver(ObserverType* obs) {
     if (std::find(observers_.begin(), observers_.end(), obs)
         != observers_.end()) {
       NOTREACHED() << "Observers can only be added once!";
       return;
     }
     observers_.push_back(obs);
   }
   // Remove an observer from the list if it is in 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);
       }
     }
   }
   bool HasObserver(ObserverType* observer) const {
     for (size_t i = 0; i < observers_.size(); ++i) {
       if (observers_[i] == observer)
         return true;
     }
     return false;
   }
   void Clear() {
     if (notify_depth_) {
       for (typename ListType::iterator it = observers_.begin();
            it != observers_.end(); ++it) {
         *it = 0;
       }
     } else {
       observers_.clear();
     }
   }
  protected:
   size_t size() const { return observers_.size(); }
   void Compact() {
     observers_.erase(
         std::remove(observers_.begin(), observers_.end(),
                     static_cast<ObserverType*>(NULL)), observers_.end());
   }
  private:
   friend class ObserverListThreadSafe<ObserverType>;
   typedef std::vector<ObserverType*> ListType;
   ListType observers_;
   int notify_depth_;
   NotificationType type_;
   friend class ObserverListBase::Iterator;
   DISALLOW_COPY_AND_ASSIGN(ObserverListBase);
 };
 template <class ObserverType, bool check_empty = false>
 class ObserverList : public ObserverListBase<ObserverType> {
  public:
   typedef typename ObserverListBase<ObserverType>::NotificationType
       NotificationType;
   ObserverList() {}
   explicit ObserverList(NotificationType type)
       : ObserverListBase<ObserverType>(type) {}
   ~ObserverList() {
     // When check_empty is true, assert that the list is empty on destruction.
     if (check_empty) {
       ObserverListBase<ObserverType>::Compact();
       DCHECK_EQ(ObserverListBase<ObserverType>::size(), 0U);
     }
   }
   bool might_have_observers() const {
     return ObserverListBase<ObserverType>::size() != 0;
   }
 };
 #define FOR_EACH_OBSERVER(ObserverType, observer_list, func)               \
   do {                                                                     \
     if ((observer_list).might_have_observers()) {                          \
       ObserverListBase<ObserverType>::Iterator                             \
           it_inside_observer_macro(observer_list);                         \
       ObserverType* obs;                                                   \
       while ((obs = it_inside_observer_macro.GetNext()) != NULL)           \
         obs->func;                                                         \
     }                                                                      \
   } while (0)
 #endif  // BASE_OBSERVER_LIST_H__

The Tor Browser / annotate

security/sandbox/chromium/base/observer_list.h@925c144e1f1f (annotated)

security/sandbox/chromium/base/observer_list.h