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

--1:000000000000
+:9f4d6566bdea
+/* -*- 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/. */
+#include "ChildIterator.h"
+#include "nsContentUtils.h"
+#include "mozilla/dom/XBLChildrenElement.h"
+#include "mozilla/dom/HTMLContentElement.h"
+#include "mozilla/dom/HTMLShadowElement.h"
+#include "mozilla/dom/ShadowRoot.h"
+namespace mozilla {
+namespace dom {
+class MatchedNodes {
+public:
+MatchedNodes(HTMLContentElement* aInsertionPoint)
+: mIsContentElement(true), mContentElement(aInsertionPoint) {}
+MatchedNodes(XBLChildrenElement* aInsertionPoint)
+: mIsContentElement(false), mChildrenElement(aInsertionPoint) {}
+uint32_t Length() const
+{
+return mIsContentElement ? mContentElement->MatchedNodes().Length()
+: mChildrenElement->mInsertedChildren.Length();
+}
+nsIContent* operator[](int32_t aIndex) const
+{
+return mIsContentElement ? mContentElement->MatchedNodes()[aIndex]
+: mChildrenElement->mInsertedChildren[aIndex];
+}
+bool IsEmpty() const
+{
+return mIsContentElement ? mContentElement->MatchedNodes().IsEmpty()
+: mChildrenElement->mInsertedChildren.IsEmpty();
+}
+protected:
+bool mIsContentElement;
+union {
+HTMLContentElement* mContentElement;
+XBLChildrenElement* mChildrenElement;
+};
+};
+static inline MatchedNodes
+GetMatchedNodesForPoint(nsIContent* aContent)
+{
+if (aContent->NodeInfo()->Equals(nsGkAtoms::children, kNameSpaceID_XBL)) {
+// XBL case
+return MatchedNodes(static_cast<XBLChildrenElement*>(aContent));
+}
+// Web components case
+MOZ_ASSERT(aContent->IsHTML(nsGkAtoms::content));
+return MatchedNodes(static_cast<HTMLContentElement*>(aContent));
+}
+nsIContent*
+ExplicitChildIterator::GetNextChild()
+{
+// If we're already in the inserted-children array, look there first
+if (mIndexInInserted) {
+MOZ_ASSERT(mChild);
+MOZ_ASSERT(nsContentUtils::IsContentInsertionPoint(mChild));
+MOZ_ASSERT(!mDefaultChild);
+MatchedNodes assignedChildren = GetMatchedNodesForPoint(mChild);
+if (mIndexInInserted < assignedChildren.Length()) {
+return assignedChildren[mIndexInInserted++];
+}
+mIndexInInserted = 0;
+mChild = mChild->GetNextSibling();
+} else if (mShadowIterator) {
+// If we're inside of a <shadow> element, look through the
+// explicit children of the projected ShadowRoot via
+// the mShadowIterator.
+nsIContent* nextChild = mShadowIterator->GetNextChild();
+if (nextChild) {
+return nextChild;
+}
+mShadowIterator = nullptr;
+mChild = mChild->GetNextSibling();
+} else if (mDefaultChild) {
+// If we're already in default content, check if there are more nodes there
+MOZ_ASSERT(mChild);
+MOZ_ASSERT(nsContentUtils::IsContentInsertionPoint(mChild));
+mDefaultChild = mDefaultChild->GetNextSibling();
+if (mDefaultChild) {
+return mDefaultChild;
+}
+mChild = mChild->GetNextSibling();
+} else if (mIsFirst) {  // at the beginning of the child list
+mChild = mParent->GetFirstChild();
+mIsFirst = false;
+} else if (mChild) { // in the middle of the child list
+mChild = mChild->GetNextSibling();
+}
+// Iterate until we find a non-insertion point, or an insertion point with
+// content.
+while (mChild) {
+// If the current child being iterated is a shadow insertion point then
+// the iterator needs to go into the projected ShadowRoot.
+if (ShadowRoot::IsShadowInsertionPoint(mChild)) {
+// Look for the next child in the projected ShadowRoot for the <shadow>
+// element.
+HTMLShadowElement* shadowElem = static_cast<HTMLShadowElement*>(mChild);
+ShadowRoot* projectedShadow = shadowElem->GetOlderShadowRoot();
+if (projectedShadow) {
+mShadowIterator = new ExplicitChildIterator(projectedShadow);
+nsIContent* nextChild = mShadowIterator->GetNextChild();
+if (nextChild) {
+return nextChild;
+}
+mShadowIterator = nullptr;
+}
+mChild = mChild->GetNextSibling();
+} else if (nsContentUtils::IsContentInsertionPoint(mChild)) {
+// If the current child being iterated is a content insertion point
+// then the iterator needs to return the nodes distributed into
+// the content insertion point.
+MatchedNodes assignedChildren = GetMatchedNodesForPoint(mChild);
+if (!assignedChildren.IsEmpty()) {
+// Iterate through elements projected on insertion point.
+mIndexInInserted = 1;
+return assignedChildren[0];
+}
+// Insertion points inside fallback/default content
+// are considered inactive and do not get assigned nodes.
+mDefaultChild = mChild->GetFirstChild();
+if (mDefaultChild) {
+return mDefaultChild;
+}
+// If we have an insertion point with no assigned nodes and
+// no default content, move on to the next node.
+mChild = mChild->GetNextSibling();
+} else {
+// mChild is not an insertion point, thus it is the next node to
+// return from this iterator.
+break;
+}
+}
+return mChild;
+}
+FlattenedChildIterator::FlattenedChildIterator(nsIContent* aParent)
+: ExplicitChildIterator(aParent), mXBLInvolved(false)
+{
+nsXBLBinding* binding =
+aParent->OwnerDoc()->BindingManager()->GetBindingWithContent(aParent);
+if (binding) {
+nsIContent* anon = binding->GetAnonymousContent();
+if (anon) {
+mParent = anon;
+mXBLInvolved = true;
+}
+}
+// We set mXBLInvolved to true if either:
+// - The node we're iterating has a binding with content attached to it.
+// - The node is generated XBL content and has an <xbl:children> child.
+if (!mXBLInvolved && aParent->GetBindingParent()) {
+for (nsIContent* child = aParent->GetFirstChild();
+child;
+child = child->GetNextSibling()) {
+if (child->NodeInfo()->Equals(nsGkAtoms::children, kNameSpaceID_XBL)) {
+MOZ_ASSERT(child->GetBindingParent());
+mXBLInvolved = true;
+break;
+}
+}
+}
+}
+nsIContent*
+ExplicitChildIterator::Get()
+{
+MOZ_ASSERT(!mIsFirst);
+if (mIndexInInserted) {
+XBLChildrenElement* point = static_cast<XBLChildrenElement*>(mChild);
+return point->mInsertedChildren[mIndexInInserted - 1];
+} else if (mShadowIterator)  {
+return mShadowIterator->Get();
+}
+return mDefaultChild ? mDefaultChild : mChild;
+}
+nsIContent*
+ExplicitChildIterator::GetPreviousChild()
+{
+// If we're already in the inserted-children array, look there first
+if (mIndexInInserted) {
+// NB: mIndexInInserted points one past the last returned child so we need
+// to look *two* indices back in order to return the previous child.
+MatchedNodes assignedChildren = GetMatchedNodesForPoint(mChild);
+if (--mIndexInInserted) {
+return assignedChildren[mIndexInInserted - 1];
+}
+mChild = mChild->GetPreviousSibling();
+} else if (mShadowIterator) {
+nsIContent* previousChild = mShadowIterator->GetPreviousChild();
+if (previousChild) {
+return previousChild;
+}
+mShadowIterator = nullptr;
+mChild = mChild->GetPreviousSibling();
+} else if (mDefaultChild) {
+// If we're already in default content, check if there are more nodes there
+mDefaultChild = mDefaultChild->GetPreviousSibling();
+if (mDefaultChild) {
+return mDefaultChild;
+}
+mChild = mChild->GetPreviousSibling();
+} else if (mIsFirst) { // at the beginning of the child list
+return nullptr;
+} else if (mChild) { // in the middle of the child list
+mChild = mChild->GetPreviousSibling();
+} else { // at the end of the child list
+mChild = mParent->GetLastChild();
+}
+// Iterate until we find a non-insertion point, or an insertion point with
+// content.
+while (mChild) {
+if (ShadowRoot::IsShadowInsertionPoint(mChild)) {
+// If the current child being iterated is a shadow insertion point then
+// the iterator needs to go into the projected ShadowRoot.
+HTMLShadowElement* shadowElem = static_cast<HTMLShadowElement*>(mChild);
+ShadowRoot* projectedShadow = shadowElem->GetOlderShadowRoot();
+if (projectedShadow) {
+// Create a ExplicitChildIterator that begins iterating from the end.
+mShadowIterator = new ExplicitChildIterator(projectedShadow, false);
+nsIContent* previousChild = mShadowIterator->GetPreviousChild();
+if (previousChild) {
+return previousChild;
+}
+mShadowIterator = nullptr;
+}
+mChild = mChild->GetPreviousSibling();
+} else if (nsContentUtils::IsContentInsertionPoint(mChild)) {
+// If the current child being iterated is a content insertion point
+// then the iterator needs to return the nodes distributed into
+// the content insertion point.
+MatchedNodes assignedChildren = GetMatchedNodesForPoint(mChild);
+if (!assignedChildren.IsEmpty()) {
+mIndexInInserted = assignedChildren.Length();
+return assignedChildren[mIndexInInserted - 1];
+}
+mDefaultChild = mChild->GetLastChild();
+if (mDefaultChild) {
+return mDefaultChild;
+}
+mChild = mChild->GetPreviousSibling();
+} else {
+// mChild is not an insertion point, thus it is the next node to
+// return from this iterator.
+break;
+}
+}
+if (!mChild) {
+mIsFirst = true;
+}
+return mChild;
+}
+} // namespace dom
+} // namespace mozilla

The Tor Browser / file comparison

comparison: content/base/src/ChildIterator.cpp

content/base/src/ChildIterator.cpp