getElementsByTagName() should take a qualifiedName in parameter

third_party/WebKit/Source/core/dom/NodeListsNodeData.h

 /*
  * Copyright (C) 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith <catfish.man@gmail.com>
  *
  * 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,
@@ skipping 65 matching lines @@
     static const bool safe_to_compare_to_empty_or_deleted =
         DefaultHash<StringImpl*>::Hash::safe_to_compare_to_empty_or_deleted;
   };
 
   // Oilpan: keep a weak reference to the collection objects.
   // Object unregistration is handled by GC's weak processing.
   typedef HeapHashMap<std::pair<unsigned char, StringImpl*>,
                       WeakMember<LiveNodeListBase>,
                       NodeListAtomicCacheMapEntryHash>
       NodeListAtomicNameCacheMap;
-  typedef HeapHashMap<QualifiedName, WeakMember<TagCollection>>
-      TagCollectionCacheNS;
+  typedef HeapHashMap<QualifiedName, WeakMember<TagCollectionNS>>
+      TagCollectionNSCache;
 
   template <typename T>
   T* AddCache(ContainerNode& node,
               CollectionType collection_type,
               const AtomicString& name) {
     DCHECK(ThreadState::Current()->IsGCForbidden());
     NodeListAtomicNameCacheMap::AddResult result = atomic_name_caches_.insert(
         NamedNodeListKey(collection_type, name), nullptr);
     if (!result.is_new_entry) {
       return static_cast<T*>(result.stored_value->value.Get());
@@ skipping 19 matching lines @@
     ScriptWrappableVisitor::WriteBarrier(this, list);
     return list;
   }
 
   template <typename T>
   T* Cached(CollectionType collection_type) {
     return static_cast<T*>(
         atomic_name_caches_.at(NamedNodeListKey(collection_type, g_star_atom)));
   }
 
-  TagCollection* AddCache(ContainerNode& node,
-                          const AtomicString& namespace_uri,
-                          const AtomicString& local_name) {
+  TagCollectionNS* AddCache(ContainerNode& node,
+                            const AtomicString& namespace_uri,
+                            const AtomicString& local_name) {
     DCHECK(ThreadState::Current()->IsGCForbidden());
     QualifiedName name(g_null_atom, local_name, namespace_uri);
-    TagCollectionCacheNS::AddResult result =
-        tag_collection_cache_ns_.insert(name, nullptr);
+    TagCollectionNSCache::AddResult result =
+        tag_collection_ns_caches_.insert(name, nullptr);
     if (!result.is_new_entry)
       return result.stored_value->value;
 
-    TagCollection* list =
-        TagCollection::Create(node, namespace_uri, local_name);
+    TagCollectionNS* list =
+        TagCollectionNS::Create(node, namespace_uri, local_name);
     result.stored_value->value = list;
     ScriptWrappableVisitor::WriteBarrier(this, list);
     return list;
   }
 
   static NodeListsNodeData* Create() { return new NodeListsNodeData; }
 
   void InvalidateCaches(const QualifiedName* attr_name = 0);
 
   bool IsEmpty() const {
     return !child_node_list_ && atomic_name_caches_.IsEmpty() &&
-           tag_collection_cache_ns_.IsEmpty();
+           tag_collection_ns_caches_.IsEmpty();
   }
 
   void AdoptTreeScope() { InvalidateCaches(); }
 
   void AdoptDocument(Document& old_document, Document& new_document) {
     DCHECK_NE(old_document, new_document);
 
     NodeListAtomicNameCacheMap::const_iterator atomic_name_cache_end =
         atomic_name_caches_.end();
     for (NodeListAtomicNameCacheMap::const_iterator it =
              atomic_name_caches_.begin();
          it != atomic_name_cache_end; ++it) {
       LiveNodeListBase* list = it->value;
       list->DidMoveToDocument(old_document, new_document);
     }
 
-    TagCollectionCacheNS::const_iterator tag_end =
-        tag_collection_cache_ns_.end();
-    for (TagCollectionCacheNS::const_iterator it =
-             tag_collection_cache_ns_.begin();
+    TagCollectionNSCache::const_iterator tag_end =
+        tag_collection_ns_caches_.end();
+    for (TagCollectionNSCache::const_iterator it =
+             tag_collection_ns_caches_.begin();
          it != tag_end; ++it) {
       LiveNodeListBase* list = it->value;
       DCHECK(!list->IsRootedAtTreeScope());
       list->DidMoveToDocument(old_document, new_document);
     }
   }
   DECLARE_TRACE();
 
   DECLARE_TRACE_WRAPPERS();
 
  private:
   NodeListsNodeData() : child_node_list_(nullptr) {}
 
   std::pair<unsigned char, StringImpl*> NamedNodeListKey(
       CollectionType type,
       const AtomicString& name) {
     // Holding the raw StringImpl is safe because |name| is retained by the
     // NodeList and the NodeList is reponsible for removing itself from the
     // cache on deletion.
     return std::pair<unsigned char, StringImpl*>(type, name.Impl());
   }
 
   // Can be a ChildNodeList or an EmptyNodeList.
   WeakMember<NodeList> child_node_list_;
   NodeListAtomicNameCacheMap atomic_name_caches_;
-  TagCollectionCacheNS tag_collection_cache_ns_;
+  TagCollectionNSCache tag_collection_ns_caches_;
 };
 
 DEFINE_TRAIT_FOR_TRACE_WRAPPERS(NodeListsNodeData);
 
 template <typename Collection>
 inline Collection* ContainerNode::EnsureCachedCollection(CollectionType type) {
   ThreadState::MainThreadGCForbiddenScope gc_forbidden;
   return EnsureNodeLists().AddCache<Collection>(*this, type);
 }
 
 template <typename Collection>
 inline Collection* ContainerNode::EnsureCachedCollection(
     CollectionType type,
     const AtomicString& name) {
   ThreadState::MainThreadGCForbiddenScope gc_forbidden;
   return EnsureNodeLists().AddCache<Collection>(*this, type, name);
 }
 
 template <typename Collection>
 inline Collection* ContainerNode::EnsureCachedCollection(
     CollectionType type,
     const AtomicString& namespace_uri,
     const AtomicString& local_name) {
-  DCHECK_EQ(type, kTagCollectionType);
+  DCHECK_EQ(type, kTagCollectionNSType);
   ThreadState::MainThreadGCForbiddenScope gc_forbidden;
   return EnsureNodeLists().AddCache(*this, namespace_uri, local_name);
 }
 
 template <typename Collection>
 inline Collection* ContainerNode::CachedCollection(CollectionType type) {
   NodeListsNodeData* node_lists = this->NodeLists();
   return node_lists ? node_lists->Cached<Collection>(type) : 0;
 }
 
 }  // namespace blink
 
 #endif  // NodeListsNodeData_h