The Tor Browser: comparison content/base/src/ChildIterator.h

--1:000000000000
+:b8bcc8d77d18
+/* -*- 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 / file comparison

comparison: content/base/src/ChildIterator.h

content/base/src/ChildIterator.h