Migrate WTF::LinkedHashSet/ListHashSet::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 2976 matching lines @@
 
   Persistent<Set> set1 = new Set();
   Persistent<Set> set2 = new Set();
 
   const Set& constSet = *set1.get();
 
   keepNumbersAlive.push_back(IntWrapper::create(2));
   keepNumbersAlive.push_back(IntWrapper::create(103));
   keepNumbersAlive.push_back(IntWrapper::create(10));
 
-  set1->add(IntWrapper::create(0));
-  set1->add(keepNumbersAlive[0]);
-  set1->add(keepNumbersAlive[1]);
-  set1->add(keepNumbersAlive[2]);
+  set1->insert(IntWrapper::create(0));
+  set1->insert(keepNumbersAlive[0]);
+  set1->insert(keepNumbersAlive[1]);
+  set1->insert(keepNumbersAlive[2]);
 
   set2->clear();
-  set2->add(IntWrapper::create(42));
+  set2->insert(IntWrapper::create(42));
   set2->clear();
 
   EXPECT_EQ(4u, set1->size());
   typename Set::iterator it(set1->begin());
   typename Set::reverse_iterator reverse(set1->rbegin());
   typename Set::const_iterator cit(constSet.begin());
   typename Set::const_reverse_iterator creverse(constSet.rbegin());
 
   EXPECT_EQ(0, (*it)->value());
   EXPECT_EQ(0, (*cit)->value());
@@ skipping 372 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->insert(wrapped);
-        weakOrderedSet->add(wrapped);
+        weakOrderedSet->insert(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
       // alive the IntWrapper objects.
@@ skipping 96 matching lines @@
           }
         }
         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->insert(wrapped);
-            weakOrderedSet->add(wrapped);
+            weakOrderedSet->insert(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)
           EXPECT_EQ(count + added, weakSet->size());
@@ 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.insert(four);
-    pListSet.add(eight);
-    pLinkedSet.add(nine);
+    pListSet.insert(eight);
+    pLinkedSet.insert(nine);
     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));
@@ skipping 2466 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink