Migrate WTF::HashSet::add() to ::insert() [continued]

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 2404 matching lines @@
       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);
+      set2->insert(one);
+      set2->insert(two);
+      set2->insert(three);
+      set2->insert(four);
+      set->insert(oneB);
       set3->add(oneB);
       set3->add(oneB);
       vector->push_back(oneB);
       deque->append(oneB);
       vector2->push_back(threeB);
       vector2->push_back(fourB);
       deque2->append(threeE);
       deque2->append(fourE);
       vectorWU->push_back(PairWrappedUnwrapped(&*oneC, 42));
       dequeWU->append(PairWrappedUnwrapped(&*oneE, 42));
@@ skipping 336 matching lines @@
   IntWrapper* oneRaw = IntWrapper::create(1);
   Persistent<IntWrapper> one(oneRaw);
   Persistent<IntWrapper> one2(oneRaw);
   Persistent<IntWrapper> two(IntWrapper::create(2));
   Persistent<IntWrapper> three(IntWrapper::create(3));
   Persistent<IntWrapper> four(IntWrapper::create(4));
   Persistent<IntWrapper> five(IntWrapper::create(5));
   Persistent<IntWrapper> six(IntWrapper::create(6));
   {
     PersistentSet set;
-    set.add(one);
-    set.add(two);
+    set.insert(one);
+    set.insert(two);
     conservativelyCollectGarbage();
     EXPECT_TRUE(set.contains(one));
     EXPECT_TRUE(set.contains(one2));
     EXPECT_TRUE(set.contains(two));
 
-    set.add(three);
-    set.add(four);
+    set.insert(three);
+    set.insert(four);
     conservativelyCollectGarbage();
     EXPECT_TRUE(set.contains(one));
     EXPECT_TRUE(set.contains(two));
     EXPECT_TRUE(set.contains(three));
     EXPECT_TRUE(set.contains(four));
 
     set.clear();
     conservativelyCollectGarbage();
     EXPECT_FALSE(set.contains(one));
     EXPECT_FALSE(set.contains(two));
     EXPECT_FALSE(set.contains(three));
     EXPECT_FALSE(set.contains(four));
   }
   {
     PersistentSet set1;
     PersistentSet set2;
 
-    set1.add(one);
-    set2.add(two);
+    set1.insert(one);
+    set2.insert(two);
     set1.swap(set2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(set1.contains(two));
     EXPECT_TRUE(set2.contains(one));
     EXPECT_TRUE(set2.contains(one2));
   }
 }
 
 TEST(HeapTest, CrossThreadPersistentSet) {
   IntWrapper::s_destructorCalls = 0;
 
   typedef HashSet<CrossThreadPersistent<IntWrapper>> CrossThreadPersistentSet;
 
   IntWrapper* oneRaw = IntWrapper::create(1);
   CrossThreadPersistent<IntWrapper> one(oneRaw);
   CrossThreadPersistent<IntWrapper> one2(oneRaw);
   CrossThreadPersistent<IntWrapper> two(IntWrapper::create(2));
   CrossThreadPersistent<IntWrapper> three(IntWrapper::create(3));
   CrossThreadPersistent<IntWrapper> four(IntWrapper::create(4));
   CrossThreadPersistent<IntWrapper> five(IntWrapper::create(5));
   CrossThreadPersistent<IntWrapper> six(IntWrapper::create(6));
   {
     CrossThreadPersistentSet set;
-    set.add(one);
-    set.add(two);
+    set.insert(one);
+    set.insert(two);
     conservativelyCollectGarbage();
     EXPECT_TRUE(set.contains(one));
     EXPECT_TRUE(set.contains(one2));
     EXPECT_TRUE(set.contains(two));
 
-    set.add(three);
-    set.add(four);
+    set.insert(three);
+    set.insert(four);
     conservativelyCollectGarbage();
     EXPECT_TRUE(set.contains(one));
     EXPECT_TRUE(set.contains(two));
     EXPECT_TRUE(set.contains(three));
     EXPECT_TRUE(set.contains(four));
 
     set.clear();
     conservativelyCollectGarbage();
     EXPECT_FALSE(set.contains(one));
     EXPECT_FALSE(set.contains(two));
     EXPECT_FALSE(set.contains(three));
     EXPECT_FALSE(set.contains(four));
   }
   {
     CrossThreadPersistentSet set1;
     CrossThreadPersistentSet set2;
 
-    set1.add(one);
-    set2.add(two);
+    set1.insert(one);
+    set2.insert(two);
     set1.swap(set2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(set1.contains(two));
     EXPECT_TRUE(set2.contains(one));
     EXPECT_TRUE(set2.contains(one2));
   }
 }
 
 class NonTrivialObject final {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
@@ skipping 69 matching lines @@
   Persistent<IntWrapper> two = IntWrapper::create(2);
 
   keepNumbersAlive.push_back(IntWrapper::create(103));
   keepNumbersAlive.push_back(IntWrapper::create(10));
 
   {
     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]);
+    weakSet->insert(IntWrapper::create(0));
+    weakSet->insert(two);
+    weakSet->insert(keepNumbersAlive[0]);
+    weakSet->insert(keepNumbersAlive[1]);
     weakCountedSet->add(IntWrapper::create(0));
     weakCountedSet->add(two);
     weakCountedSet->add(two);
     weakCountedSet->add(two);
     weakCountedSet->add(keepNumbersAlive[0]);
     weakCountedSet->add(keepNumbersAlive[1]);
     EXPECT_EQ(1u, weakStrong->size());
     EXPECT_EQ(1u, strongWeak->size());
     EXPECT_EQ(2u, weakWeak->size());
     EXPECT_EQ(4u, weakSet->size());
@@ skipping 326 matching lines @@
 
   PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
 
   Persistent<WSSet> weakStrong = new WSSet();
   Persistent<SWSet> strongWeak = new SWSet();
   Persistent<WUSet> weakUnwrapped = new WUSet();
   Persistent<UWSet> unwrappedWeak = new UWSet();
 
   Persistent<IntWrapper> two = IntWrapper::create(2);
 
-  weakStrong->add(PairWeakStrong(IntWrapper::create(1), &*two));
-  weakStrong->add(PairWeakStrong(&*two, &*two));
-  strongWeak->add(PairStrongWeak(&*two, IntWrapper::create(1)));
-  strongWeak->add(PairStrongWeak(&*two, &*two));
-  weakUnwrapped->add(PairWeakUnwrapped(IntWrapper::create(1), 2));
-  weakUnwrapped->add(PairWeakUnwrapped(&*two, 2));
-  unwrappedWeak->add(PairUnwrappedWeak(2, IntWrapper::create(1)));
-  unwrappedWeak->add(PairUnwrappedWeak(2, &*two));
+  weakStrong->insert(PairWeakStrong(IntWrapper::create(1), &*two));
+  weakStrong->insert(PairWeakStrong(&*two, &*two));
+  strongWeak->insert(PairStrongWeak(&*two, IntWrapper::create(1)));
+  strongWeak->insert(PairStrongWeak(&*two, &*two));
+  weakUnwrapped->insert(PairWeakUnwrapped(IntWrapper::create(1), 2));
+  weakUnwrapped->insert(PairWeakUnwrapped(&*two, 2));
+  unwrappedWeak->insert(PairUnwrappedWeak(2, IntWrapper::create(1)));
+  unwrappedWeak->insert(PairUnwrappedWeak(2, &*two));
 
   checkPairSets<WSSet, SWSet, WUSet, UWSet>(
       weakStrong, strongWeak, weakUnwrapped, unwrappedWeak, true, two);
 
   preciselyCollectGarbage();
   checkPairSets<WSSet, SWSet, WUSet, UWSet>(
       weakStrong, strongWeak, weakUnwrapped, unwrappedWeak, false, two);
 }
 
 TEST(HeapTest, HeapWeakPairs) {
@@ skipping 67 matching lines @@
 
       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->insert(wrapped, wrapped2);
         strongWeak->insert(wrapped2, wrapped);
         weakWeak->insert(wrapped, wrapped2);
-        weakSet->add(wrapped);
+        weakSet->insert(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());
 
       // Collect garbage. This should change nothing since we are keeping
@@ skipping 96 matching lines @@
               count++;
           }
         }
         if (addAfterwards) {
           for (int i = 1000; i < 1100; i++) {
             IntWrapper* wrapped = IntWrapper::create(i);
             keepNumbersAlive.push_back(wrapped);
             weakStrong->insert(wrapped, wrapped);
             strongWeak->insert(wrapped, wrapped);
             weakWeak->insert(wrapped, wrapped);
-            weakSet->add(wrapped);
+            weakSet->insert(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());
         else if (collectionNumber == weakSetIndex)
@@ skipping 333 matching lines @@
 
     pDeque.append(seven);
     pDeque.append(two);
 
     Vec* vec = new Vec();
     vec->swap(pVec);
 
     pVec.push_back(two);
     pVec.push_back(three);
 
-    pSet.add(four);
+    pSet.insert(four);
     pListSet.add(eight);
     pLinkedSet.add(nine);
     pMap.insert(five, six);
     wpMap.insert(ten, eleven);
 
     // Collect |vec| and |one|.
     vec = 0;
     preciselyCollectGarbage();
     EXPECT_EQ(1, IntWrapper::s_destructorCalls);
 
@@ skipping 86 matching lines @@
   EXPECT_EQ(0, UseMixin::s_traceCount);
   preciselyCollectGarbage();
   EXPECT_EQ(1, UseMixin::s_traceCount);
 
   Persistent<Mixin> mixin = usemixin;
   usemixin = nullptr;
   preciselyCollectGarbage();
   EXPECT_EQ(2, UseMixin::s_traceCount);
 
   PersistentHeapHashSet<WeakMember<Mixin>> weakMap;
-  weakMap.add(UseMixin::create());
+  weakMap.insert(UseMixin::create());
   preciselyCollectGarbage();
   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->insert(key, IntSet());
 
   HeapHashMap<void*, IntSet>::iterator it = map->find(key);
   EXPECT_EQ(0u, map->get(key).size());
 
-  it->value.add(IntWrapper::create(42));
+  it->value.insert(IntWrapper::create(42));
   EXPECT_EQ(1u, map->get(key).size());
 
   Persistent<HeapHashMap<void*, IntSet>> keepAlive(map);
   preciselyCollectGarbage();
   EXPECT_EQ(1u, map->get(key).size());
   EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, CollectionNesting3) {
   clearOutOldGarbage();
@@ skipping 625 matching lines @@
 }
 
 template <typename Set>
 void setWithCustomWeaknessHandling() {
   typedef typename Set::iterator Iterator;
   Persistent<IntWrapper> livingInt(IntWrapper::create(42));
   Persistent<Set> set1(new Set());
   {
     Set set2;
     Set* set3 = new Set();
-    set2.add(
+    set2.insert(
         PairWithWeakHandling(IntWrapper::create(0), IntWrapper::create(1)));
-    set3->add(
+    set3->insert(
         PairWithWeakHandling(IntWrapper::create(2), IntWrapper::create(3)));
-    set1->add(
+    set1->insert(
         PairWithWeakHandling(IntWrapper::create(4), IntWrapper::create(5)));
     conservativelyCollectGarbage();
     // The first set is pointed to from a persistent, so it's referenced, but
     // the weak processing may have taken place.
     if (set1->size()) {
       Iterator i1 = set1->begin();
       EXPECT_EQ(4, i1->first->value());
       EXPECT_EQ(5, i1->second->value());
     }
     // The second set is on-stack, so its backing store must be referenced from
     // the stack. That makes the weak references strong.
     Iterator i2 = set2.begin();
     EXPECT_EQ(0, i2->first->value());
     EXPECT_EQ(1, i2->second->value());
     // The third set is pointed to from the stack, so it's referenced, but the
     // weak processing may have taken place.
     if (set3->size()) {
       Iterator i3 = set3->begin();
       EXPECT_EQ(2, i3->first->value());
       EXPECT_EQ(3, i3->second->value());
     }
   }
   preciselyCollectGarbage();
   EXPECT_EQ(0u, set1->size());
-  set1->add(PairWithWeakHandling(IntWrapper::create(103), livingInt));
+  set1->insert(PairWithWeakHandling(IntWrapper::create(103), livingInt));
   // This one gets zapped at GC time because nothing holds the 103 alive.
-  set1->add(PairWithWeakHandling(livingInt, IntWrapper::create(103)));
-  set1->add(PairWithWeakHandling(
+  set1->insert(PairWithWeakHandling(livingInt, IntWrapper::create(103)));
+  set1->insert(PairWithWeakHandling(
       IntWrapper::create(103),
       IntWrapper::create(103)));  // This one gets zapped too.
-  set1->add(PairWithWeakHandling(livingInt, livingInt));
+  set1->insert(PairWithWeakHandling(livingInt, livingInt));
   // This one is identical to the previous and doesn't add anything.
-  set1->add(PairWithWeakHandling(livingInt, livingInt));
+  set1->insert(PairWithWeakHandling(livingInt, livingInt));
   EXPECT_EQ(4u, set1->size());
   preciselyCollectGarbage();
   EXPECT_EQ(2u, set1->size());
   Iterator i1 = set1->begin();
   EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
   EXPECT_EQ(livingInt, i1->second);
   ++i1;
   EXPECT_TRUE(i1->first->value() == 103 || i1->first == livingInt);
   EXPECT_EQ(livingInt, i1->second);
 }
@@ skipping 254 matching lines @@
   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->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.
+    set.insert(IntWrapper::create(103));  // Weak set can't hold this long.
+    set.insert(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->insert(OffHeapInt::create(2), WeakSet());
   EXPECT_EQ(2u, map->size());
 
   preciselyCollectGarbage();
   EXPECT_EQ(1u, map->size());  // The one with key 2 was removed.
@@ skipping 150 matching lines @@
 
   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->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);
+  set->insert(wp1);
+  set->insert(wp2);
+  set->insert(pw1);
+  set->insert(pw2);
 
   preciselyCollectGarbage();
 
   EXPECT_EQ(2u, weakPairMap->size());
   EXPECT_EQ(2u, weakPairMap2->size());
   EXPECT_EQ(1u, weakPairMap3->size());
   EXPECT_EQ(2u, weakPairMap4->size());
 
   EXPECT_EQ(3u, pairWeakMap->size());
   EXPECT_EQ(4u, pairWeakMap2->size());
@@ skipping 1090 matching lines @@
       return;
 
     // Verify that the weak reference is gone.
     EXPECT_FALSE(weakHeapObjectSet().contains(this));
 
     // Add a new member to the static singleton; this will
     // re-initializes the persistent node of the collection
     // object. Done while terminating the test thread, so
     // verify that this brings about the release of the
     // persistent also.
-    heapObjectSet().add(create(false));
+    heapObjectSet().insert(create(false));
   }
 
   DEFINE_INLINE_TRACE() {}
 
  private:
   explicit HeapObject(bool testDestructor) : m_testDestructor(testDestructor) {}
 
   bool m_testDestructor;
 };
 
@@ skipping 13 matching lines @@
                                   new ThreadSpecific<HeapObjectSet>);
   if (!singleton.isSet())
     singleton->registerAsStaticReference();
 
   return *singleton;
 }
 
 void ThreadedClearOnShutdownTester::runWhileAttached() {
   EXPECT_EQ(42, threadSpecificIntWrapper().value());
   // Creates a thread-specific singleton to a weakly held object.
-  weakHeapObjectSet().add(HeapObject::create(true));
+  weakHeapObjectSet().insert(HeapObject::create(true));
 }
 
 }  // namespace
 
 TEST(HeapTest, TestClearOnShutdown) {
   ThreadedClearOnShutdownTester::test();
 }
 
 // Verify that WeakMember<const T> compiles and behaves as expected.
 class WithWeakConstObject final : public GarbageCollected<WithWeakConstObject> {
@@ skipping 76 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink