Extract named items caches in HTMLCollection as a class
authorrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 27 Feb 2014 03:35:22 +0000 (03:35 +0000)
committerrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 27 Feb 2014 03:35:22 +0000 (03:35 +0000)
https://bugs.webkit.org/show_bug.cgi?id=129365

Reviewed by Antti Koivisto.

Extracted CollectionNamedElementCache, like CollectionIndexCache, out of HTMLCollection.
We can move more named item related functions into this class in the future.

HTMLCollection's member variables m_isNameCacheValid, m_idCache, and m_nameCache were replaced by
a single unique_ptr that holds an instance of CollectionNamedElementCache since this object rarely
exists in most HTMLCollections.

Also removed m_isItemRefElementsCacheValid since it was only used by Microdata API removed in r153772
and renamed a whole bunch of member functions and variables for consistency.

* dom/Document.cpp:
(WebCore::Document::collectionCachedIdNameMap):
(WebCore::Document::collectionWillClearIdNameMap):
* dom/Document.h:
* dom/NodeRareData.h:
(WebCore::NodeListsNodeData::adoptDocument):
* html/HTMLAllCollection.cpp:
(WebCore::HTMLAllCollection::namedItemWithIndex):
* html/HTMLCollection.cpp:
(WebCore::HTMLCollection::HTMLCollection):
(WebCore::HTMLCollection::~HTMLCollection):
(WebCore::HTMLCollection::invalidateCache):
(WebCore::HTMLCollection::invalidateNamedElementCache): Renamed from invalidateIdNameCacheMaps.
(WebCore::HTMLCollection::namedItem):
(WebCore::HTMLCollection::updateNamedElementCache): Renamed from updateNameCache.
(WebCore::HTMLCollection::namedItems):

* html/HTMLCollection.h:
(WebCore::CollectionNamedElementCache::findElementsWithId): Renamed from HTMLCollection::idCache.
(WebCore::CollectionNamedElementCache::findElementsWithName): Renamed from HTMLCollection::nameCache.
(WebCore::CollectionNamedElementCache::appendIdCache): Moved from HTMLCollection.
(WebCore::CollectionNamedElementCache::appendNameCache): Ditto.
(WebCore::CollectionNamedElementCache::find): Ditto.
(WebCore::CollectionNamedElementCache::append): Ditto.

(WebCore::HTMLCollection::invalidateCache):
(WebCore::HTMLCollection::hasNamedElementCache): Renamed from hasIdNameCache.
(WebCore::HTMLCollection::createNameItemCache): Added.
(WebCore::HTMLCollection::namedItemCaches): Added.

* html/HTMLFormControlsCollection.cpp:
(WebCore::HTMLFormControlsCollection::updateNamedElementCache):
* html/HTMLFormControlsCollection.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@164772 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/Document.h
Source/WebCore/dom/NodeRareData.h
Source/WebCore/html/HTMLAllCollection.cpp
Source/WebCore/html/HTMLCollection.cpp
Source/WebCore/html/HTMLCollection.h
Source/WebCore/html/HTMLFormControlsCollection.cpp
Source/WebCore/html/HTMLFormControlsCollection.h

index 99e94cb84566efa66c1ab417769602d85132a2be..b3a692a0e0fe57f60b9f61d1a908f38d33596e04 100644 (file)
@@ -1,3 +1,92 @@
+2014-02-26  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Extract named items caches in HTMLCollection as a class
+        https://bugs.webkit.org/show_bug.cgi?id=129365
+
+        Reviewed by Antti Koivisto.
+
+        Extracted CollectionNamedElementCache, like CollectionIndexCache, out of HTMLCollection.
+        We can move more named item related functions into this class in the future.
+
+        HTMLCollection's member variables m_isNameCacheValid, m_idCache, and m_nameCache were replaced by
+        a single unique_ptr that holds an instance of CollectionNamedElementCache since this object rarely
+        exists in most HTMLCollections.
+
+        Also removed m_isItemRefElementsCacheValid since it was only used by Microdata API removed in r153772
+        and renamed a whole bunch of member functions and variables for consistency.
+
+        * dom/Document.cpp:
+        (WebCore::Document::collectionCachedIdNameMap):
+        (WebCore::Document::collectionWillClearIdNameMap):
+        * dom/Document.h:
+        * dom/NodeRareData.h:
+        (WebCore::NodeListsNodeData::adoptDocument):
+        * html/HTMLAllCollection.cpp:
+        (WebCore::HTMLAllCollection::namedItemWithIndex):
+        * html/HTMLCollection.cpp:
+        (WebCore::HTMLCollection::HTMLCollection):
+        (WebCore::HTMLCollection::~HTMLCollection):
+        (WebCore::HTMLCollection::invalidateCache):
+        (WebCore::HTMLCollection::invalidateNamedElementCache): Renamed from invalidateIdNameCacheMaps.
+        (WebCore::HTMLCollection::namedItem):
+        (WebCore::HTMLCollection::updateNamedElementCache): Renamed from updateNameCache.
+        (WebCore::HTMLCollection::namedItems):
+
+        * html/HTMLCollection.h:
+        (WebCore::CollectionNamedElementCache::findElementsWithId): Renamed from HTMLCollection::idCache.
+        (WebCore::CollectionNamedElementCache::findElementsWithName): Renamed from HTMLCollection::nameCache.
+        (WebCore::CollectionNamedElementCache::appendIdCache): Moved from HTMLCollection.
+        (WebCore::CollectionNamedElementCache::appendNameCache): Ditto.
+        (WebCore::CollectionNamedElementCache::find): Ditto.
+        (WebCore::CollectionNamedElementCache::append): Ditto.
+
+        (WebCore::HTMLCollection::invalidateCache):
+        (WebCore::HTMLCollection::hasNamedElementCache): Renamed from hasIdNameCache.
+        (WebCore::HTMLCollection::createNameItemCache): Added.
+        (WebCore::HTMLCollection::namedItemCaches): Added.
+
+        * html/HTMLFormControlsCollection.cpp:
+        (WebCore::HTMLFormControlsCollection::updateNamedElementCache):
+        * html/HTMLFormControlsCollection.h:
+
+2014-02-26  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Extract named items caches in HTMLCollection as a class
+        https://bugs.webkit.org/show_bug.cgi?id=129365
+
+        Reviewed by Antti Koivisto.
+
+        Extracted CollectionNamedItemCaches, like CollectionIndexCache, out of HTMLCollection.
+        We can move more named item related functions into this class in the future.
+
+        HTMLCollection's member variables m_isNameCacheValid, m_idCache, and m_nameCache were replaced by
+        a single unique_ptr that holds an instance of CollectionNamedItemCaches since this object rarely
+        exists in most HTMLCollections.
+
+        Also removed m_isItemRefElementsCacheValid since it was only used by Microdata API removed in r153772.
+
+        * html/HTMLAllCollection.cpp:
+        (WebCore::HTMLAllCollection::namedItemWithIndex):
+        * html/HTMLCollection.cpp:
+        (WebCore::HTMLCollection::HTMLCollection):
+        (WebCore::HTMLCollection::invalidateCache):
+        (WebCore::HTMLCollection::invalidateIdNameCacheMaps):
+        (WebCore::HTMLCollection::namedItem):
+        (WebCore::HTMLCollection::updateNameCache):
+        (WebCore::HTMLCollection::namedItems):
+        * html/HTMLCollection.h:
+        (WebCore::CollectionNamedItemCaches::idCache):
+        (WebCore::CollectionNamedItemCaches::nameCache):
+        (WebCore::CollectionNamedItemCaches::appendIdCache):
+        (WebCore::CollectionNamedItemCaches::appendNameCache):
+        (WebCore::CollectionNamedItemCaches::find):
+        (WebCore::CollectionNamedItemCaches::append):
+        (WebCore::HTMLCollection::hasIdNameCache):
+        (WebCore::HTMLCollection::createNameItemCaches):
+        (WebCore::HTMLCollection::namedItemCachesAssertingExistence):
+        * html/HTMLFormControlsCollection.cpp:
+        (WebCore::HTMLFormControlsCollection::updateNameCache):
+
 2014-02-26  Ryosuke Niwa  <rniwa@webkit.org>
 
         Indenting an indented image element resulted in an extra indentation
index bbe606f659c84c4ad3cc71400197ba01ffb35b3a..84d37f6a7271b4e6bda8b2d361c6956d995ed72f 100644 (file)
@@ -3479,13 +3479,13 @@ void Document::unregisterCollection(HTMLCollection& collection, bool hasIdNameMa
 
 void Document::collectionCachedIdNameMap(const HTMLCollection& collection)
 {
-    ASSERT_UNUSED(collection, collection.hasIdNameCache());
+    ASSERT_UNUSED(collection, collection.hasNamedElementCache());
     m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]++;
 }
 
 void Document::collectionWillClearIdNameMap(const HTMLCollection& collection)
 {
-    ASSERT_UNUSED(collection, collection.hasIdNameCache());
+    ASSERT_UNUSED(collection, collection.hasNamedElementCache());
     ASSERT(m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]);
     m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]--;
 }
index 89f71c5230c61fb2e4ab2a42d6a901511b3534f7..cf22698ad693cb649b2a56ecd901941603208df4 100644 (file)
@@ -761,8 +761,8 @@ public:
 
     void registerNodeList(LiveNodeList&);
     void unregisterNodeList(LiveNodeList&);
-    void registerCollection(HTMLCollection&, bool hasIdNameCache);
-    void unregisterCollection(HTMLCollection&, bool hasIdNameCache);
+    void registerCollection(HTMLCollection&, bool hasNamedElementCache);
+    void unregisterCollection(HTMLCollection&, bool hasNamedElementCache);
     void collectionCachedIdNameMap(const HTMLCollection&);
     void collectionWillClearIdNameMap(const HTMLCollection&);
     bool shouldInvalidateNodeListAndCollectionCaches(const QualifiedName* attrName = nullptr) const;
index 9dab21115634482cdb054df343a273a807047298..f8f3d7e8954e45ccdcba785f613d9a777e3bebc5 100644 (file)
@@ -254,8 +254,8 @@ public:
 
         for (auto it : m_cachedCollections) {
             HTMLCollection& collection = *it.value;
-            oldDocument->unregisterCollection(collection, collection.hasIdNameCache());
-            newDocument->registerCollection(collection, collection.hasIdNameCache());
+            oldDocument->unregisterCollection(collection, collection.hasNamedElementCache());
+            newDocument->registerCollection(collection, collection.hasNamedElementCache());
             collection.invalidateCache();
         }
     }
index 1812ab176a183dd58cc6289c15e436f7417153b4..f2afbab3ea8ec882612cc4ca729e32e1a730bb2a 100644 (file)
@@ -46,17 +46,18 @@ HTMLAllCollection::~HTMLAllCollection()
 
 Node* HTMLAllCollection::namedItemWithIndex(const AtomicString& name, unsigned index) const
 {
-    updateNameCache();
+    updateNamedElementCache();
+    const CollectionNamedElementCache& cache = namedItemCaches();
 
-    if (Vector<Element*>* cache = idCache(name)) {
-        if (index < cache->size())
-            return cache->at(index);
-        index -= cache->size();
+    if (const Vector<Element*>* elements = cache.findElementsWithId(name)) {
+        if (index < elements->size())
+            return elements->at(index);
+        index -= elements->size();
     }
 
-    if (Vector<Element*>* cache = nameCache(name)) {
-        if (index < cache->size())
-            return cache->at(index);
+    if (const Vector<Element*>* elements = cache.findElementsWithName(name)) {
+        if (index < elements->size())
+            return elements->at(index);
     }
 
     return 0;
index f339c25ee82aa63ab2483c5196e8ed4375d20908..b0c991633900b9525b6796508734b0d58a0030da 100644 (file)
@@ -133,19 +133,17 @@ static NodeListInvalidationType invalidationTypeExcludingIdAndNameAttributes(Col
 
 HTMLCollection::HTMLCollection(ContainerNode& ownerNode, CollectionType type, ElementTraversalType traversalType)
     : m_ownerNode(ownerNode)
-    , m_rootType(rootTypeFromCollectionType(type))
+    , m_collectionType(type)
     , m_invalidationType(invalidationTypeExcludingIdAndNameAttributes(type))
+    , m_rootType(rootTypeFromCollectionType(type))
     , m_shouldOnlyIncludeDirectChildren(shouldOnlyIncludeDirectChildren(type))
-    , m_isNameCacheValid(false)
-    , m_collectionType(type)
     , m_usesCustomForwardOnlyTraversal(traversalType == CustomForwardOnlyTraversal)
-    , m_isItemRefElementsCacheValid(false)
 {
     ASSERT(m_rootType == static_cast<unsigned>(rootTypeFromCollectionType(type)));
     ASSERT(m_invalidationType == static_cast<unsigned>(invalidationTypeExcludingIdAndNameAttributes(type)));
     ASSERT(m_collectionType == static_cast<unsigned>(type));
 
-    document().registerCollection(*this, hasIdNameCache());
+    document().registerCollection(*this, hasNamedElementCache());
 }
 
 PassRefPtr<HTMLCollection> HTMLCollection::create(ContainerNode& base, CollectionType type)
@@ -155,7 +153,7 @@ PassRefPtr<HTMLCollection> HTMLCollection::create(ContainerNode& base, Collectio
 
 HTMLCollection::~HTMLCollection()
 {
-    document().unregisterCollection(*this, hasIdNameCache());
+    document().unregisterCollection(*this, hasNamedElementCache());
     // HTMLNameCollection removes cache by itself.
     if (type() != WindowNamedItems && type() != DocumentNamedItems)
         ownerNode().nodeLists()->removeCachedCollection(this);
@@ -367,18 +365,15 @@ Element* HTMLCollection::collectionTraverseBackward(Element& current, unsigned c
 void HTMLCollection::invalidateCache() const
 {
     m_indexCache.invalidate();
-    m_isItemRefElementsCacheValid = false;
-    if (hasIdNameCache())
-        invalidateIdNameCacheMaps();
+    if (hasNamedElementCache())
+        invalidateNamedElementCache();
 }
 
-void HTMLCollection::invalidateIdNameCacheMaps() const
+void HTMLCollection::invalidateNamedElementCache() const
 {
-    ASSERT(hasIdNameCache());
+    ASSERT(hasNamedElementCache());
     document().collectionWillClearIdNameMap(*this);
-    m_isNameCacheValid = false;
-    m_idCache.clear();
-    m_nameCache.clear();
+    m_namedElementCache = nullptr;
 }
 
 Node* HTMLCollection::namedItem(const AtomicString& name) const
@@ -414,14 +409,15 @@ Node* HTMLCollection::namedItem(const AtomicString& name) const
     }
 
     // The pathological case. We need to walk the entire subtree.
-    updateNameCache();
+    updateNamedElementCache();
+    ASSERT(m_namedElementCache);
 
-    if (Vector<Element*>* idResults = idCache(name)) {
+    if (const Vector<Element*>* idResults = m_namedElementCache->findElementsWithId(name)) {
         if (idResults->size())
             return idResults->at(0);
     }
 
-    if (Vector<Element*>* nameResults = nameCache(name)) {
+    if (const Vector<Element*>* nameResults = m_namedElementCache->findElementsWithName(name)) {
         if (nameResults->size())
             return nameResults->at(0);
     }
@@ -429,26 +425,25 @@ Node* HTMLCollection::namedItem(const AtomicString& name) const
     return 0;
 }
 
-void HTMLCollection::updateNameCache() const
+void HTMLCollection::updateNamedElementCache() const
 {
-    if (hasIdNameCache())
+    if (hasNamedElementCache())
         return;
 
     ContainerNode& root = rootNode();
+    CollectionNamedElementCache& cache = createNameItemCache();
 
     unsigned count;
     for (Element* element = firstElement(root); element; element = traverseForward(*element, 1, count, root)) {
         const AtomicString& idAttrVal = element->getIdAttribute();
         if (!idAttrVal.isEmpty())
-            appendIdCache(idAttrVal, element);
+            cache.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);
+            cache.appendNameCache(nameAttrVal, element);
     }
-
-    setHasIdNameCache();
 }
 
 bool HTMLCollection::hasNamedItem(const AtomicString& name) const
@@ -463,10 +458,11 @@ void HTMLCollection::namedItems(const AtomicString& name, Vector<Ref<Element>>&
     if (name.isEmpty())
         return;
 
-    updateNameCache();
+    updateNamedElementCache();
+    ASSERT(m_namedElementCache);
 
-    Vector<Element*>* idResults = idCache(name);
-    Vector<Element*>* nameResults = nameCache(name);
+    const Vector<Element*>* idResults = m_namedElementCache->findElementsWithId(name);
+    const Vector<Element*>* nameResults = m_namedElementCache->findElementsWithName(name);
 
     for (unsigned i = 0; idResults && i < idResults->size(); ++i)
         result.append(*idResults->at(i));
@@ -480,12 +476,4 @@ PassRefPtr<NodeList> HTMLCollection::tags(const String& name)
     return ownerNode().getElementsByTagName(name);
 }
 
-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
index 7e2379998a6e9c5c794e829761941ad8a10a86e2..2d210b76ecf096f486b67b487247b350ba17f388 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * 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) 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012, 2013, 2014 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
@@ -38,6 +38,32 @@ namespace WebCore {
 
 class Element;
 
+class CollectionNamedElementCache {
+public:
+    const Vector<Element*>* findElementsWithId(const AtomicString& id) const { return find(m_idToElementsMap, id); }
+    const Vector<Element*>* findElementsWithName(const AtomicString& name) const { return find(m_nameToElementsMap, name); }
+
+    void appendIdCache(const AtomicString& id, Element* element) { return append(m_idToElementsMap, id, element); }
+    void appendNameCache(const AtomicString& name, Element* element)  { return append(m_nameToElementsMap, name, element); }
+
+private:
+    typedef HashMap<AtomicStringImpl*, Vector<Element*>> StringToElementsMap;
+
+    static const Vector<Element*>* find(const StringToElementsMap& map, const AtomicString& key)
+    {
+        auto it = map.find(key.impl());
+        return it != map.end() ? &it->value : nullptr;
+    }
+
+    static void append(StringToElementsMap& map, const AtomicString& key, Element* element)
+    {
+        map.add(key.impl(), Vector<Element*>()).iterator->value.append(element);
+    }
+
+    StringToElementsMap m_idToElementsMap;
+    StringToElementsMap m_nameToElementsMap;
+};
+
 class HTMLCollection : public ScriptWrappable, public RefCounted<HTMLCollection> {
 public:
     static PassRefPtr<HTMLCollection> create(ContainerNode& base, CollectionType);
@@ -61,8 +87,8 @@ public:
     {
         if (!attrName || shouldInvalidateTypeOnAttributeChange(invalidationType(), *attrName))
             invalidateCache();
-        else if (hasIdNameCache() && (*attrName == HTMLNames::idAttr || *attrName == HTMLNames::nameAttr))
-            invalidateIdNameCacheMaps();
+        else if (hasNamedElementCache() && (*attrName == HTMLNames::idAttr || *attrName == HTMLNames::nameAttr))
+            invalidateNamedElementCache();
     }
     virtual void invalidateCache() const;
 
@@ -73,60 +99,53 @@ public:
     Element* collectionTraverseBackward(Element&, unsigned count) const;
     bool collectionCanTraverseBackward() const { return !m_usesCustomForwardOnlyTraversal; }
 
-    bool hasIdNameCache() const { return m_isNameCacheValid; }
+    bool hasNamedElementCache() const { return !!m_namedElementCache; }
 
 protected:
     enum ElementTraversalType { NormalTraversal, CustomForwardOnlyTraversal };
     HTMLCollection(ContainerNode& base, CollectionType, ElementTraversalType = NormalTraversal);
 
-    void invalidateIdNameCacheMaps() const;
-    virtual void updateNameCache() const;
-
-    typedef HashMap<AtomicStringImpl*, OwnPtr<Vector<Element*>>> NodeCacheMap;
-    Vector<Element*>* idCache(const AtomicString& name) const { return m_idCache.get(name.impl()); }
-    Vector<Element*>* nameCache(const AtomicString& name) const { return m_nameCache.get(name.impl()); }
-    void appendIdCache(const AtomicString& name, Element* element) const { append(m_idCache, name, element); }
-    void appendNameCache(const AtomicString& name, Element* element) const { append(m_nameCache, name, element); }
+    virtual void updateNamedElementCache() const;
 
     Document& document() const { return m_ownerNode->document(); }
     ContainerNode& rootNode() const;
     bool usesCustomForwardOnlyTraversal() const { return m_usesCustomForwardOnlyTraversal; }
 
-    bool isItemRefElementsCacheValid() const { return m_isItemRefElementsCacheValid; }
-    void setItemRefElementsCacheValid() const { m_isItemRefElementsCacheValid = true; }
-
     NodeListRootType rootType() const { return static_cast<NodeListRootType>(m_rootType); }
 
-    void setHasIdNameCache() const
+    CollectionNamedElementCache& createNameItemCache() const
     {
-        m_isNameCacheValid = true;
+        ASSERT(!m_namedElementCache);
+        m_namedElementCache = std::make_unique<CollectionNamedElementCache>();
         document().collectionCachedIdNameMap(*this);
+        return *m_namedElementCache;
     }
 
-private:
-    static void append(NodeCacheMap&, const AtomicString&, Element*);
+    const CollectionNamedElementCache& namedItemCaches() const
+    {
+        ASSERT(!!m_namedElementCache);
+        return *m_namedElementCache;
+    }
 
+private:
     Element* iterateForPreviousElement(Element* current) const;
     Element* firstElement(ContainerNode& root) const;
     Element* traverseForward(Element& current, unsigned count, unsigned& traversedCount, ContainerNode& root) const;
 
     virtual Element* customElementAfter(Element*) const { ASSERT_NOT_REACHED(); return nullptr; }
+    
+    void invalidateNamedElementCache() const;
 
     Ref<ContainerNode> m_ownerNode;
 
     mutable CollectionIndexCache<HTMLCollection, Element> m_indexCache;
+    mutable std::unique_ptr<CollectionNamedElementCache> m_namedElementCache;
 
-    const unsigned m_rootType : 1;
+    const unsigned m_collectionType : 5;
     const unsigned m_invalidationType : 4;
+    const unsigned m_rootType : 1;
     const unsigned m_shouldOnlyIncludeDirectChildren : 1;
-
-    mutable unsigned m_isNameCacheValid : 1;
-    const unsigned m_collectionType : 5;
     const unsigned m_usesCustomForwardOnlyTraversal : 1;
-    mutable unsigned m_isItemRefElementsCacheValid : 1;
-
-    mutable NodeCacheMap m_idCache;
-    mutable NodeCacheMap m_nameCache;
 };
 
 } // namespace
index 313ce9aebc6642a9fba1709c612cbd3336af513f..3ecd885cc3bd3cc7a67a7928fc1112d926d71c54 100644 (file)
@@ -135,13 +135,13 @@ Node* HTMLFormControlsCollection::namedItem(const AtomicString& name) const
     return firstNamedItem(formControlElements(), imagesElements, nameAttr, name);
 }
 
-void HTMLFormControlsCollection::updateNameCache() const
+void HTMLFormControlsCollection::updateNamedElementCache() const
 {
-    if (hasIdNameCache())
+    if (hasNamedElementCache())
         return;
 
+    CollectionNamedElementCache& cache = createNameItemCache();
     HashSet<AtomicStringImpl*> foundInputElements;
-
     const Vector<FormAssociatedElement*>& elementsArray = formControlElements();
 
     for (unsigned i = 0; i < elementsArray.size(); ++i) {
@@ -151,11 +151,11 @@ void HTMLFormControlsCollection::updateNameCache() const
             const AtomicString& idAttrVal = element.getIdAttribute();
             const AtomicString& nameAttrVal = element.getNameAttribute();
             if (!idAttrVal.isEmpty()) {
-                appendIdCache(idAttrVal, &element);
+                cache.appendIdCache(idAttrVal, &element);
                 foundInputElements.add(idAttrVal.impl());
             }
             if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal) {
-                appendNameCache(nameAttrVal, &element);
+                cache.appendNameCache(nameAttrVal, &element);
                 foundInputElements.add(nameAttrVal.impl());
             }
         }
@@ -168,13 +168,11 @@ void HTMLFormControlsCollection::updateNameCache() const
             const AtomicString& idAttrVal = element.getIdAttribute();
             const AtomicString& nameAttrVal = element.getNameAttribute();
             if (!idAttrVal.isEmpty() && !foundInputElements.contains(idAttrVal.impl()))
-                appendIdCache(idAttrVal, &element);
+                cache.appendIdCache(idAttrVal, &element);
             if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal && !foundInputElements.contains(nameAttrVal.impl()))
-                appendNameCache(nameAttrVal, &element);
+                cache.appendNameCache(nameAttrVal, &element);
         }
     }
-
-    setHasIdNameCache();
 }
 
 void HTMLFormControlsCollection::invalidateCache() const
index a4cfd2d18e90f9816891a50398f5abd32eeb08c5..32cc3bb38aa6042ae572f4398580e17751f89211 100644 (file)
@@ -47,7 +47,7 @@ private:
     explicit HTMLFormControlsCollection(ContainerNode&);
 
     virtual void invalidateCache() const override;
-    virtual void updateNameCache() const override;
+    virtual void updateNamedElementCache() const override;
 
     const Vector<FormAssociatedElement*>& formControlElements() const;
     const Vector<HTMLImageElement*>& formImageElements() const;