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

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

content/base/src/ChildIterator.cpp

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/. */
 #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 / annotate

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

content/base/src/ChildIterator.cpp