The Tor Browser: content/base/src/ChildIterator.h@deefc01c0e14 (annotated)

content/base/src/ChildIterator.h@deefc01c0e14 (annotated)

content/base/src/ChildIterator.h

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 sw=2 et 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 ChildIterator_h
 #define ChildIterator_h
 /**
  * Iterates over the children on a node. If a child is an insertion point,
  * iterates over the children inserted there instead, or the default content
  * if no children are inserted there.
  *
  * The FlattenedChildIterator expands any anonymous content bound from an XBL
  * binding's <xbl:content> element.
  */
 #include "nsIContent.h"
 namespace mozilla {
 namespace dom {
 // This class iterates normal DOM child nodes of a given DOM node with
 // <xbl:children> nodes replaced by the elements that have been filtered into that
 // insertion point. Any bindings on the given element are ignored for purposes
 // of determining which insertion point children are filtered into. The iterator
 // can be initialized to start at the end by providing false for aStartAtBeginning
 // in order to start iterating in reverse from the last child.
 class ExplicitChildIterator
 {
 public:
   ExplicitChildIterator(nsIContent* aParent, bool aStartAtBeginning = true)
     : mParent(aParent),
       mChild(nullptr),
       mDefaultChild(nullptr),
       mIndexInInserted(0),
       mIsFirst(aStartAtBeginning)
   {
   }
   nsIContent* GetNextChild();
   // Looks for aChildToFind respecting insertion points until aChildToFind
   // or aBound is found. If aBound is nullptr then the seek is unbounded. Returns
   // whether aChildToFind was found as an explicit child prior to encountering
   // aBound.
   bool Seek(nsIContent* aChildToFind, nsIContent* aBound = nullptr)
   {
     // It would be nice to assert that we find aChildToFind, but bz thinks that
     // we might not find aChildToFind when called from ContentInserted
     // if first-letter frames are about.
     nsIContent* child;
     do {
       child = GetNextChild();
     } while (child && child != aChildToFind && child != aBound);
     return child == aChildToFind;
   }
   // Returns the current target of this iterator (which might be an explicit
   // child of the node, fallback content of an insertion point or
   // a node distributed to an insertion point.
   nsIContent* Get();
   // The inverse of GetNextChild. Properly steps in and out of insertion
   // points.
   nsIContent* GetPreviousChild();
 protected:
   // The parent of the children being iterated. For the FlattenedChildIterator,
   // if there is a binding attached to the original parent, mParent points to
   // the <xbl:content> element for the binding.
   nsIContent* mParent;
   // The current child. When we encounter an insertion point,
   // mChild remains as the insertion point whose content we're iterating (and
   // our state is controled by mDefaultChild or mIndexInInserted depending on
   // whether the insertion point expands to its default content or not).
   nsIContent* mChild;
   // If non-null, this points to the current default content for the current
   // insertion point that we're iterating (i.e. mChild, which must be an
   // nsXBLChildrenElement or HTMLContentElement). Once this transitions back
   // to null, we continue iterating at mChild's next sibling.
   nsIContent* mDefaultChild;
   // If non-null, this points to an iterator of the explicit children of
   // the ShadowRoot projected by the current shadow element that we're
   // iterating.
   nsAutoPtr<ExplicitChildIterator> mShadowIterator;
   // If not zero, we're iterating inserted children for an insertion point. This
   // is an index into mChild's inserted children array (mChild must be an
   // nsXBLChildrenElement). The index is one past the "current" child (as
   // opposed to mChild which represents the "current" child).
   uint32_t mIndexInInserted;
   // A flag to let us know that we haven't started iterating yet.
   bool mIsFirst;
 };
 // Iterates over the flattened children of a node, which accounts for anonymous
 // children and nodes moved by insertion points. If a node has anonymous
 // children, those are iterated over.
 class FlattenedChildIterator : public ExplicitChildIterator
 {
 public:
   FlattenedChildIterator(nsIContent* aParent);
   bool XBLInvolved() { return mXBLInvolved; }
 private:
   // For certain optimizations, nsCSSFrameConstructor needs to know if the
   // child list of the element that we're iterating matches its .childNodes.
   bool mXBLInvolved;
 };
 } // namespace dom
 } // namespace mozilla
 #endif

The Tor Browser / annotate

content/base/src/ChildIterator.h@deefc01c0e14 (annotated)

content/base/src/ChildIterator.h