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

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 549 matching lines @@
 
     int gcCount = 0;
     while (!done()) {
       ThreadState::current()->safePoint(BlinkGC::NoHeapPointersOnStack);
       {
         Persistent<HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>> weakMap =
             new HeapHashMap<ThreadMarker, WeakMember<IntWrapper>>;
         PersistentHeapHashMap<ThreadMarker, WeakMember<IntWrapper>> weakMap2;
 
         for (int i = 0; i < numberOfAllocations; i++) {
-          weakMap->add(static_cast<unsigned>(i), IntWrapper::create(0));
-          weakMap2.add(static_cast<unsigned>(i), IntWrapper::create(0));
+          weakMap->insert(static_cast<unsigned>(i), IntWrapper::create(0));
+          weakMap2.insert(static_cast<unsigned>(i), IntWrapper::create(0));
           SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
           testing::yieldCurrentThread();
         }
 
         if (gcCount < gcPerThread) {
           preciselyCollectGarbage();
           gcCount++;
           atomicIncrement(&m_gcCount);
         }
 
@@ skipping 590 matching lines @@
 
   explicit FinalizationObserverWithHashMap(Observable& target)
       : m_target(target) {}
   ~FinalizationObserverWithHashMap() {
     m_target.willFinalize();
     s_didCallWillFinalize = true;
   }
 
   static ObserverMap& observe(Observable& target) {
     ObserverMap& map = observers();
-    ObserverMap::AddResult result = map.add(&target, nullptr);
+    ObserverMap::AddResult result = map.insert(&target, nullptr);
     if (result.isNewEntry) {
       result.storedValue->value =
           WTF::makeUnique<FinalizationObserverWithHashMap>(target);
     } else {
       ASSERT(result.storedValue->value);
     }
     return map;
   }
 
   static void clearObservers() {
@@ skipping 832 matching lines @@
 
     preciselyCollectGarbage();
     size_t afterGC = heap.objectPayloadSizeForTesting();
     EXPECT_EQ(afterGC, afterSetWasCreated);
 
     // If the additions below cause garbage collections, these
     // pointers should be found by conservative stack scanning.
     IntWrapper* one(IntWrapper::create(1));
     IntWrapper* anotherOne(IntWrapper::create(1));
 
-    map->add(one, one);
+    map->insert(one, one);
 
     size_t afterOneAdd = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(afterOneAdd > afterGC);
 
     HeapObjectIdentityMap::iterator it(map->begin());
     HeapObjectIdentityMap::iterator it2(map->begin());
     ++it;
     ++it2;
 
-    map->add(anotherOne, one);
+    map->insert(anotherOne, one);
 
     // The addition above can cause an allocation of a new
     // backing store. We therefore garbage collect before
     // taking the heap stats in order to get rid of the old
     // backing store. We make sure to not use conservative
     // stack scanning as that could find a pointer to the
     // old backing.
     preciselyCollectGarbage();
     size_t afterAddAndGC = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(afterAddAndGC >= afterOneAdd);
 
     EXPECT_EQ(map->size(), 2u);  // Two different wrappings of '1' are distinct.
 
     preciselyCollectGarbage();
     EXPECT_TRUE(map->contains(one));
     EXPECT_TRUE(map->contains(anotherOne));
 
     IntWrapper* gotten(map->get(one));
     EXPECT_EQ(gotten->value(), one->value());
     EXPECT_EQ(gotten, one);
 
     size_t afterGC2 = heap.objectPayloadSizeForTesting();
     EXPECT_EQ(afterGC2, afterAddAndGC);
 
     IntWrapper* dozen = 0;
 
     for (int i = 1; i < 1000; i++) {  // 999 iterations.
       IntWrapper* iWrapper(IntWrapper::create(i));
       IntWrapper* iSquared(IntWrapper::create(i * i));
-      map->add(iWrapper, iSquared);
+      map->insert(iWrapper, iSquared);
       if (i == 12)
         dozen = iWrapper;
     }
     size_t afterAdding1000 = heap.objectPayloadSizeForTesting();
     EXPECT_TRUE(afterAdding1000 > afterGC2);
 
     IntWrapper* gross(map->get(dozen));
     EXPECT_EQ(gross->value(), 144);
 
     // This should clear out any junk backings created by all the adds.
@@ skipping 332 matching lines @@
       IntWrapper* fourD(IntWrapper::create(4));
       IntWrapper* fourE(IntWrapper::create(4));
       IntWrapper* fourF(IntWrapper::create(4));
       IntWrapper* four(IntWrapper::create(4));
       IntWrapper* fiveC(IntWrapper::create(5));
       IntWrapper* fiveD(IntWrapper::create(5));
       IntWrapper* fiveE(IntWrapper::create(5));
       IntWrapper* fiveF(IntWrapper::create(5));
 
       // Member Collections.
-      memberMember2->add(one, two);
-      memberMember2->add(two, three);
-      memberMember2->add(three, four);
-      memberMember2->add(four, one);
-      primitiveMember->add(1, two);
-      primitiveMember->add(2, three);
-      primitiveMember->add(3, four);
-      primitiveMember->add(4, one);
-      memberPrimitive->add(one, 2);
-      memberPrimitive->add(two, 3);
-      memberPrimitive->add(three, 4);
-      memberPrimitive->add(four, 1);
+      memberMember2->insert(one, two);
+      memberMember2->insert(two, three);
+      memberMember2->insert(three, four);
+      memberMember2->insert(four, one);
+      primitiveMember->insert(1, two);
+      primitiveMember->insert(2, three);
+      primitiveMember->insert(3, four);
+      primitiveMember->insert(4, one);
+      memberPrimitive->insert(one, 2);
+      memberPrimitive->insert(two, 3);
+      memberPrimitive->insert(three, 4);
+      memberPrimitive->insert(four, 1);
       set2->add(one);
       set2->add(two);
       set2->add(three);
       set2->add(four);
       set->add(oneB);
       set3->add(oneB);
       set3->add(oneB);
       vector->push_back(oneB);
       deque->append(oneB);
       vector2->push_back(threeB);
@@ skipping 451 matching lines @@
 
  private:
   HeapDeque<Member<IntWrapper>> m_deque;
   HeapVector<Member<IntWrapper>> m_vector;
 };
 
 TEST(HeapTest, HeapHashMapWithInlinedObject) {
   HeapHashMap<int, NonTrivialObject> map;
   for (int num = 1; num < 1000; num++) {
     NonTrivialObject object(num);
-    map.add(num, object);
+    map.insert(num, object);
   }
 }
 
 template <typename T>
 void MapIteratorCheck(T& it, const T& end, int expected) {
   int found = 0;
   while (it != end) {
     found++;
     int key = it->key->value();
     int value = it->value->value();
@@ skipping 33 matching lines @@
   Persistent<WeakWeak> weakWeak = new WeakWeak();
   Persistent<WeakSet> weakSet = new WeakSet();
   Persistent<WeakCountedSet> weakCountedSet = new WeakCountedSet();
 
   Persistent<IntWrapper> two = IntWrapper::create(2);
 
   keepNumbersAlive.push_back(IntWrapper::create(103));
   keepNumbersAlive.push_back(IntWrapper::create(10));
 
   {
-    weakStrong->add(IntWrapper::create(1), two);
-    strongWeak->add(two, IntWrapper::create(1));
-    weakWeak->add(two, IntWrapper::create(42));
-    weakWeak->add(IntWrapper::create(42), two);
+    weakStrong->insert(IntWrapper::create(1), two);
+    strongWeak->insert(two, IntWrapper::create(1));
+    weakWeak->insert(two, IntWrapper::create(42));
+    weakWeak->insert(IntWrapper::create(42), two);
     weakSet->add(IntWrapper::create(0));
     weakSet->add(two);
     weakSet->add(keepNumbersAlive[0]);
     weakSet->add(keepNumbersAlive[1]);
     weakCountedSet->add(IntWrapper::create(0));
     weakCountedSet->add(two);
     weakCountedSet->add(two);
     weakCountedSet->add(two);
     weakCountedSet->add(keepNumbersAlive[0]);
     weakCountedSet->add(keepNumbersAlive[1]);
@@ skipping 180 matching lines @@
 
   int baseLine, refBaseLine;
 
   {
     Map stackMap;
     RefMap stackRefMap;
 
     preciselyCollectGarbage();
     preciselyCollectGarbage();
 
-    stackMap.add(IntWrapper::create(42), ThingWithDestructor(1729));
-    stackMap.add(luck, ThingWithDestructor(8128));
-    stackRefMap.add(IntWrapper::create(42),
-                    RefCountedAndGarbageCollected::create());
-    stackRefMap.add(luck, RefCountedAndGarbageCollected::create());
+    stackMap.insert(IntWrapper::create(42), ThingWithDestructor(1729));
+    stackMap.insert(luck, ThingWithDestructor(8128));
+    stackRefMap.insert(IntWrapper::create(42),
+                       RefCountedAndGarbageCollected::create());
+    stackRefMap.insert(luck, RefCountedAndGarbageCollected::create());
 
     baseLine = ThingWithDestructor::s_liveThingsWithDestructor;
     refBaseLine = RefCountedAndGarbageCollected::s_destructorCalls;
 
     // Although the heap maps are on-stack, we can't expect prompt
     // finalization of the elements, so when they go out of scope here we
     // will not necessarily have called the relevant destructors.
   }
 
   // The RefCountedAndGarbageCollected things need an extra GC to discover
   // that they are no longer ref counted.
   preciselyCollectGarbage();
   preciselyCollectGarbage();
   EXPECT_EQ(baseLine - 2, ThingWithDestructor::s_liveThingsWithDestructor);
   EXPECT_EQ(refBaseLine + 2, RefCountedAndGarbageCollected::s_destructorCalls);
 
   // Now use maps kept alive with persistents. Here we don't expect any
   // destructors to be called before there have been GCs.
 
-  map->add(IntWrapper::create(42), ThingWithDestructor(1729));
-  map->add(luck, ThingWithDestructor(8128));
-  refMap->add(IntWrapper::create(42), RefCountedAndGarbageCollected::create());
-  refMap->add(luck, RefCountedAndGarbageCollected::create());
+  map->insert(IntWrapper::create(42), ThingWithDestructor(1729));
+  map->insert(luck, ThingWithDestructor(8128));
+  refMap->insert(IntWrapper::create(42),
+                 RefCountedAndGarbageCollected::create());
+  refMap->insert(luck, RefCountedAndGarbageCollected::create());
 
   baseLine = ThingWithDestructor::s_liveThingsWithDestructor;
   refBaseLine = RefCountedAndGarbageCollected::s_destructorCalls;
 
   luck.clear();
   if (clearMaps) {
     map->clear();     // Clear map.
     refMap->clear();  // Clear map.
   } else {
     map.clear();     // Clear Persistent handle, not map.
@@ skipping 193 matching lines @@
 
       Persistent<WeakSet> weakSet = new WeakSet();
       Persistent<WeakOrderedSet> weakOrderedSet = new WeakOrderedSet();
 
       PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
       for (int i = 0; i < 128; i += 2) {
         IntWrapper* wrapped = IntWrapper::create(i);
         IntWrapper* wrapped2 = IntWrapper::create(i + 1);
         keepNumbersAlive.push_back(wrapped);
         keepNumbersAlive.push_back(wrapped2);
-        weakStrong->add(wrapped, wrapped2);
-        strongWeak->add(wrapped2, wrapped);
-        weakWeak->add(wrapped, wrapped2);
+        weakStrong->insert(wrapped, wrapped2);
+        strongWeak->insert(wrapped2, wrapped);
+        weakWeak->insert(wrapped, wrapped2);
         weakSet->add(wrapped);
         weakOrderedSet->add(wrapped);
       }
 
       EXPECT_EQ(64u, weakStrong->size());
       EXPECT_EQ(64u, strongWeak->size());
       EXPECT_EQ(64u, weakWeak->size());
       EXPECT_EQ(64u, weakSet->size());
       EXPECT_EQ(64u, weakOrderedSet->size());
 
@@ skipping 94 matching lines @@
             if (deleteAfterwards)
               weakOrderedSet->remove(keepNumbersAlive[i]);
             else
               count++;
           }
         }
         if (addAfterwards) {
           for (int i = 1000; i < 1100; i++) {
             IntWrapper* wrapped = IntWrapper::create(i);
             keepNumbersAlive.push_back(wrapped);
-            weakStrong->add(wrapped, wrapped);
-            strongWeak->add(wrapped, wrapped);
-            weakWeak->add(wrapped, wrapped);
+            weakStrong->insert(wrapped, wrapped);
+            strongWeak->insert(wrapped, wrapped);
+            weakWeak->insert(wrapped, wrapped);
             weakSet->add(wrapped);
             weakOrderedSet->add(wrapped);
           }
         }
         if (collectionNumber == weakStrongIndex)
           EXPECT_EQ(count + added, weakStrong->size());
         else if (collectionNumber == strongWeakIndex)
           EXPECT_EQ(count + added, strongWeak->size());
         else if (collectionNumber == weakWeakIndex)
           EXPECT_EQ(count + added, weakWeak->size());
@@ skipping 342 matching lines @@
 
     Vec* vec = new Vec();
     vec->swap(pVec);
 
     pVec.push_back(two);
     pVec.push_back(three);
 
     pSet.add(four);
     pListSet.add(eight);
     pLinkedSet.add(nine);
-    pMap.add(five, six);
-    wpMap.add(ten, eleven);
+    pMap.insert(five, six);
+    wpMap.insert(ten, eleven);
 
     // Collect |vec| and |one|.
     vec = 0;
     preciselyCollectGarbage();
     EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 
     EXPECT_EQ(2u, pVec.size());
     EXPECT_EQ(two, pVec.at(0));
     EXPECT_EQ(three, pVec.at(1));
 
@@ skipping 34 matching lines @@
   IntWrapper::s_destructorCalls = 0;
   typedef HeapVector<Member<IntWrapper>> IntVector;
   typedef HeapDeque<Member<IntWrapper>> IntDeque;
   HeapHashMap<void*, IntVector>* map = new HeapHashMap<void*, IntVector>();
   HeapHashMap<void*, IntDeque>* map2 = new HeapHashMap<void*, IntDeque>();
   static_assert(WTF::IsTraceable<IntVector>::value,
                 "Failed to recognize HeapVector as traceable");
   static_assert(WTF::IsTraceable<IntDeque>::value,
                 "Failed to recognize HeapDeque as traceable");
 
-  map->add(key, IntVector());
-  map2->add(key, IntDeque());
+  map->insert(key, IntVector());
+  map2->insert(key, IntDeque());
 
   HeapHashMap<void*, IntVector>::iterator it = map->find(key);
   EXPECT_EQ(0u, map->get(key).size());
 
   HeapHashMap<void*, IntDeque>::iterator it2 = map2->find(key);
   EXPECT_EQ(0u, map2->get(key).size());
 
   it->value.push_back(IntWrapper::create(42));
   EXPECT_EQ(1u, map->get(key).size());
 
   it2->value.append(IntWrapper::create(42));
   EXPECT_EQ(1u, map2->get(key).size());
 
   Persistent<HeapHashMap<void*, IntVector>> keepAlive(map);
   Persistent<HeapHashMap<void*, IntDeque>> keepAlive2(map2);
 
   for (int i = 0; i < 100; i++) {
-    map->add(key + 1 + i, IntVector());
-    map2->add(key + 1 + i, IntDeque());
+    map->insert(key + 1 + i, IntVector());
+    map2->insert(key + 1 + i, IntDeque());
   }
 
   preciselyCollectGarbage();
 
   EXPECT_EQ(1u, map->get(key).size());
   EXPECT_EQ(1u, map2->get(key).size());
   EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 
   keepAlive = nullptr;
   preciselyCollectGarbage();
@@ skipping 19 matching lines @@
   EXPECT_EQ(0u, weakMap.size());
 }
 
 TEST(HeapTest, CollectionNesting2) {
   clearOutOldGarbage();
   void* key = &IntWrapper::s_destructorCalls;
   IntWrapper::s_destructorCalls = 0;
   typedef HeapHashSet<Member<IntWrapper>> IntSet;
   HeapHashMap<void*, IntSet>* map = new HeapHashMap<void*, IntSet>();
 
-  map->add(key, IntSet());
+  map->insert(key, IntSet());
 
   HeapHashMap<void*, IntSet>::iterator it = map->find(key);
   EXPECT_EQ(0u, map->get(key).size());
 
   it->value.add(IntWrapper::create(42));
   EXPECT_EQ(1u, map->get(key).size());
 
   Persistent<HeapHashMap<void*, IntSet>> keepAlive(map);
   preciselyCollectGarbage();
   EXPECT_EQ(1u, map->get(key).size());
@@ skipping 465 matching lines @@
 
   EXPECT_FALSE(RefCountedWithDestructor::s_wasDestructed);
   set.clear();
   EXPECT_TRUE(RefCountedWithDestructor::s_wasDestructed);
 }
 
 TEST(HeapTest, DestructorsCalled) {
   HeapHashMap<Member<IntWrapper>, std::unique_ptr<SimpleClassWithDestructor>>
       map;
   SimpleClassWithDestructor* hasDestructor = new SimpleClassWithDestructor();
-  map.add(IntWrapper::create(1), WTF::wrapUnique(hasDestructor));
+  map.insert(IntWrapper::create(1), WTF::wrapUnique(hasDestructor));
   SimpleClassWithDestructor::s_wasDestructed = false;
   map.clear();
   EXPECT_TRUE(SimpleClassWithDestructor::s_wasDestructed);
 }
 
 class MixinA : public GarbageCollectedMixin {
  public:
   MixinA() : m_obj(IntWrapper::create(100)) {}
   DEFINE_INLINE_VIRTUAL_TRACE() {
     s_traceCount++;
@@ skipping 209 matching lines @@
   typedef HeapHashMap<PairWithWeakHandling, RefPtr<OffHeapInt>> Map;
   typedef Map::iterator Iterator;
   clearOutOldGarbage();
   OffHeapInt::s_destructorCalls = 0;
 
   Persistent<Map> map1(new Map());
   Persistent<IntWrapper> livingInt(IntWrapper::create(42));
   {
     Map map2;
     Map* map3 = new Map();
-    map2.add(PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)),
-             OffHeapInt::create(1001));
-    map3->add(
+    map2.insert(
+        PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)),
+        OffHeapInt::create(1001));
+    map3->insert(
         PairWithWeakHandling(IntWrapper::create(2), IntWrapper::create(3)),
         OffHeapInt::create(1002));
-    map1->add(
+    map1->insert(
         PairWithWeakHandling(IntWrapper::create(4), IntWrapper::create(5)),
         OffHeapInt::create(1003));
     EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
 
     conservativelyCollectGarbage();
     // The first map2 is pointed to from a persistent, so it's referenced, but
     // the weak processing may have taken place.
     if (map1->size()) {
       Iterator i1 = map1->begin();
       EXPECT_EQ(4, i1->key.first->value());
@@ skipping 15 matching lines @@
       EXPECT_EQ(1002, i3->value->value());
     }
   }
   preciselyCollectGarbage();
 
   EXPECT_EQ(0u, map1->size());
   EXPECT_EQ(3, OffHeapInt::s_destructorCalls);
 
   OffHeapInt::s_destructorCalls = 0;
 
-  map1->add(PairWithWeakHandling(IntWrapper::create(103), livingInt),
-            OffHeapInt::create(2000));
-  map1->add(PairWithWeakHandling(livingInt, IntWrapper::create(103)),
-            OffHeapInt::create(2001));  // This one gets zapped at GC time
-                                        // because nothing holds the 103 alive.
-  map1->add(
+  map1->insert(PairWithWeakHandling(IntWrapper::create(103), livingInt),
+               OffHeapInt::create(2000));
+  map1->insert(PairWithWeakHandling(livingInt, IntWrapper::create(103)),
+               OffHeapInt::create(2001));  // This one gets zapped at GC time
+  // because nothing holds the 103 alive.
+  map1->insert(
       PairWithWeakHandling(IntWrapper::create(103), IntWrapper::create(103)),
       OffHeapInt::create(2002));  // This one gets zapped too.
   RefPtr<OffHeapInt> dupeInt(OffHeapInt::create(2003));
-  map1->add(PairWithWeakHandling(livingInt, livingInt), dupeInt);
-  map1->add(PairWithWeakHandling(livingInt, livingInt),
-            dupeInt);  // This one is identical to the previous and doesn't add
-                       // anything.
+  map1->insert(PairWithWeakHandling(livingInt, livingInt), dupeInt);
+  map1->insert(
+      PairWithWeakHandling(livingInt, livingInt),
+      dupeInt);  // This one is identical to the previous and doesn't add
+                 // anything.
   dupeInt.clear();
 
   EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(4u, map1->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(2u, map1->size());
   Iterator i1 = map1->begin();
   EXPECT_TRUE(i1->key.first->value() == 103 || i1->key.first == livingInt);
   EXPECT_EQ(livingInt, i1->key.second);
   ++i1;
   EXPECT_TRUE(i1->key.first->value() == 103 || i1->key.first == livingInt);
   EXPECT_EQ(livingInt, i1->key.second);
 }
 
 TEST(HeapTest, MapWithCustomWeaknessHandling2) {
   typedef HeapHashMap<RefPtr<OffHeapInt>, PairWithWeakHandling> Map;
   typedef Map::iterator Iterator;
   clearOutOldGarbage();
   OffHeapInt::s_destructorCalls = 0;
 
   Persistent<Map> map1(new Map());
   Persistent<IntWrapper> livingInt(IntWrapper::create(42));
 
   {
     Map map2;
     Map* map3 = new Map();
-    map2.add(
+    map2.insert(
         OffHeapInt::create(1001),
         PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)));
-    map3->add(
+    map3->insert(
         OffHeapInt::create(1002),
         PairWithWeakHandling(IntWrapper::create(2), IntWrapper::create(3)));
-    map1->add(
+    map1->insert(
         OffHeapInt::create(1003),
         PairWithWeakHandling(IntWrapper::create(4), IntWrapper::create(5)));
     EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
 
     conservativelyCollectGarbage();
     // The first map2 is pointed to from a persistent, so it's referenced, but
     // the weak processing may have taken place.
     if (map1->size()) {
       Iterator i1 = map1->begin();
       EXPECT_EQ(4, i1->value.first->value());
@@ skipping 15 matching lines @@
       EXPECT_EQ(1002, i3->key->value());
     }
   }
   preciselyCollectGarbage();
 
   EXPECT_EQ(0u, map1->size());
   EXPECT_EQ(3, OffHeapInt::s_destructorCalls);
 
   OffHeapInt::s_destructorCalls = 0;
 
-  map1->add(OffHeapInt::create(2000),
-            PairWithWeakHandling(IntWrapper::create(103), livingInt));
+  map1->insert(OffHeapInt::create(2000),
+               PairWithWeakHandling(IntWrapper::create(103), livingInt));
   // This one gets zapped at GC time because nothing holds the 103 alive.
-  map1->add(OffHeapInt::create(2001),
-            PairWithWeakHandling(livingInt, IntWrapper::create(103)));
-  map1->add(OffHeapInt::create(2002),
-            PairWithWeakHandling(
-                IntWrapper::create(103),
-                IntWrapper::create(103)));  // This one gets zapped too.
+  map1->insert(OffHeapInt::create(2001),
+               PairWithWeakHandling(livingInt, IntWrapper::create(103)));
+  map1->insert(OffHeapInt::create(2002),
+               PairWithWeakHandling(
+                   IntWrapper::create(103),
+                   IntWrapper::create(103)));  // This one gets zapped too.
   RefPtr<OffHeapInt> dupeInt(OffHeapInt::create(2003));
-  map1->add(dupeInt, PairWithWeakHandling(livingInt, livingInt));
+  map1->insert(dupeInt, PairWithWeakHandling(livingInt, livingInt));
   // This one is identical to the previous and doesn't add anything.
-  map1->add(dupeInt, PairWithWeakHandling(livingInt, livingInt));
+  map1->insert(dupeInt, PairWithWeakHandling(livingInt, livingInt));
   dupeInt.clear();
 
   EXPECT_EQ(0, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(4u, map1->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2, OffHeapInt::s_destructorCalls);
   EXPECT_EQ(2u, map1->size());
   Iterator i1 = map1->begin();
   EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
   EXPECT_EQ(livingInt, i1->value.second);
   ++i1;
   EXPECT_TRUE(i1->value.first->value() == 103 || i1->value.first == livingInt);
   EXPECT_EQ(livingInt, i1->value.second);
 }
 
 static void addElementsToWeakMap(
     HeapHashMap<int, WeakMember<IntWrapper>>* map) {
   // Key cannot be zero in hashmap.
   for (int i = 1; i < 11; i++)
-    map->add(i, IntWrapper::create(i));
+    map->insert(i, IntWrapper::create(i));
 }
 
 // crbug.com/402426
 // If it doesn't assert a concurrent modification to the map, then it's passing.
 TEST(HeapTest, RegressNullIsStrongified) {
   Persistent<HeapHashMap<int, WeakMember<IntWrapper>>> map =
       new HeapHashMap<int, WeakMember<IntWrapper>>();
   addElementsToWeakMap(map);
   HeapHashMap<int, WeakMember<IntWrapper>>::AddResult result =
-      map->add(800, nullptr);
+      map->insert(800, nullptr);
   conservativelyCollectGarbage();
   result.storedValue->value = IntWrapper::create(42);
 }
 
 TEST(HeapTest, Bind) {
   std::unique_ptr<WTF::Closure> closure =
       WTF::bind(static_cast<void (Bar::*)(Visitor*)>(&Bar::trace),
                 wrapPersistent(Bar::create()), nullptr);
   // OffHeapInt* should not make Persistent.
   std::unique_ptr<WTF::Closure> closure2 =
@@ skipping 56 matching lines @@
   clearOutOldGarbage();
   OffHeapInt::s_destructorCalls = 0;
 
   Persistent<IntWrapper> livingInt(IntWrapper::create(42));
 
   typedef RefPtr<OffHeapInt> Key;
   typedef HeapHashMap<Key, WeakSet, WTF::DefaultHash<Key>::Hash,
                       HashTraits<Key>, EmptyClearingHashSetTraits>
       Map;
   Persistent<Map> map(new Map());
-  map->add(OffHeapInt::create(1), WeakSet());
+  map->insert(OffHeapInt::create(1), WeakSet());
   {
     WeakSet& set = map->begin()->value;
     set.add(IntWrapper::create(103));  // Weak set can't hold this long.
     set.add(livingInt);  // This prevents the set from being emptied.
     EXPECT_EQ(2u, set.size());
   }
 
   // The set we add here is empty, so the entry will be removed from the map
   // at the next GC.
-  map->add(OffHeapInt::create(2), WeakSet());
+  map->insert(OffHeapInt::create(2), WeakSet());
   EXPECT_EQ(2u, map->size());
 
   preciselyCollectGarbage();
   EXPECT_EQ(1u, map->size());  // The one with key 2 was removed.
   EXPECT_EQ(1, OffHeapInt::s_destructorCalls);
   {
     WeakSet& set = map->begin()->value;
     EXPECT_EQ(1u, set.size());
   }
 
   livingInt.clear();  // The weak set can no longer keep the '42' alive now.
   preciselyCollectGarbage();
   EXPECT_EQ(0u, map->size());
 }
 
 TEST(HeapTest, EphemeronsInEphemerons) {
   typedef HeapHashMap<WeakMember<IntWrapper>, Member<IntWrapper>> InnerMap;
   typedef HeapHashMap<WeakMember<IntWrapper>, InnerMap> OuterMap;
 
   for (int keepOuterAlive = 0; keepOuterAlive <= 1; keepOuterAlive++) {
     for (int keepInnerAlive = 0; keepInnerAlive <= 1; keepInnerAlive++) {
       Persistent<OuterMap> outer = new OuterMap();
       Persistent<IntWrapper> one = IntWrapper::create(1);
       Persistent<IntWrapper> two = IntWrapper::create(2);
-      outer->add(one, InnerMap());
-      outer->begin()->value.add(two, IntWrapper::create(3));
+      outer->insert(one, InnerMap());
+      outer->begin()->value.insert(two, IntWrapper::create(3));
       EXPECT_EQ(1u, outer->get(one).size());
       if (!keepOuterAlive)
         one.clear();
       if (!keepInnerAlive)
         two.clear();
       preciselyCollectGarbage();
       if (keepOuterAlive) {
         const InnerMap& inner = outer->get(one);
         if (keepInnerAlive) {
           EXPECT_EQ(1u, inner.size());
           IntWrapper* three = inner.get(two);
           EXPECT_EQ(3, three->value());
         } else {
           EXPECT_EQ(0u, inner.size());
         }
       } else {
         EXPECT_EQ(0u, outer->size());
       }
       outer->clear();
       Persistent<IntWrapper> deep = IntWrapper::create(42);
       Persistent<IntWrapper> home = IntWrapper::create(103);
       Persistent<IntWrapper> composite = IntWrapper::create(91);
       Persistent<HeapVector<Member<IntWrapper>>> keepAlive =
           new HeapVector<Member<IntWrapper>>();
       for (int i = 0; i < 10000; i++) {
         IntWrapper* value = IntWrapper::create(i);
         keepAlive->push_back(value);
-        OuterMap::AddResult newEntry = outer->add(value, InnerMap());
-        newEntry.storedValue->value.add(deep, home);
-        newEntry.storedValue->value.add(composite, home);
+        OuterMap::AddResult newEntry = outer->insert(value, InnerMap());
+        newEntry.storedValue->value.insert(deep, home);
+        newEntry.storedValue->value.insert(composite, home);
       }
       composite.clear();
       preciselyCollectGarbage();
       EXPECT_EQ(10000u, outer->size());
       for (int i = 0; i < 10000; i++) {
         IntWrapper* value = keepAlive->at(i);
         EXPECT_EQ(1u, outer->get(value)
                           .size());  // Other one was deleted by weak handling.
         if (i & 1)
           keepAlive->at(i) = nullptr;
@@ skipping 17 matching lines @@
 
 TEST(HeapTest, EphemeronsPointToEphemerons) {
   Persistent<IntWrapper> key = IntWrapper::create(42);
   Persistent<IntWrapper> key2 = IntWrapper::create(103);
 
   Persistent<EphemeronWrapper> chain;
   for (int i = 0; i < 100; i++) {
     EphemeronWrapper* oldHead = chain;
     chain = new EphemeronWrapper();
     if (i == 50)
-      chain->getMap().add(key2, oldHead);
+      chain->getMap().insert(key2, oldHead);
     else
-      chain->getMap().add(key, oldHead);
-    chain->getMap().add(IntWrapper::create(103), new EphemeronWrapper());
+      chain->getMap().insert(key, oldHead);
+    chain->getMap().insert(IntWrapper::create(103), new EphemeronWrapper());
   }
 
   preciselyCollectGarbage();
 
   EphemeronWrapper* wrapper = chain;
   for (int i = 0; i < 100; i++) {
     EXPECT_EQ(1u, wrapper->getMap().size());
     if (i == 49)
       wrapper = wrapper->getMap().get(key2);
     else
@@ skipping 29 matching lines @@
   Persistent<PairWeakMap> pairWeakMap = new PairWeakMap();
   Persistent<PairWeakMap> pairWeakMap2 = new PairWeakMap();
 
   Persistent<Set> set = new Set();
 
   Persistent<IntWrapper> wp1 = IntWrapper::create(1);
   Persistent<IntWrapper> wp2 = IntWrapper::create(2);
   Persistent<IntWrapper> pw1 = IntWrapper::create(3);
   Persistent<IntWrapper> pw2 = IntWrapper::create(4);
 
-  weakPairMap->add(wp1, PairWithWeakHandling(wp1, wp1));
-  weakPairMap->add(wp2, PairWithWeakHandling(wp1, wp1));
-  weakPairMap2->add(wp1, PairWithWeakHandling(wp1, wp2));
-  weakPairMap2->add(wp2, PairWithWeakHandling(wp1, wp2));
+  weakPairMap->insert(wp1, PairWithWeakHandling(wp1, wp1));
+  weakPairMap->insert(wp2, PairWithWeakHandling(wp1, wp1));
+  weakPairMap2->insert(wp1, PairWithWeakHandling(wp1, wp2));
+  weakPairMap2->insert(wp2, PairWithWeakHandling(wp1, wp2));
   // The map from wp1 to (wp2, wp1) would mark wp2 live, so we skip that.
-  weakPairMap3->add(wp2, PairWithWeakHandling(wp2, wp1));
-  weakPairMap4->add(wp1, PairWithWeakHandling(wp2, wp2));
-  weakPairMap4->add(wp2, PairWithWeakHandling(wp2, wp2));
+  weakPairMap3->insert(wp2, PairWithWeakHandling(wp2, wp1));
+  weakPairMap4->insert(wp1, PairWithWeakHandling(wp2, wp2));
+  weakPairMap4->insert(wp2, PairWithWeakHandling(wp2, wp2));
 
-  pairWeakMap->add(PairWithWeakHandling(pw1, pw1), pw1);
-  pairWeakMap->add(PairWithWeakHandling(pw1, pw2), pw1);
+  pairWeakMap->insert(PairWithWeakHandling(pw1, pw1), pw1);
+  pairWeakMap->insert(PairWithWeakHandling(pw1, pw2), pw1);
   // The map from (pw2, pw1) to pw1 would make pw2 live, so we skip that.
-  pairWeakMap->add(PairWithWeakHandling(pw2, pw2), pw1);
-  pairWeakMap2->add(PairWithWeakHandling(pw1, pw1), pw2);
-  pairWeakMap2->add(PairWithWeakHandling(pw1, pw2), pw2);
-  pairWeakMap2->add(PairWithWeakHandling(pw2, pw1), pw2);
-  pairWeakMap2->add(PairWithWeakHandling(pw2, pw2), pw2);
+  pairWeakMap->insert(PairWithWeakHandling(pw2, pw2), pw1);
+  pairWeakMap2->insert(PairWithWeakHandling(pw1, pw1), pw2);
+  pairWeakMap2->insert(PairWithWeakHandling(pw1, pw2), pw2);
+  pairWeakMap2->insert(PairWithWeakHandling(pw2, pw1), pw2);
+  pairWeakMap2->insert(PairWithWeakHandling(pw2, pw2), pw2);
 
   set->add(wp1);
   set->add(wp2);
   set->add(pw1);
   set->add(pw2);
 
   preciselyCollectGarbage();
 
   EXPECT_EQ(2u, weakPairMap->size());
   EXPECT_EQ(2u, weakPairMap2->size());
@@ skipping 43 matching lines @@
  private:
   Member<IntWrapper> m_link;
 };
 
 TEST(HeapTest, IndirectStrongToWeak) {
   typedef HeapHashMap<WeakMember<IntWrapper>, Member<Link1>> Map;
   Persistent<Map> map = new Map();
   Persistent<IntWrapper> deadObject =
       IntWrapper::create(100);  // Named for "Drowning by Numbers" (1988).
   Persistent<IntWrapper> lifeObject = IntWrapper::create(42);
-  map->add(deadObject, new Link1(deadObject));
-  map->add(lifeObject, new Link1(lifeObject));
+  map->insert(deadObject, new Link1(deadObject));
+  map->insert(lifeObject, new Link1(lifeObject));
   EXPECT_EQ(2u, map->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2u, map->size());
   EXPECT_EQ(deadObject, map->get(deadObject)->link());
   EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
   deadObject.clear();  // Now it can live up to its name.
   preciselyCollectGarbage();
   EXPECT_EQ(1u, map->size());
   EXPECT_EQ(lifeObject, map->get(lifeObject)->link());
   lifeObject.clear();  // Despite its name.
@@ skipping 85 matching lines @@
     // Create a weak collection that is kept alive by a persistent
     // and keep the contents alive with a persistents as
     // well.
     Persistent<IntWrapper> wrapper1 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper2 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper3 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper4 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper5 = IntWrapper::create(32);
     Persistent<IntWrapper> wrapper6 = IntWrapper::create(32);
     Persistent<WeakCollectionType> weakCollection = new WeakCollectionType;
-    weakCollection->add(wrapper1, wrapper1);
-    weakCollection->add(wrapper2, wrapper2);
-    weakCollection->add(wrapper3, wrapper3);
-    weakCollection->add(wrapper4, wrapper4);
-    weakCollection->add(wrapper5, wrapper5);
-    weakCollection->add(wrapper6, wrapper6);
+    weakCollection->insert(wrapper1, wrapper1);
+    weakCollection->insert(wrapper2, wrapper2);
+    weakCollection->insert(wrapper3, wrapper3);
+    weakCollection->insert(wrapper4, wrapper4);
+    weakCollection->insert(wrapper5, wrapper5);
+    weakCollection->insert(wrapper6, wrapper6);
 
     // Signal the main thread that the worker is done with its allocation.
     wakeMainThread();
 
     {
       // Wait for the main thread to do two GCs without sweeping
       // this thread heap. The worker waits within a safepoint,
       // but there is no sweeping until leaving the safepoint
       // scope. If the weak collection backing is marked dead
       // because of this we will not get strongification in the
@@ skipping 239 matching lines @@
     : blink::AllocatesOnAssignmentHashTraits {};
 
 }  // namespace WTF
 
 namespace blink {
 
 TEST(HeapTest, GCInHashMapOperations) {
   typedef HeapHashMap<AllocatesOnAssignment, AllocatesOnAssignment> Map;
   Map* map = new Map();
   IntWrapper* key = new IntWrapper(42);
-  map->add(key, AllocatesOnAssignment(103));
+  map->insert(key, AllocatesOnAssignment(103));
   map->erase(key);
   for (int i = 0; i < 10; i++)
-    map->add(AllocatesOnAssignment(i), AllocatesOnAssignment(i));
+    map->insert(AllocatesOnAssignment(i), AllocatesOnAssignment(i));
   for (Map::iterator it = map->begin(); it != map->end(); ++it)
     EXPECT_EQ(it->key.value(), it->value.value());
 }
 
 class PartObjectWithVirtualMethod {
  public:
   DEFINE_INLINE_VIRTUAL_TRACE() {}
 };
 
 class ObjectWithVirtualPartObject
@@ skipping 787 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink