Migrate WTF::HashCountedSet::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 2405 matching lines @@
       primitiveMember->insert(4, one);
       memberPrimitive->insert(one, 2);
       memberPrimitive->insert(two, 3);
       memberPrimitive->insert(three, 4);
       memberPrimitive->insert(four, 1);
       set2->insert(one);
       set2->insert(two);
       set2->insert(three);
       set2->insert(four);
       set->insert(oneB);
-      set3->add(oneB);
-      set3->add(oneB);
+      set3->insert(oneB);
+      set3->insert(oneB);
       vector->push_back(oneB);
       deque->push_back(oneB);
       vector2->push_back(threeB);
       vector2->push_back(fourB);
       deque2->push_back(threeE);
       deque2->push_back(fourE);
       vectorWU->push_back(PairWrappedUnwrapped(&*oneC, 42));
       dequeWU->push_back(PairWrappedUnwrapped(&*oneE, 42));
       vectorWU2->push_back(PairWrappedUnwrapped(&*threeC, 43));
       vectorWU2->push_back(PairWrappedUnwrapped(&*fourC, 44));
@@ skipping 506 matching lines @@
 
   {
     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->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]);
+    weakCountedSet->insert(IntWrapper::create(0));
+    weakCountedSet->insert(two);
+    weakCountedSet->insert(two);
+    weakCountedSet->insert(two);
+    weakCountedSet->insert(keepNumbersAlive[0]);
+    weakCountedSet->insert(keepNumbersAlive[1]);
     EXPECT_EQ(1u, weakStrong->size());
     EXPECT_EQ(1u, strongWeak->size());
     EXPECT_EQ(2u, weakWeak->size());
     EXPECT_EQ(4u, weakSet->size());
     EXPECT_EQ(4u, weakCountedSet->size());
     EXPECT_EQ(3u, weakCountedSet->find(two)->value);
     weakCountedSet->remove(two);
     EXPECT_EQ(2u, weakCountedSet->find(two)->value);
   }
 
@@ skipping 582 matching lines @@
       EXPECT_EQ(0u, weakWeak->size());
       EXPECT_EQ(0u, weakSet->size());
       EXPECT_EQ(0u, weakOrderedSet->size());
     }
   }
 }
 
 TEST(HeapTest, HeapHashCountedSetToVector) {
   HeapHashCountedSet<Member<IntWrapper>> set;
   HeapVector<Member<IntWrapper>> vector;
-  set.add(new IntWrapper(1));
-  set.add(new IntWrapper(1));
-  set.add(new IntWrapper(2));
+  set.insert(new IntWrapper(1));
+  set.insert(new IntWrapper(1));
+  set.insert(new IntWrapper(2));
 
   copyToVector(set, vector);
   EXPECT_EQ(3u, vector.size());
 
   Vector<int> intVector;
   for (const auto& i : vector)
     intVector.push_back(i->value());
   std::sort(intVector.begin(), intVector.end());
   ASSERT_EQ(3u, intVector.size());
   EXPECT_EQ(1, intVector[0]);
   EXPECT_EQ(1, intVector[1]);
   EXPECT_EQ(2, intVector[2]);
 }
 
 TEST(HeapTest, WeakHeapHashCountedSetToVector) {
   HeapHashCountedSet<WeakMember<IntWrapper>> set;
   HeapVector<Member<IntWrapper>> vector;
-  set.add(new IntWrapper(1));
-  set.add(new IntWrapper(1));
-  set.add(new IntWrapper(2));
+  set.insert(new IntWrapper(1));
+  set.insert(new IntWrapper(1));
+  set.insert(new IntWrapper(2));
 
   copyToVector(set, vector);
   EXPECT_LE(3u, vector.size());
   for (const auto& i : vector)
     EXPECT_TRUE(i->value() == 1 || i->value() == 2);
 }
 
 TEST(HeapTest, RefCountedGarbageCollected) {
   RefCountedAndGarbageCollected::s_destructorCalls = 0;
   {
@@ skipping 2750 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink