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

third_party/WebKit/Source/platform/heap/HeapCompact.cpp

 // Copyright 2016 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 "platform/heap/HeapCompact.h"
 
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/SparseHeapBitmap.h"
@@ skipping 29 matching lines @@
     m_relocatablePages.insert(page);
   }
 
   void addInteriorFixup(MovableReference* slot) {
     auto it = m_interiorFixups.find(slot);
     // Ephemeron fixpoint iterations may cause repeated registrations.
     if (UNLIKELY(it != m_interiorFixups.end())) {
       DCHECK(!it->value);
       return;
     }
-    m_interiorFixups.add(slot, nullptr);
+    m_interiorFixups.insert(slot, nullptr);
     LOG_HEAP_COMPACTION("Interior slot: %p\n", slot);
     Address slotAddress = reinterpret_cast<Address>(slot);
     if (!m_interiors) {
       m_interiors = SparseHeapBitmap::create(slotAddress);
       return;
     }
     m_interiors->add(slotAddress);
   }
 
   void add(MovableReference* slot) {
     MovableReference reference = *slot;
     BasePage* refPage = pageFromObject(reference);
     // Nothing to compact on a large object's page.
     if (refPage->isLargeObjectPage())
       return;
 
 #if DCHECK_IS_ON()
     DCHECK(HeapCompact::isCompactableArena(refPage->arena()->arenaIndex()));
     auto it = m_fixups.find(reference);
     DCHECK(it == m_fixups.end() || it->value == slot);
 #endif
 
     // TODO: when updateHeapResidency() becomes more discriminating about
     // leaving out arenas that aren't worth compacting, a check for
     // isCompactingArena() would be appropriate here, leaving early if
     // |refPage|'s arena isn't in the set.
 
-    m_fixups.add(reference, slot);
+    m_fixups.insert(reference, slot);
 
     // Note: |slot| will reside outside the Oilpan heap if it is a
     // PersistentHeapCollectionBase. Hence pageFromObject() cannot be
     // used, as it sanity checks the |BasePage| it returns. Simply
     // derive the raw BasePage address here and check if it is a member
     // of the compactable and relocatable page address set.
     Address slotAddress = reinterpret_cast<Address>(slot);
     void* slotPageAddress = blinkPageAddress(slotAddress) + blinkGuardPageSize;
     if (LIKELY(!m_relocatablePages.contains(slotPageAddress)))
       return;
@@ skipping 11 matching lines @@
     //    "interior" bitmap. This bitmap is used when moving a backing
     //    store, quickly/ier checking if interior slots will have to
     //    be additionally redirected.
     addInteriorFixup(slot);
   }
 
   void addFixupCallback(MovableReference reference,
                         MovingObjectCallback callback,
                         void* callbackData) {
     DCHECK(!m_fixupCallbacks.contains(reference));
-    m_fixupCallbacks.add(reference, std::pair<void*, MovingObjectCallback>(
-                                        callbackData, callback));
+    m_fixupCallbacks.insert(reference, std::pair<void*, MovingObjectCallback>(
+                                           callbackData, callback));
   }
 
   void relocateInteriorFixups(Address from, Address to, size_t size) {
     SparseHeapBitmap* range = m_interiors->hasRange(from, size);
     if (LIKELY(!range))
       return;
 
     // Scan through the payload, looking for interior pointer slots
     // to adjust. If the backing store of such an interior slot hasn't
     // been moved already, update the slot -> real location mapping.
@@ skipping 338 matching lines @@
   fixups().addCompactingPage(page);
 }
 
 bool HeapCompact::scheduleCompactionGCForTesting(bool value) {
   bool current = s_forceCompactionGC;
   s_forceCompactionGC = value;
   return current;
 }
 
 }  // namespace blink