Migrate WTF::LinkedHashSet/ListHashSet::add() to ::insert()

third_party/WebKit/Source/platform/heap/HeapCompactTest.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/heap/Handle.h"
 #include "platform/heap/SparseHeapBitmap.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Deque.h"
@@ skipping 336 matching lines @@
 
   for (size_t i = 0; i < deque->size(); ++i)
     EXPECT_EQ(static_cast<int>(7 - i), deque->at(i).at(i)->value());
 }
 
 TEST(HeapCompactTest, CompactLinkedHashSet) {
   using OrderedHashSet = HeapLinkedHashSet<Member<IntWrapper>>;
   Persistent<OrderedHashSet> set = new OrderedHashSet;
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::create(i);
-    set->add(value);
+    set->insert(value);
   }
   EXPECT_EQ(13u, set->size());
 
   int expected = 0;
   for (IntWrapper* v : *set) {
     EXPECT_EQ(expected, v->value());
     expected++;
   }
 
   performHeapCompaction();
 
   expected = 0;
   for (IntWrapper* v : *set) {
     EXPECT_EQ(expected, v->value());
     expected++;
   }
 }
 
 TEST(HeapCompactTest, CompactLinkedHashSetVector) {
   using OrderedHashSet = HeapLinkedHashSet<Member<IntVector>>;
   Persistent<OrderedHashSet> set = new OrderedHashSet;
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::create(i);
     IntVector* vector = new IntVector(19, value);
-    set->add(vector);
+    set->insert(vector);
   }
   EXPECT_EQ(13u, set->size());
 
   int expected = 0;
   for (IntVector* v : *set) {
     EXPECT_EQ(expected, (*v)[0]->value());
     expected++;
   }
 
   performHeapCompaction();
 
   expected = 0;
   for (IntVector* v : *set) {
     EXPECT_EQ(expected, (*v)[0]->value());
     expected++;
   }
 }
 
 TEST(HeapCompactTest, CompactLinkedHashSetMap) {
   using Inner = HeapHashSet<Member<IntWrapper>>;
   using OrderedHashSet = HeapLinkedHashSet<Member<Inner>>;
 
   Persistent<OrderedHashSet> set = new OrderedHashSet;
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::create(i);
     Inner* inner = new Inner;
     inner->insert(value);
-    set->add(inner);
+    set->insert(inner);
   }
   EXPECT_EQ(13u, set->size());
 
   int expected = 0;
   for (const Inner* v : *set) {
     EXPECT_EQ(1u, v->size());
     EXPECT_EQ(expected, (*v->begin())->value());
     expected++;
   }
 
   performHeapCompaction();
 
   expected = 0;
   for (const Inner* v : *set) {
     EXPECT_EQ(1u, v->size());
     EXPECT_EQ(expected, (*v->begin())->value());
     expected++;
   }
 }
 
 TEST(HeapCompactTest, CompactLinkedHashSetNested) {
   using Inner = HeapLinkedHashSet<Member<IntWrapper>>;
   using OrderedHashSet = HeapLinkedHashSet<Member<Inner>>;
 
   Persistent<OrderedHashSet> set = new OrderedHashSet;
   for (int i = 0; i < 13; ++i) {
     IntWrapper* value = IntWrapper::create(i);
     Inner* inner = new Inner;
-    inner->add(value);
-    set->add(inner);
+    inner->insert(value);
+    set->insert(inner);
   }
   EXPECT_EQ(13u, set->size());
 
   int expected = 0;
   for (const Inner* v : *set) {
     EXPECT_EQ(1u, v->size());
     EXPECT_EQ(expected, (*v->begin())->value());
     expected++;
   }
 
   performHeapCompaction();
 
   expected = 0;
   for (const Inner* v : *set) {
     EXPECT_EQ(1u, v->size());
     EXPECT_EQ(expected, (*v->begin())->value());
     expected++;
   }
 }
 
 }  // namespace blink