Do not cause unnecessary node lists invalidation on id/name attribute change

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.
  * Copyright (C) 2014 Samsung Electronics. 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 146 matching lines @@
         break;
     }
     ASSERT_NOT_REACHED();
     return DoNotInvalidateOnAttributeChanges;
 }
 
 HTMLCollection::HTMLCollection(ContainerNode* ownerNode, CollectionType type, ItemAfterOverrideType itemAfterOverrideType)
     : LiveNodeListBase(ownerNode, rootTypeFromCollectionType(type), invalidationTypeExcludingIdAndNameAttributes(type), type)
     , m_overridesItemAfter(itemAfterOverrideType == OverridesItemAfter)
     , m_shouldOnlyIncludeDirectChildren(shouldTypeOnlyIncludeDirectChildren(type))
-    , m_isNameCacheValid(false)
+    , m_hasValidIdNameCache(false)
 {
     ScriptWrappable::init(this);
 }
 
 PassRefPtr<HTMLCollection> HTMLCollection::create(ContainerNode* base, CollectionType type)
 {
     return adoptRef(new HTMLCollection(base, type, DoesNotOverrideItemAfter));
 }
 
 HTMLCollection::~HTMLCollection()
 {
+    if (hasValidIdNameCache())
+        unregisterIdNameCacheFromDocument(document());
     // HTMLNameCollection, ClassCollection and TagCollection remove cache by themselves.
     if (type() != WindowNamedItems && type() != DocumentNamedItems && type() != ClassCollectionType
         && type() != HTMLTagCollectionType && type() != TagCollectionType) {
         ownerNode()->nodeLists()->removeCache(this, type());
     }
 }
 
-void HTMLCollection::invalidateCache() const
+void HTMLCollection::invalidateCache(Document* oldDocument) const
 {
     m_collectionIndexCache.invalidate();
-    invalidateIdNameCacheMaps();
+    invalidateIdNameCacheMaps(oldDocument);
 }
 
 template <class NodeListType>
 inline bool isMatchingElement(const NodeListType&, const Element&);
 
 template <> inline bool isMatchingElement(const HTMLCollection& htmlCollection, const Element& element)
 {
     CollectionType type = htmlCollection.type();
 
     // These collections apply to any kind of Elements, not just HTMLElements.
@@ skipping 269 matching lines @@
     }
 }
 
 Element* 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.
-    updateNameCache();
+    updateIdNameCache();
 
     Vector<Element*>* idResults = idCache(name);
     if (idResults && !idResults->isEmpty())
         return idResults->first();
 
     Vector<Element*>* nameResults = nameCache(name);
     if (nameResults && !nameResults->isEmpty())
         return nameResults->first();
 
     return 0;
@@ skipping 32 matching lines @@
                 names.append(idAttribute);
         }
     }
 }
 
 void HTMLCollection::namedPropertyEnumerator(Vector<String>& names, ExceptionState&)
 {
     supportedPropertyNames(names);
 }
 
-void HTMLCollection::updateNameCache() const
+void HTMLCollection::updateIdNameCache() const
 {
-    if (hasNameCache())
+    if (hasValidIdNameCache())
         return;
 
     ContainerNode& root = rootNode();
     for (Element* element = traverseToFirstElement(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);
     }
 
-    setHasNameCache();
+    setHasValidIdNameCache();
 }
 
 void HTMLCollection::namedItems(const AtomicString& name, Vector<RefPtr<Element> >& result) const
 {
     ASSERT(result.isEmpty());
     if (name.isEmpty())
         return;
 
-    updateNameCache();
+    updateIdNameCache();
 
     Vector<Element*>* idResults = idCache(name);
     Vector<Element*>* nameResults = nameCache(name);
 
     for (unsigned i = 0; idResults && i < idResults->size(); ++i)
         result.append(idResults->at(i));
 
     for (unsigned i = 0; nameResults && i < nameResults->size(); ++i)
         result.append(nameResults->at(i));
 }
 
 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