Have getElementsByClassName() / getElementsByTagName*() return an HTMLCollection

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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/html/HTMLCollection.h"
 
 #include "HTMLNames.h"
-#include "core/dom/ClassNodeList.h"
+#include "core/dom/ClassCollection.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/NodeList.h"
 #include "core/dom/NodeRareData.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLObjectElement.h"
 #include "core/html/HTMLOptionElement.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 static bool shouldOnlyIncludeDirectChildren(CollectionType type)
 {
     switch (type) {
+    case ClassCollectionType:
+    case TagCollectionType:
+    case HTMLTagCollectionType:
     case DocAll:
     case DocAnchors:
     case DocApplets:
     case DocEmbeds:
     case DocForms:
     case DocImages:
     case DocLinks:
     case DocScripts:
     case DocumentNamedItems:
     case MapAreas:
     case TableRows:
     case SelectOptions:
     case SelectedOptions:
     case DataListOptions:
     case WindowNamedItems:
     case FormControls:
         return false;
     case NodeChildren:
     case TRCells:
     case TSectionRows:
     case TableTBodies:
         return true;
     case ChildNodeListType:
-    case ClassNodeListType:
     case NameNodeListType:
-    case TagNodeListType:
-    case HTMLTagNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
 static NodeListRootType rootTypeFromCollectionType(CollectionType type)
 {
     switch (type) {
     case DocImages:
     case DocApplets:
     case DocEmbeds:
     case DocForms:
     case DocLinks:
     case DocAnchors:
     case DocScripts:
     case DocAll:
     case WindowNamedItems:
     case DocumentNamedItems:
     case FormControls:
         return NodeListIsRootedAtDocument;
+    case ClassCollectionType:
+    case TagCollectionType:
+    case HTMLTagCollectionType:
     case NodeChildren:
     case TableTBodies:
     case TSectionRows:
     case TableRows:
     case TRCells:
     case SelectOptions:
     case SelectedOptions:
     case DataListOptions:
     case MapAreas:
         return NodeListIsRootedAtNode;
     case ChildNodeListType:
-    case ClassNodeListType:
     case NameNodeListType:
-    case TagNodeListType:
-    case HTMLTagNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
     ASSERT_NOT_REACHED();
     return NodeListIsRootedAtNode;
 }
 
 static NodeListInvalidationType invalidationTypeExcludingIdAndNameAttributes(CollectionType type)
 {
     switch (type) {
+    case TagCollectionType:
+    case HTMLTagCollectionType:
     case DocImages:
     case DocEmbeds:
     case DocForms:
     case DocScripts:
     case DocAll:
     case NodeChildren:
     case TableTBodies:
     case TSectionRows:
     case TableRows:
     case TRCells:
     case SelectOptions:
     case MapAreas:
         return DoNotInvalidateOnAttributeChanges;
     case DocApplets:
     case SelectedOptions:
     case DataListOptions:
         // FIXME: We can do better some day.
         return InvalidateOnAnyAttrChange;
     case DocAnchors:
         return InvalidateOnNameAttrChange;
     case DocLinks:
         return InvalidateOnHRefAttrChange;
     case WindowNamedItems:
         return InvalidateOnIdNameAttrChange;
     case DocumentNamedItems:
         return InvalidateOnIdNameAttrChange;
     case FormControls:
         return InvalidateForFormControls;
+    case ClassCollectionType:
+        return InvalidateOnClassAttrChange;
     case ChildNodeListType:
-    case ClassNodeListType:
     case NameNodeListType:
-    case TagNodeListType:
-    case HTMLTagNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
     ASSERT_NOT_REACHED();
     return DoNotInvalidateOnAttributeChanges;
 }
 
 HTMLCollection::HTMLCollection(ContainerNode* ownerNode, CollectionType type, ItemAfterOverrideType itemAfterOverrideType)
     : LiveNodeListBase(ownerNode, rootTypeFromCollectionType(type), invalidationTypeExcludingIdAndNameAttributes(type),
         WebCore::shouldOnlyIncludeDirectChildren(type), type, itemAfterOverrideType)
     , m_isNameCacheValid(false)
 {
     ScriptWrappable::init(this);
 }
 
 PassRefPtr<HTMLCollection> HTMLCollection::create(ContainerNode* base, CollectionType type)
 {
     return adoptRef(new HTMLCollection(base, type, DoesNotOverrideItemAfter));
 }
 
 HTMLCollection::~HTMLCollection()
 {
-    // HTMLNameCollection removes cache by itself.
-    if (type() != WindowNamedItems && type() != DocumentNamedItems)
+    // HTMLNameCollection, ClassCollection and TagCollection remove cache by themselves.
+    if (type() != WindowNamedItems && type() != DocumentNamedItems && type() != ClassCollectionType
+        && type() != HTMLTagCollectionType && type() != TagCollectionType) {
         ownerNode()->nodeLists()->removeCacheWithAtomicName(this, type());
+    }
 }
 
 void HTMLCollection::invalidateCache() const
 {
     LiveNodeListBase::invalidateCache();
     invalidateIdNameCacheMaps();
 }
 
 template <class NodeListType>
 inline bool isMatchingElement(const NodeListType&, const Element&);
 
 template <> inline bool isMatchingElement(const HTMLCollection& htmlCollection, const Element& element)
 {
     CollectionType type = htmlCollection.type();
-    if (!element.isHTMLElement() && !(type == DocAll || type == NodeChildren || type == WindowNamedItems))
+
+    // These collections apply to any kind of Elements, not just HTMLElements.
+    switch (type) {
+    case DocAll:
+    case NodeChildren:
+        return true;
+    case ClassCollectionType:
+        return static_cast<const ClassCollection&>(htmlCollection).elementMatches(element);
+    case TagCollectionType:
+        return static_cast<const TagCollection&>(htmlCollection).elementMatches(element);
+    case HTMLTagCollectionType:
+        return static_cast<const HTMLTagCollection&>(htmlCollection).elementMatches(element);
+    default:
+        break;
+    }
+
+    // The following only applies to HTMLElements.
+    if (!element.isHTMLElement())
         return false;
 
     switch (type) {
     case DocImages:
         return element.hasLocalName(imgTag);
     case DocScripts:
         return element.hasLocalName(scriptTag);
     case DocForms:
         return element.hasLocalName(formTag);
     case TableTBodies:
@@ skipping 16 matching lines @@
     case MapAreas:
         return element.hasLocalName(areaTag);
     case DocApplets:
         return element.hasLocalName(appletTag) || (element.hasLocalName(objectTag) && toHTMLObjectElement(element).containsJavaApplet());
     case DocEmbeds:
         return element.hasLocalName(embedTag);
     case DocLinks:
         return (element.hasLocalName(aTag) || element.hasLocalName(areaTag)) && element.fastHasAttribute(hrefAttr);
     case DocAnchors:
         return element.hasLocalName(aTag) && element.fastHasAttribute(nameAttr);
+    case ClassCollectionType:
+    case TagCollectionType:
+    case HTMLTagCollectionType:
     case DocAll:
     case NodeChildren:
-        return true;
     case FormControls:
     case DocumentNamedItems:
     case TableRows:
     case WindowNamedItems:
     case ChildNodeListType:
-    case ClassNodeListType:
     case NameNodeListType:
-    case TagNodeListType:
-    case HTMLTagNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         ASSERT_NOT_REACHED();
     }
     return false;
 }
 
 template <> inline bool isMatchingElement(const LiveNodeList& nodeList, const Element& element)
 {
     return nodeList.nodeMatches(element);
 }
 
-template <> inline bool isMatchingElement(const HTMLTagNodeList& nodeList, const Element& element)
-{
-    return nodeList.nodeMatchesInlined(element);
-}
-
-template <> inline bool isMatchingElement(const ClassNodeList& nodeList, const Element& element)
-{
-    return nodeList.nodeMatchesInlined(element);
-}
-
 static Node* previousNode(const Node& base, const Node& previous, bool onlyIncludeDirectChildren)
 {
     return onlyIncludeDirectChildren ? previous.previousSibling() : NodeTraversal::previous(previous, &base);
 }
 
 static inline Node* lastDescendant(const Node& node)
 {
     Node* descendant = node.lastChild();
     for (Node* current = descendant; current; current = current->lastChild())
         descendant = current;
@@ skipping 78 matching lines @@
 }
 
 // FIXME: This should be in LiveNodeList.cpp but it needs to stay here until firstMatchingElement()
 // and others are moved to a separate header.
 inline Node* LiveNodeList::traverseToFirstElement(const ContainerNode& root) const
 {
     ASSERT(isLiveNodeListType(type()));
     switch (type()) {
     case ChildNodeListType:
         return root.firstChild();
-    case HTMLTagNodeListType:
-        return firstMatchingElement(static_cast<const HTMLTagNodeList&>(*this), root);
-    case ClassNodeListType:
-        return firstMatchingElement(static_cast<const ClassNodeList&>(*this), root);
     default:
         return firstMatchingElement(static_cast<const LiveNodeList&>(*this), root);
     }
 }
 
 // FIXME: This should be in LiveNodeList.cpp but it needs to stay here until traverseMatchingElementsForwardToOffset()
 // and others are moved to a separate header.
 inline Node* LiveNodeList::traverseForwardToOffset(unsigned offset, Node& currentNode, unsigned& currentOffset, const ContainerNode& root) const
 {
     switch (type()) {
     case ChildNodeListType:
         return traverseSiblingsForwardToOffset(offset, currentNode, currentOffset);
-    case HTMLTagNodeListType:
-        return traverseMatchingElementsForwardToOffset(static_cast<const HTMLTagNodeList&>(*this), offset, toElement(currentNode), currentOffset, root);
-    case ClassNodeListType:
-        return traverseMatchingElementsForwardToOffset(static_cast<const ClassNodeList&>(*this), offset, toElement(currentNode), currentOffset, root);
     default:
         return traverseMatchingElementsForwardToOffset(*this, offset, toElement(currentNode), currentOffset, root);
     }
 }
 
 bool ALWAYS_INLINE LiveNodeListBase::isLastItemCloserThanLastOrCachedItem(unsigned offset) const
 {
     ASSERT(isLengthCacheValid());
     unsigned distanceFromLastItem = cachedLength() - offset;
     if (!cachedItem())
@@ skipping 253 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