The Tor Browser: accessible/src/base/AccIterator.h@97036ab72558 (annotated)

accessible/src/base/AccIterator.h@97036ab72558 (annotated)

accessible/src/base/AccIterator.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef mozilla_a11y_AccIterator_h__
 #define mozilla_a11y_AccIterator_h__
 #include "DocAccessible.h"
 #include "Filters.h"
 class nsITreeView;
 namespace mozilla {
 namespace a11y {
 /**
  * AccIterable is a basic interface for iterators over accessibles.
  */
 class AccIterable
 {
 public:
   virtual ~AccIterable() { }
   virtual Accessible* Next() = 0;
 private:
   friend class Relation;
   nsAutoPtr<AccIterable> mNextIter;
 };
 /**
  * Allows to iterate through accessible children or subtree complying with
  * filter function.
  */
 class AccIterator : public AccIterable
 {
 public:
   AccIterator(Accessible* aRoot, filters::FilterFuncPtr aFilterFunc);
   virtual ~AccIterator();
   /**
    * Return next accessible complying with filter function. Return the first
    * accessible for the first time.
    */
   virtual Accessible* Next();
 private:
   AccIterator();
   AccIterator(const AccIterator&);
   AccIterator& operator =(const AccIterator&);
   struct IteratorState
   {
     IteratorState(Accessible* aParent, IteratorState* mParentState = nullptr);
     Accessible* mParent;
     int32_t mIndex;
     IteratorState* mParentState;
   };
   filters::FilterFuncPtr mFilterFunc;
   IteratorState* mState;
 };
 /**
  * Allows to traverse through related accessibles that are pointing to the given
  * dependent accessible by relation attribute.
  */
 class RelatedAccIterator : public AccIterable
 {
 public:
   /**
    * Constructor.
    *
    * @param aDocument         [in] the document accessible the related
    * &                         accessibles belong to.
    * @param aDependentContent [in] the content of dependent accessible that
    *                           relations were requested for
    * @param aRelAttr          [in] relation attribute that relations are
    *                           pointed by
    */
   RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent,
                      nsIAtom* aRelAttr);
   virtual ~RelatedAccIterator() { }
   /**
    * Return next related accessible for the given dependent accessible.
    */
   virtual Accessible* Next();
 private:
   RelatedAccIterator();
   RelatedAccIterator(const RelatedAccIterator&);
   RelatedAccIterator& operator = (const RelatedAccIterator&);
   DocAccessible* mDocument;
   nsIAtom* mRelAttr;
   DocAccessible::AttrRelProviderArray* mProviders;
   nsIContent* mBindingParent;
   uint32_t mIndex;
 };
 /**
  * Used to iterate through HTML labels associated with the given accessible.
  */
 class HTMLLabelIterator : public AccIterable
 {
 public:
   enum LabelFilter {
     eAllLabels,
     eSkipAncestorLabel
   };
   HTMLLabelIterator(DocAccessible* aDocument, const Accessible* aAccessible,
                     LabelFilter aFilter = eAllLabels);
   virtual ~HTMLLabelIterator() { }
   /**
    * Return next label accessible associated with the given element.
    */
   virtual Accessible* Next();
 private:
   HTMLLabelIterator();
   HTMLLabelIterator(const HTMLLabelIterator&);
   HTMLLabelIterator& operator = (const HTMLLabelIterator&);
   RelatedAccIterator mRelIter;
   // XXX: replace it on weak reference (bug 678429), it's safe to use raw
   // pointer now because iterators life cycle is short.
   const Accessible* mAcc;
   LabelFilter mLabelFilter;
 };
 /**
  * Used to iterate through HTML outputs associated with the given element.
  */
 class HTMLOutputIterator : public AccIterable
 {
 public:
   HTMLOutputIterator(DocAccessible* aDocument, nsIContent* aElement);
   virtual ~HTMLOutputIterator() { }
   /**
    * Return next output accessible associated with the given element.
    */
   virtual Accessible* Next();
 private:
   HTMLOutputIterator();
   HTMLOutputIterator(const HTMLOutputIterator&);
   HTMLOutputIterator& operator = (const HTMLOutputIterator&);
   RelatedAccIterator mRelIter;
 };
 /**
  * Used to iterate through XUL labels associated with the given element.
  */
 class XULLabelIterator : public AccIterable
 {
 public:
   XULLabelIterator(DocAccessible* aDocument, nsIContent* aElement);
   virtual ~XULLabelIterator() { }
   /**
    * Return next label accessible associated with the given element.
    */
   virtual Accessible* Next();
 private:
   XULLabelIterator();
   XULLabelIterator(const XULLabelIterator&);
   XULLabelIterator& operator = (const XULLabelIterator&);
   RelatedAccIterator mRelIter;
 };
 /**
  * Used to iterate through XUL descriptions associated with the given element.
  */
 class XULDescriptionIterator : public AccIterable
 {
 public:
   XULDescriptionIterator(DocAccessible* aDocument, nsIContent* aElement);
   virtual ~XULDescriptionIterator() { }
   /**
    * Return next description accessible associated with the given element.
    */
   virtual Accessible* Next();
 private:
   XULDescriptionIterator();
   XULDescriptionIterator(const XULDescriptionIterator&);
   XULDescriptionIterator& operator = (const XULDescriptionIterator&);
   RelatedAccIterator mRelIter;
 };
 /**
  * Used to iterate through IDs, elements or accessibles pointed by IDRefs
  * attribute. Note, any method used to iterate through IDs, elements, or
  * accessibles moves iterator to next position.
  */
 class IDRefsIterator : public AccIterable
 {
 public:
   IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent,
                  nsIAtom* aIDRefsAttr);
   virtual ~IDRefsIterator() { }
   /**
    * Return next ID.
    */
   const nsDependentSubstring NextID();
   /**
    * Return next element.
    */
   nsIContent* NextElem();
   /**
    * Return the element with the given ID.
    */
   nsIContent* GetElem(const nsDependentSubstring& aID);
   // AccIterable
   virtual Accessible* Next();
 private:
   IDRefsIterator();
   IDRefsIterator(const IDRefsIterator&);
   IDRefsIterator operator = (const IDRefsIterator&);
   nsString mIDs;
   nsIContent* mContent;
   DocAccessible* mDoc;
   nsAString::index_type mCurrIdx;
 };
 /**
  * Iterator that points to a single accessible returning it on the first call
  * to Next().
  */
 class SingleAccIterator : public AccIterable
 {
 public:
   SingleAccIterator(Accessible* aTarget): mAcc(aTarget) { }
   virtual ~SingleAccIterator() { }
   virtual Accessible* Next();
 private:
   SingleAccIterator();
   SingleAccIterator(const SingleAccIterator&);
   SingleAccIterator& operator = (const SingleAccIterator&);
   nsRefPtr<Accessible> mAcc;
 };
 /**
  * Used to iterate items of the given item container.
  */
 class ItemIterator : public AccIterable
 {
 public:
   ItemIterator(Accessible* aItemContainer) :
     mContainer(aItemContainer), mAnchor(nullptr) { }
   virtual ~ItemIterator() { }
   virtual Accessible* Next();
 private:
   ItemIterator() MOZ_DELETE;
   ItemIterator(const ItemIterator&) MOZ_DELETE;
   ItemIterator& operator = (const ItemIterator&) MOZ_DELETE;
   Accessible* mContainer;
   Accessible* mAnchor;
 };
 /**
  * Used to iterate through XUL tree items of the same level.
  */
 class XULTreeItemIterator : public AccIterable
 {
 public:
   XULTreeItemIterator(XULTreeAccessible* aXULTree, nsITreeView* aTreeView,
                       int32_t aRowIdx);
   virtual ~XULTreeItemIterator() { }
   virtual Accessible* Next();
 private:
   XULTreeItemIterator() MOZ_DELETE;
   XULTreeItemIterator(const XULTreeItemIterator&) MOZ_DELETE;
   XULTreeItemIterator& operator = (const XULTreeItemIterator&) MOZ_DELETE;
   XULTreeAccessible* mXULTree;
   nsITreeView* mTreeView;
   int32_t mRowCount;
   int32_t mContainerLevel;
   int32_t mCurrRowIdx;
 };
 } // namespace a11y
 } // namespace mozilla
 #endif

The Tor Browser / annotate

accessible/src/base/AccIterator.h@97036ab72558 (annotated)

accessible/src/base/AccIterator.h