Remove complexity related to m_cachedElementsArrayOffset from LiveNodeListBase

Source/core/html/HTMLCollection.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 161 matching lines @@
     return adoptRef(new HTMLCollection(base, type, DoesNotOverrideItemAfter));
 }
 
 HTMLCollection::~HTMLCollection()
 {
     // HTMLNameCollection removes cache by itself.
     if (type() != WindowNamedItems && type() != DocumentNamedItems)
         ownerNode()->nodeLists()->removeCacheWithAtomicName(this, type());
 }
 
+void HTMLCollection::invalidateCache() const
+{
+    LiveNodeListBase::invalidateCache();
+    invalidateIdNameCacheMaps();
+}
+
 template <class NodeListType>
 inline bool isMatchingElement(const NodeListType*, Element*);
 
 template <> inline bool isMatchingElement(const HTMLCollection* htmlCollection, Element* element)
 {
     CollectionType type = htmlCollection->type();
     if (!element->isHTMLElement() && !(type == DocAll || type == NodeChildren || type == WindowNamedItems))
         return false;
 
     switch (type) {
@@ skipping 193 matching lines @@
 bool ALWAYS_INLINE LiveNodeListBase::isFirstItemCloserThanCachedItem(unsigned offset) const
 {
     ASSERT(isItemCacheValid());
     if (cachedItemOffset() < offset)
         return false;
 
     unsigned distanceFromCachedItem = cachedItemOffset() - offset;
     return offset < distanceFromCachedItem;
 }
 
-ALWAYS_INLINE void LiveNodeListBase::setItemCache(Node* item, unsigned offset, unsigned elementsArrayOffset) const
-{
-    setItemCache(item, offset);
-    if (overridesItemAfter()) {
-        ASSERT_WITH_SECURITY_IMPLICATION(item->isElementNode());
-        static_cast<const HTMLCollection*>(this)->m_cachedElementsArrayOffset = elementsArrayOffset;
-    } else
-        ASSERT(!elementsArrayOffset);
-}
-
 unsigned LiveNodeListBase::length() const
 {
     if (isLengthCacheValid())
         return cachedLength();
 
     item(UINT_MAX);
     ASSERT(isLengthCacheValid());
 
     return cachedLength();
 }
@@ skipping 10 matching lines @@
     ContainerNode* root = rootContainerNode();
     if (!root) {
         // FIMXE: In someTextNode.childNodes case the root is Text. We shouldn't even make a LiveNodeList for that.
         setLengthCache(0);
         return 0;
     }
 
     if (isLengthCacheValid() && !overridesItemAfter() && isLastItemCloserThanLastOrCachedItem(offset)) {
         Node* lastItem = itemBefore(0);
         ASSERT(lastItem);
-        setItemCache(lastItem, cachedLength() - 1, 0);
+        setItemCache(lastItem, cachedLength() - 1);
     } else if (!isItemCacheValid() || isFirstItemCloserThanCachedItem(offset) || (overridesItemAfter() && offset < cachedItemOffset())) {
-        unsigned offsetInArray = 0;
         Node* firstItem;
         if (type() == ChildNodeListType)
             firstItem = root->firstChild();
         else if (isNodeList(type()))
             firstItem = traverseLiveNodeListFirstElement(*root);
         else
-            firstItem = static_cast<const HTMLCollection*>(this)->traverseFirstElement(offsetInArray, *root);
+            firstItem = static_cast<const HTMLCollection*>(this)->traverseFirstElement(*root);
 
         if (!firstItem) {
             setLengthCache(0);
             return 0;
         }
-        setItemCache(firstItem, 0, offsetInArray);
+        setItemCache(firstItem, 0);
         ASSERT(!cachedItemOffset());
     }
 
     if (cachedItemOffset() == offset)
         return cachedItem();
 
     return itemBeforeOrAfterCachedItem(offset, root);
 }
 
 inline Node* LiveNodeListBase::itemBeforeOrAfterCachedItem(unsigned offset, ContainerNode* root) const
 {
     unsigned currentOffset = cachedItemOffset();
     Node* currentItem = cachedItem();
     ASSERT(currentItem);
     ASSERT(currentOffset != offset);
 
     if (offset < cachedItemOffset()) {
         ASSERT(!overridesItemAfter());
         while ((currentItem = itemBefore(currentItem))) {
             ASSERT(currentOffset);
             currentOffset--;
             if (currentOffset == offset) {
-                setItemCache(currentItem, currentOffset, 0);
+                setItemCache(currentItem, currentOffset);
                 return currentItem;
             }
         }
         ASSERT_NOT_REACHED();
         return 0;
     }
 
-    unsigned offsetInArray = 0;
     if (type() == ChildNodeListType)
         currentItem = traverseChildNodeListForwardToOffset(offset, currentItem, currentOffset);
     else if (isNodeList(type()))
         currentItem = traverseLiveNodeListForwardToOffset(offset, toElement(*currentItem), currentOffset, root);
     else
-        currentItem = static_cast<const HTMLCollection*>(this)->traverseForwardToOffset(offset, toElement(*currentItem), currentOffset, offsetInArray, root);
+        currentItem = static_cast<const HTMLCollection*>(this)->traverseForwardToOffset(offset, toElement(*currentItem), currentOffset, root);
 
     if (!currentItem) {
         // Did not find the item. On plus side, we now know the length.
         setLengthCache(currentOffset + 1);
         return 0;
     }
-    setItemCache(currentItem, currentOffset, offsetInArray);
+    setItemCache(currentItem, currentOffset);
     return currentItem;
 }
 
-Element* HTMLCollection::virtualItemAfter(unsigned&, Element*) const
+Element* HTMLCollection::virtualItemAfter(Element*) const
 {
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static inline bool nameShouldBeVisibleInDocumentAll(HTMLElement* element)
 {
     // The document.all collection returns only certain types of elements by name,
     // although it returns any type of element by id.
     return element->hasLocalName(appletTag)
@@ skipping 30 matching lines @@
 
 inline Element* nextMatchingChildElement(const HTMLCollection* nodeList, Element& current, ContainerNode* root)
 {
     Element* next = &current;
     do {
         next = ElementTraversal::nextSkippingChildren(*next, root);
     } while (next && !isMatchingElement(nodeList, next));
     return next;
 }
 
-inline Element* HTMLCollection::traverseFirstElement(unsigned& offsetInArray, ContainerNode& root) const
+inline Element* HTMLCollection::traverseFirstElement(ContainerNode& root) const
 {
     if (overridesItemAfter())
-        return virtualItemAfter(offsetInArray, 0);
-    ASSERT(!offsetInArray);
+        return virtualItemAfter(0);
     if (shouldOnlyIncludeDirectChildren())
         return firstMatchingChildElement(static_cast<const HTMLCollection*>(this), root);
     return firstMatchingElement(static_cast<const HTMLCollection*>(this), root);
 }
 
-inline Element* HTMLCollection::traverseNextElement(unsigned& offsetInArray, Element& previous, ContainerNode* root) const
+inline Element* HTMLCollection::traverseNextElement(Element& previous, ContainerNode* root) const
 {
     if (overridesItemAfter())
-        return virtualItemAfter(offsetInArray, &previous);
-    ASSERT(!offsetInArray);
+        return virtualItemAfter(&previous);
     if (shouldOnlyIncludeDirectChildren())
         return nextMatchingChildElement(this, previous, root);
     return nextMatchingElement(this, previous, root);
 }
 
-inline Element* HTMLCollection::traverseForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset, unsigned& offsetInArray, ContainerNode* root) const
+inline Element* HTMLCollection::traverseForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset, ContainerNode* root) const
 {
     ASSERT(currentOffset < offset);
     if (overridesItemAfter()) {
-        offsetInArray = m_cachedElementsArrayOffset;
         Element* next = &currentElement;
-        while ((next = virtualItemAfter(offsetInArray, next))) {
+        while ((next = virtualItemAfter(next))) {
             if (++currentOffset == offset)
                 return next;
         }
         return 0;
     }
     if (shouldOnlyIncludeDirectChildren()) {
         Element* next = &currentElement;
         while ((next = nextMatchingChildElement(this, *next, root))) {
             if (++currentOffset == offset)
                 return next;
         }
         return 0;
     }
     return traverseMatchingElementsForwardToOffset(this, offset, currentElement, currentOffset, root);
 }
 
 Node* HTMLCollection::namedItem(const AtomicString& name) const
 {
     // http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/nameditem.asp
     // This method first searches for an object with a matching id
     // attribute. If a match is not found, the method then searches for an
     // object with a matching name attribute, but only on those elements
     // that are allowed a name attribute.
 
     ContainerNode* root = rootContainerNode();
     if (!root)
         return 0;
 
-    unsigned arrayOffset = 0;
     unsigned i = 0;
-    for (Element* element = traverseFirstElement(arrayOffset, *root); element; element = traverseNextElement(arrayOffset, *element, root)) {
+    for (Element* element = traverseFirstElement(*root); element; element = traverseNextElement(*element, root)) {
         if (checkForNameMatch(element, /* checkName */ false, name)) {
-            setItemCache(element, i, arrayOffset);
+            setItemCache(element, i);
             return element;
         }
         i++;
     }
 
     i = 0;
-    for (Element* element = traverseFirstElement(arrayOffset, *root); element; element = traverseNextElement(arrayOffset, *element, root)) {
+    for (Element* element = traverseFirstElement(*root); element; element = traverseNextElement(*element, root)) {
         if (checkForNameMatch(element, /* checkName */ true, name)) {
-            setItemCache(element, i, arrayOffset);
+            setItemCache(element, i);
             return element;
         }
         i++;
     }
 
     return 0;
 }
 
 void HTMLCollection::updateNameCache() const
 {
     if (hasNameCache())
         return;
 
     ContainerNode* root = rootContainerNode();
     if (!root)
         return;
 
-    unsigned arrayOffset = 0;
-    for (Element* element = traverseFirstElement(arrayOffset, *root); element; element = traverseNextElement(arrayOffset, *element, root)) {
+    for (Element* element = traverseFirstElement(*root); element; element = traverseNextElement(*element, root)) {
         const AtomicString& idAttrVal = element->getIdAttribute();
         if (!idAttrVal.isEmpty())
             appendIdCache(idAttrVal, element);
         if (!element->isHTMLElement())
             continue;
         const AtomicString& nameAttrVal = element->getNameAttribute();
         if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal && (type() != DocAll || nameShouldBeVisibleInDocumentAll(toHTMLElement(element))))
             appendNameCache(nameAttrVal, element);
     }
 
@@ skipping 20 matching lines @@
 
 void HTMLCollection::append(NodeCacheMap& map, const AtomicString& key, Element* element)
 {
     OwnPtr<Vector<Element*> >& vector = map.add(key.impl(), nullptr).iterator->value;
     if (!vector)
         vector = adoptPtr(new Vector<Element*>);
     vector->append(element);
 }
 
 } // namespace WebCore