Migrate WTF::HashMap::add() to ::insert()

third_party/WebKit/Source/core/dom/NthIndexCache.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/NthIndexCache.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 
 namespace blink {
@@ skipping 137 matching lines @@
     nthIndexCache->cacheNthOfTypeIndexDataForParent(element);
   return index;
 }
 
 void NthIndexCache::cacheNthIndexDataForParent(Element& element) {
   DCHECK(element.parentNode());
   if (!m_parentMap)
     m_parentMap = new ParentMap();
 
   ParentMap::AddResult addResult =
-      m_parentMap->add(element.parentNode(), nullptr);
+      m_parentMap->insert(element.parentNode(), nullptr);
   DCHECK(addResult.isNewEntry);
   addResult.storedValue->value = new NthIndexData(*element.parentNode());
 }
 
 NthIndexCache::IndexByType& NthIndexCache::ensureTypeIndexMap(
     ContainerNode& parent) {
   if (!m_parentMapForType)
     m_parentMapForType = new ParentMapForType();
 
   ParentMapForType::AddResult addResult =
-      m_parentMapForType->add(&parent, nullptr);
+      m_parentMapForType->insert(&parent, nullptr);
   if (addResult.isNewEntry)
     addResult.storedValue->value = new IndexByType();
 
   DCHECK(addResult.storedValue->value);
   return *addResult.storedValue->value;
 }
 
 void NthIndexCache::cacheNthOfTypeIndexDataForParent(Element& element) {
   DCHECK(element.parentNode());
-  IndexByType::AddResult addResult =
-      ensureTypeIndexMap(*element.parentNode()).add(element.tagName(), nullptr);
+  IndexByType::AddResult addResult = ensureTypeIndexMap(*element.parentNode())
+                                         .insert(element.tagName(), nullptr);
   DCHECK(addResult.isNewEntry);
   addResult.storedValue->value =
       new NthIndexData(*element.parentNode(), element.tagQName());
 }
 
 unsigned NthIndexData::nthIndex(Element& element) const {
   DCHECK(!element.isPseudoElement());
 
   unsigned index = 0;
   for (Element *sibling = &element; sibling;
@@ skipping 32 matching lines @@
   // The frequency at which we cache the nth-index for a set of siblings.  A
   // spread value of 3 means every third Element will have its nth-index cached.
   // Using a spread value > 1 is done to save memory. Looking up the nth-index
   // will still be done in constant time in terms of sibling count, at most
   // 'spread' elements will be traversed.
   const unsigned spread = 3;
   unsigned count = 0;
   for (Element* sibling = ElementTraversal::firstChild(parent); sibling;
        sibling = ElementTraversal::nextSibling(*sibling)) {
     if (!(++count % spread))
-      m_elementIndexMap.add(sibling, count);
+      m_elementIndexMap.insert(sibling, count);
   }
   DCHECK(count);
   m_count = count;
 }
 
 NthIndexData::NthIndexData(ContainerNode& parent, const QualifiedName& type) {
   // The frequency at which we cache the nth-index of type for a set of
   // siblings.  A spread value of 3 means every third Element of its type will
   // have its nth-index cached.  Using a spread value > 1 is done to save
   // memory. Looking up the nth-index of its type will still be done in less
   // time, as most number of elements traversed will be equal to find 'spread'
   // elements in the sibling set.
   const unsigned spread = 3;
   unsigned count = 0;
   for (Element* sibling =
            ElementTraversal::firstChild(parent, HasTagName(type));
        sibling;
        sibling = ElementTraversal::nextSibling(*sibling, HasTagName(type))) {
     if (!(++count % spread))
-      m_elementIndexMap.add(sibling, count);
+      m_elementIndexMap.insert(sibling, count);
   }
   DCHECK(count);
   m_count = count;
 }
 
 DEFINE_TRACE(NthIndexData) {
   visitor->trace(m_elementIndexMap);
 }
 
 }  // namespace blink