Migrate WTF::Vector::append() to ::push_back() [part 14 of N]

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 471 matching lines @@
 };
 
 int IntWrapper::s_destructorCalls = 0;
 int OffHeapInt::s_destructorCalls = 0;
 
 class ThreadedTesterBase {
  protected:
   static void test(ThreadedTesterBase* tester) {
     Vector<std::unique_ptr<WebThread>, numberOfThreads> m_threads;
     for (int i = 0; i < numberOfThreads; i++) {
-      m_threads.append(WTF::wrapUnique(
+      m_threads.push_back(WTF::wrapUnique(
           Platform::current()->createThread("blink gc testing thread")));
       m_threads.back()->getWebTaskRunner()->postTask(
           BLINK_FROM_HERE,
           crossThreadBind(threadFunc, crossThreadUnretained(tester)));
     }
     while (tester->m_threadsToFinish) {
       SafePointScope scope(BlinkGC::NoHeapPointersOnStack);
       testing::yieldCurrentThread();
     }
     delete tester;
@@ skipping 47 matching lines @@
   Vector<std::unique_ptr<GlobalIntWrapperPersistent>> m_crossPersistents;
 
   std::unique_ptr<GlobalIntWrapperPersistent> createGlobalPersistent(
       int value) {
     return WTF::wrapUnique(
         new GlobalIntWrapperPersistent(IntWrapper::create(value)));
   }
 
   void addGlobalPersistent() {
     MutexLocker lock(m_mutex);
-    m_crossPersistents.append(createGlobalPersistent(0x2a2a2a2a));
+    m_crossPersistents.push_back(createGlobalPersistent(0x2a2a2a2a));
   }
 
   void runThread() override {
     ThreadState::attachCurrentThread(BlinkGC::MainThreadHeapMode);
 
     // Add a cross-thread persistent from this thread; the test object
     // verifies that it will have been cleared out after the threads
     // have all detached, running their termination GCs while doing so.
     addGlobalPersistent();
 
@@ skipping 1773 matching lines @@
 
 TEST(HeapTest, HeapVectorWithInlineCapacity) {
   IntWrapper* one = IntWrapper::create(1);
   IntWrapper* two = IntWrapper::create(2);
   IntWrapper* three = IntWrapper::create(3);
   IntWrapper* four = IntWrapper::create(4);
   IntWrapper* five = IntWrapper::create(5);
   IntWrapper* six = IntWrapper::create(6);
   {
     HeapVector<Member<IntWrapper>, 2> vector;
-    vector.append(one);
-    vector.append(two);
+    vector.push_back(one);
+    vector.push_back(two);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_TRUE(vector.contains(two));
 
-    vector.append(three);
-    vector.append(four);
+    vector.push_back(three);
+    vector.push_back(four);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_TRUE(vector.contains(two));
     EXPECT_TRUE(vector.contains(three));
     EXPECT_TRUE(vector.contains(four));
 
     vector.shrink(1);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_FALSE(vector.contains(two));
     EXPECT_FALSE(vector.contains(three));
     EXPECT_FALSE(vector.contains(four));
   }
   {
     HeapVector<Member<IntWrapper>, 2> vector1;
     HeapVector<Member<IntWrapper>, 2> vector2;
 
-    vector1.append(one);
-    vector2.append(two);
+    vector1.push_back(one);
+    vector2.push_back(two);
     vector1.swap(vector2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector1.contains(two));
     EXPECT_TRUE(vector2.contains(one));
   }
   {
     HeapVector<Member<IntWrapper>, 2> vector1;
     HeapVector<Member<IntWrapper>, 2> vector2;
 
-    vector1.append(one);
-    vector1.append(two);
-    vector2.append(three);
-    vector2.append(four);
-    vector2.append(five);
-    vector2.append(six);
+    vector1.push_back(one);
+    vector1.push_back(two);
+    vector2.push_back(three);
+    vector2.push_back(four);
+    vector2.push_back(five);
+    vector2.push_back(six);
     vector1.swap(vector2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector1.contains(three));
     EXPECT_TRUE(vector1.contains(four));
     EXPECT_TRUE(vector1.contains(five));
     EXPECT_TRUE(vector1.contains(six));
     EXPECT_TRUE(vector2.contains(one));
     EXPECT_TRUE(vector2.contains(two));
   }
 }
@@ skipping 143 matching lines @@
       memberPrimitive->add(two, 3);
       memberPrimitive->add(three, 4);
       memberPrimitive->add(four, 1);
       set2->add(one);
       set2->add(two);
       set2->add(three);
       set2->add(four);
       set->add(oneB);
       set3->add(oneB);
       set3->add(oneB);
-      vector->append(oneB);
+      vector->push_back(oneB);
       deque->append(oneB);
-      vector2->append(threeB);
-      vector2->append(fourB);
+      vector2->push_back(threeB);
+      vector2->push_back(fourB);
       deque2->append(threeE);
       deque2->append(fourE);
-      vectorWU->append(PairWrappedUnwrapped(&*oneC, 42));
+      vectorWU->push_back(PairWrappedUnwrapped(&*oneC, 42));
       dequeWU->append(PairWrappedUnwrapped(&*oneE, 42));
-      vectorWU2->append(PairWrappedUnwrapped(&*threeC, 43));
-      vectorWU2->append(PairWrappedUnwrapped(&*fourC, 44));
-      vectorWU2->append(PairWrappedUnwrapped(&*fiveC, 45));
+      vectorWU2->push_back(PairWrappedUnwrapped(&*threeC, 43));
+      vectorWU2->push_back(PairWrappedUnwrapped(&*fourC, 44));
+      vectorWU2->push_back(PairWrappedUnwrapped(&*fiveC, 45));
       dequeWU2->append(PairWrappedUnwrapped(&*threeE, 43));
       dequeWU2->append(PairWrappedUnwrapped(&*fourE, 44));
       dequeWU2->append(PairWrappedUnwrapped(&*fiveE, 45));
-      vectorUW->append(PairUnwrappedWrapped(1, &*oneD));
-      vectorUW2->append(PairUnwrappedWrapped(103, &*threeD));
-      vectorUW2->append(PairUnwrappedWrapped(104, &*fourD));
-      vectorUW2->append(PairUnwrappedWrapped(105, &*fiveD));
+      vectorUW->push_back(PairUnwrappedWrapped(1, &*oneD));
+      vectorUW2->push_back(PairUnwrappedWrapped(103, &*threeD));
+      vectorUW2->push_back(PairUnwrappedWrapped(104, &*fourD));
+      vectorUW2->push_back(PairUnwrappedWrapped(105, &*fiveD));
       dequeUW->append(PairUnwrappedWrapped(1, &*oneF));
       dequeUW2->append(PairUnwrappedWrapped(103, &*threeF));
       dequeUW2->append(PairUnwrappedWrapped(104, &*fourF));
       dequeUW2->append(PairUnwrappedWrapped(105, &*fiveF));
 
       EXPECT_TRUE(dequeContains(*deque, oneB));
 
       // Collect garbage. This should change nothing since we are keeping
       // alive the IntWrapper objects with on-stack pointers.
       conservativelyCollectGarbage();
@@ skipping 182 matching lines @@
   typedef Vector<Persistent<IntWrapper>> PersistentVector;
 
   Persistent<IntWrapper> one(IntWrapper::create(1));
   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));
   {
     PersistentVector vector;
-    vector.append(one);
-    vector.append(two);
+    vector.push_back(one);
+    vector.push_back(two);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_TRUE(vector.contains(two));
 
-    vector.append(three);
-    vector.append(four);
+    vector.push_back(three);
+    vector.push_back(four);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_TRUE(vector.contains(two));
     EXPECT_TRUE(vector.contains(three));
     EXPECT_TRUE(vector.contains(four));
 
     vector.shrink(1);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_FALSE(vector.contains(two));
     EXPECT_FALSE(vector.contains(three));
     EXPECT_FALSE(vector.contains(four));
   }
   {
     PersistentVector vector1;
     PersistentVector vector2;
 
-    vector1.append(one);
-    vector2.append(two);
+    vector1.push_back(one);
+    vector2.push_back(two);
     vector1.swap(vector2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector1.contains(two));
     EXPECT_TRUE(vector2.contains(one));
   }
   {
     PersistentVector vector1;
     PersistentVector vector2;
 
-    vector1.append(one);
-    vector1.append(two);
-    vector2.append(three);
-    vector2.append(four);
-    vector2.append(five);
-    vector2.append(six);
+    vector1.push_back(one);
+    vector1.push_back(two);
+    vector2.push_back(three);
+    vector2.push_back(four);
+    vector2.push_back(five);
+    vector2.push_back(six);
     vector1.swap(vector2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector1.contains(three));
     EXPECT_TRUE(vector1.contains(four));
     EXPECT_TRUE(vector1.contains(five));
     EXPECT_TRUE(vector1.contains(six));
     EXPECT_TRUE(vector2.contains(one));
     EXPECT_TRUE(vector2.contains(two));
   }
 }
 
 TEST(HeapTest, CrossThreadPersistentVector) {
   IntWrapper::s_destructorCalls = 0;
 
   typedef Vector<CrossThreadPersistent<IntWrapper>> CrossThreadPersistentVector;
 
   CrossThreadPersistent<IntWrapper> one(IntWrapper::create(1));
   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));
   {
     CrossThreadPersistentVector vector;
-    vector.append(one);
-    vector.append(two);
+    vector.push_back(one);
+    vector.push_back(two);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_TRUE(vector.contains(two));
 
-    vector.append(three);
-    vector.append(four);
+    vector.push_back(three);
+    vector.push_back(four);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_TRUE(vector.contains(two));
     EXPECT_TRUE(vector.contains(three));
     EXPECT_TRUE(vector.contains(four));
 
     vector.shrink(1);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector.contains(one));
     EXPECT_FALSE(vector.contains(two));
     EXPECT_FALSE(vector.contains(three));
     EXPECT_FALSE(vector.contains(four));
   }
   {
     CrossThreadPersistentVector vector1;
     CrossThreadPersistentVector vector2;
 
-    vector1.append(one);
-    vector2.append(two);
+    vector1.push_back(one);
+    vector2.push_back(two);
     vector1.swap(vector2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector1.contains(two));
     EXPECT_TRUE(vector2.contains(one));
   }
   {
     CrossThreadPersistentVector vector1;
     CrossThreadPersistentVector vector2;
 
-    vector1.append(one);
-    vector1.append(two);
-    vector2.append(three);
-    vector2.append(four);
-    vector2.append(five);
-    vector2.append(six);
+    vector1.push_back(one);
+    vector1.push_back(two);
+    vector2.push_back(three);
+    vector2.push_back(four);
+    vector2.push_back(five);
+    vector2.push_back(six);
     vector1.swap(vector2);
     conservativelyCollectGarbage();
     EXPECT_TRUE(vector1.contains(three));
     EXPECT_TRUE(vector1.contains(four));
     EXPECT_TRUE(vector1.contains(five));
     EXPECT_TRUE(vector1.contains(six));
     EXPECT_TRUE(vector2.contains(one));
     EXPECT_TRUE(vector2.contains(two));
   }
 }
@@ skipping 100 matching lines @@
   }
 }
 
 class NonTrivialObject final {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   NonTrivialObject() {}
   explicit NonTrivialObject(int num) {
     m_deque.append(IntWrapper::create(num));
-    m_vector.append(IntWrapper::create(num));
+    m_vector.push_back(IntWrapper::create(num));
   }
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_deque);
     visitor->trace(m_vector);
   }
 
  private:
   HeapDeque<Member<IntWrapper>> m_deque;
   HeapVector<Member<IntWrapper>> m_vector;
 };
@@ skipping 45 matching lines @@
   typedef HeapHashCountedSet<WeakMember<IntWrapper>> WeakCountedSet;
 
   Persistent<WeakStrong> weakStrong = new WeakStrong();
   Persistent<StrongWeak> strongWeak = new StrongWeak();
   Persistent<WeakWeak> weakWeak = new WeakWeak();
   Persistent<WeakSet> weakSet = new WeakSet();
   Persistent<WeakCountedSet> weakCountedSet = new WeakCountedSet();
 
   Persistent<IntWrapper> two = IntWrapper::create(2);
 
-  keepNumbersAlive.append(IntWrapper::create(103));
-  keepNumbersAlive.append(IntWrapper::create(10));
+  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);
     weakSet->add(IntWrapper::create(0));
     weakSet->add(two);
     weakSet->add(keepNumbersAlive[0]);
     weakSet->add(keepNumbersAlive[1]);
@@ skipping 29 matching lines @@
   clearOutOldGarbage();
   IntWrapper::s_destructorCalls = 0;
 
   PersistentHeapVector<Member<IntWrapper>> keepNumbersAlive;
 
   Persistent<Set> set1 = new Set();
   Persistent<Set> set2 = new Set();
 
   const Set& constSet = *set1.get();
 
-  keepNumbersAlive.append(IntWrapper::create(2));
-  keepNumbersAlive.append(IntWrapper::create(103));
-  keepNumbersAlive.append(IntWrapper::create(10));
+  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]);
 
   set2->clear();
   set2->add(IntWrapper::create(42));
   set2->clear();
 
@@ skipping 373 matching lines @@
       Persistent<StrongWeak> strongWeak = new StrongWeak();
       Persistent<WeakWeak> weakWeak = new WeakWeak();
 
       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.append(wrapped);
-        keepNumbersAlive.append(wrapped2);
+        keepNumbersAlive.push_back(wrapped);
+        keepNumbersAlive.push_back(wrapped2);
         weakStrong->add(wrapped, wrapped2);
         strongWeak->add(wrapped2, wrapped);
         weakWeak->add(wrapped, wrapped2);
         weakSet->add(wrapped);
         weakOrderedSet->add(wrapped);
       }
 
       EXPECT_EQ(64u, weakStrong->size());
       EXPECT_EQ(64u, strongWeak->size());
       EXPECT_EQ(64u, weakWeak->size());
@@ skipping 96 matching lines @@
             ASSERT_TRUE(weakOrderedSet->contains(keepNumbersAlive[i]));
             if (deleteAfterwards)
               weakOrderedSet->remove(keepNumbersAlive[i]);
             else
               count++;
           }
         }
         if (addAfterwards) {
           for (int i = 1000; i < 1100; i++) {
             IntWrapper* wrapped = IntWrapper::create(i);
-            keepNumbersAlive.append(wrapped);
+            keepNumbersAlive.push_back(wrapped);
             weakStrong->add(wrapped, wrapped);
             strongWeak->add(wrapped, wrapped);
             weakWeak->add(wrapped, wrapped);
             weakSet->add(wrapped);
             weakOrderedSet->add(wrapped);
           }
         }
         if (collectionNumber == weakStrongIndex)
           EXPECT_EQ(count + added, weakStrong->size());
         else if (collectionNumber == strongWeakIndex)
@@ skipping 42 matching lines @@
   HeapVector<Member<IntWrapper>> vector;
   set.add(new IntWrapper(1));
   set.add(new IntWrapper(1));
   set.add(new IntWrapper(2));
 
   copyToVector(set, vector);
   EXPECT_EQ(3u, vector.size());
 
   Vector<int> intVector;
   for (const auto& i : vector)
-    intVector.append(i->value());
+    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;
@@ skipping 209 matching lines @@
   ThreadHeap& heap = ThreadState::current()->heap();
   clearOutOldGarbage();
 
   Vector<Address> objectAddresses;
   Vector<Address> endAddresses;
   Address largeObjectAddress;
   Address largeObjectEndAddress;
   for (int i = 0; i < 10; i++) {
     SimpleObject* object = SimpleObject::create();
     Address objectAddress = reinterpret_cast<Address>(object);
-    objectAddresses.append(objectAddress);
-    endAddresses.append(objectAddress + sizeof(SimpleObject) - 1);
+    objectAddresses.push_back(objectAddress);
+    endAddresses.push_back(objectAddress + sizeof(SimpleObject) - 1);
   }
   LargeHeapObject* largeObject = LargeHeapObject::create();
   largeObjectAddress = reinterpret_cast<Address>(largeObject);
   largeObjectEndAddress = largeObjectAddress + sizeof(LargeHeapObject) - 1;
 
   // This is a low-level test where we call checkAndMarkPointer. This method
   // causes the object start bitmap to be computed which requires the heap
   // to be in a consistent state (e.g. the free allocation area must be put
   // into a free list header). However when we call makeConsistentForGC it
   // also clears out the freelists so we have to rebuild those before trying
@@ skipping 76 matching lines @@
     IntWrapper* three(IntWrapper::create(3));
     IntWrapper* four(IntWrapper::create(4));
     IntWrapper* five(IntWrapper::create(5));
     IntWrapper* six(IntWrapper::create(6));
     IntWrapper* seven(IntWrapper::create(7));
     IntWrapper* eight(IntWrapper::create(8));
     IntWrapper* nine(IntWrapper::create(9));
     Persistent<IntWrapper> ten(IntWrapper::create(10));
     IntWrapper* eleven(IntWrapper::create(11));
 
-    pVec.append(one);
-    pVec.append(two);
+    pVec.push_back(one);
+    pVec.push_back(two);
 
     pDeque.append(seven);
     pDeque.append(two);
 
     Vec* vec = new Vec();
     vec->swap(pVec);
 
-    pVec.append(two);
-    pVec.append(three);
+    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);
 
     // Collect |vec| and |one|.
     vec = 0;
     preciselyCollectGarbage();
@@ skipping 49 matching lines @@
 
   map->add(key, IntVector());
   map2->add(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.append(IntWrapper::create(42));
+  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());
@@ skipping 52 matching lines @@
 }
 
 TEST(HeapTest, CollectionNesting3) {
   clearOutOldGarbage();
   IntWrapper::s_destructorCalls = 0;
   typedef HeapVector<Member<IntWrapper>> IntVector;
   typedef HeapDeque<Member<IntWrapper>> IntDeque;
   HeapVector<IntVector>* vector = new HeapVector<IntVector>();
   HeapDeque<IntDeque>* deque = new HeapDeque<IntDeque>();
 
-  vector->append(IntVector());
+  vector->push_back(IntVector());
   deque->append(IntDeque());
 
   HeapVector<IntVector>::iterator it = vector->begin();
   HeapDeque<IntDeque>::iterator it2 = deque->begin();
   EXPECT_EQ(0u, it->size());
   EXPECT_EQ(0u, it2->size());
 
-  it->append(IntWrapper::create(42));
+  it->push_back(IntWrapper::create(42));
   it2->append(IntWrapper::create(42));
   EXPECT_EQ(1u, it->size());
   EXPECT_EQ(1u, it2->size());
 
   Persistent<HeapVector<IntVector>> keepAlive(vector);
   Persistent<HeapDeque<IntDeque>> keepAlive2(deque);
   preciselyCollectGarbage();
   EXPECT_EQ(1u, it->size());
   EXPECT_EQ(1u, it2->size());
   EXPECT_EQ(0, IntWrapper::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInVector) {
   clearOutOldGarbage();
   SimpleFinalizedObject::s_destructorCalls = 0;
   {
     PersistentHeapVector<VectorObject, 2> inlineVector;
     PersistentHeapVector<VectorObject> outlineVector;
     VectorObject i1, i2;
-    inlineVector.append(i1);
-    inlineVector.append(i2);
+    inlineVector.push_back(i1);
+    inlineVector.push_back(i2);
 
     VectorObject o1, o2;
-    outlineVector.append(o1);
-    outlineVector.append(o2);
+    outlineVector.push_back(o1);
+    outlineVector.push_back(o2);
 
     PersistentHeapVector<VectorObjectInheritedTrace> vectorInheritedTrace;
     VectorObjectInheritedTrace it1, it2;
-    vectorInheritedTrace.append(it1);
-    vectorInheritedTrace.append(it2);
+    vectorInheritedTrace.push_back(it1);
+    vectorInheritedTrace.push_back(it2);
 
     preciselyCollectGarbage();
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(6, SimpleFinalizedObject::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInDeque) {
   clearOutOldGarbage();
@@ skipping 52 matching lines @@
 
 WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::InlinedVectorObject);
 
 namespace blink {
 
 class InlinedVectorObjectWrapper final
     : public GarbageCollectedFinalized<InlinedVectorObjectWrapper> {
  public:
   InlinedVectorObjectWrapper() {
     InlinedVectorObject i1, i2;
-    m_vector1.append(i1);
-    m_vector1.append(i2);
-    m_vector2.append(i1);
-    m_vector2.append(i2);  // This allocates an out-of-line buffer.
-    m_vector3.append(i1);
-    m_vector3.append(i2);
+    m_vector1.push_back(i1);
+    m_vector1.push_back(i2);
+    m_vector2.push_back(i1);
+    m_vector2.push_back(i2);  // This allocates an out-of-line buffer.
+    m_vector3.push_back(i1);
+    m_vector3.push_back(i2);
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_vector1);
     visitor->trace(m_vector2);
     visitor->trace(m_vector3);
   }
 
  private:
   HeapVector<InlinedVectorObject> m_vector1;
   HeapVector<InlinedVectorObject, 1> m_vector2;
   HeapVector<InlinedVectorObject, 2> m_vector3;
 };
 
 class InlinedVectorObjectWithVtableWrapper final
     : public GarbageCollectedFinalized<InlinedVectorObjectWithVtableWrapper> {
  public:
   InlinedVectorObjectWithVtableWrapper() {
     InlinedVectorObjectWithVtable i1, i2;
-    m_vector1.append(i1);
-    m_vector1.append(i2);
-    m_vector2.append(i1);
-    m_vector2.append(i2);  // This allocates an out-of-line buffer.
-    m_vector3.append(i1);
-    m_vector3.append(i2);
+    m_vector1.push_back(i1);
+    m_vector1.push_back(i2);
+    m_vector2.push_back(i1);
+    m_vector2.push_back(i2);  // This allocates an out-of-line buffer.
+    m_vector3.push_back(i1);
+    m_vector3.push_back(i2);
   }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_vector1);
     visitor->trace(m_vector2);
     visitor->trace(m_vector3);
   }
 
  private:
   HeapVector<InlinedVectorObjectWithVtable> m_vector1;
   HeapVector<InlinedVectorObjectWithVtable, 1> m_vector2;
   HeapVector<InlinedVectorObjectWithVtable, 2> m_vector3;
 };
 
 TEST(HeapTest, VectorDestructors) {
   clearOutOldGarbage();
   InlinedVectorObject::s_destructorCalls = 0;
   {
     HeapVector<InlinedVectorObject> vector;
     InlinedVectorObject i1, i2;
-    vector.append(i1);
-    vector.append(i2);
+    vector.push_back(i1);
+    vector.push_back(i2);
   }
   preciselyCollectGarbage();
   // This is not EXPECT_EQ but EXPECT_LE because a HeapVectorBacking calls
   // destructors for all elements in (not the size but) the capacity of
   // the vector. Thus the number of destructors called becomes larger
   // than the actual number of objects in the vector.
   EXPECT_LE(4, InlinedVectorObject::s_destructorCalls);
 
   InlinedVectorObject::s_destructorCalls = 0;
   {
     HeapVector<InlinedVectorObject, 1> vector;
     InlinedVectorObject i1, i2;
-    vector.append(i1);
-    vector.append(i2);  // This allocates an out-of-line buffer.
+    vector.push_back(i1);
+    vector.push_back(i2);  // This allocates an out-of-line buffer.
   }
   preciselyCollectGarbage();
   EXPECT_LE(4, InlinedVectorObject::s_destructorCalls);
 
   InlinedVectorObject::s_destructorCalls = 0;
   {
     HeapVector<InlinedVectorObject, 2> vector;
     InlinedVectorObject i1, i2;
-    vector.append(i1);
-    vector.append(i2);
+    vector.push_back(i1);
+    vector.push_back(i2);
   }
   preciselyCollectGarbage();
   EXPECT_LE(4, InlinedVectorObject::s_destructorCalls);
 
   InlinedVectorObject::s_destructorCalls = 0;
   {
     Persistent<InlinedVectorObjectWrapper> vectorWrapper =
         new InlinedVectorObjectWrapper();
     conservativelyCollectGarbage();
     EXPECT_EQ(2, InlinedVectorObject::s_destructorCalls);
   }
   preciselyCollectGarbage();
   EXPECT_LE(8, InlinedVectorObject::s_destructorCalls);
 }
 
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, enable this test.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
 TEST(HeapTest, VectorDestructorsWithVtable) {
   clearOutOldGarbage();
   InlinedVectorObjectWithVtable::s_destructorCalls = 0;
   {
     HeapVector<InlinedVectorObjectWithVtable> vector;
     InlinedVectorObjectWithVtable i1, i2;
-    vector.append(i1);
-    vector.append(i2);
+    vector.push_back(i1);
+    vector.push_back(i2);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(4, InlinedVectorObjectWithVtable::s_destructorCalls);
 
   InlinedVectorObjectWithVtable::s_destructorCalls = 0;
   {
     HeapVector<InlinedVectorObjectWithVtable, 1> vector;
     InlinedVectorObjectWithVtable i1, i2;
-    vector.append(i1);
-    vector.append(i2);  // This allocates an out-of-line buffer.
+    vector.push_back(i1);
+    vector.push_back(i2);  // This allocates an out-of-line buffer.
   }
   preciselyCollectGarbage();
   EXPECT_EQ(5, InlinedVectorObjectWithVtable::s_destructorCalls);
 
   InlinedVectorObjectWithVtable::s_destructorCalls = 0;
   {
     HeapVector<InlinedVectorObjectWithVtable, 2> vector;
     InlinedVectorObjectWithVtable i1, i2;
-    vector.append(i1);
-    vector.append(i2);
+    vector.push_back(i1);
+    vector.push_back(i2);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(4, InlinedVectorObjectWithVtable::s_destructorCalls);
 
   InlinedVectorObjectWithVtable::s_destructorCalls = 0;
   {
     Persistent<InlinedVectorObjectWithVtableWrapper> vectorWrapper =
         new InlinedVectorObjectWithVtableWrapper();
     conservativelyCollectGarbage();
     EXPECT_EQ(3, InlinedVectorObjectWithVtable::s_destructorCalls);
@@ skipping 806 matching lines @@
         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->append(value);
+        keepAlive->push_back(value);
         OuterMap::AddResult newEntry = outer->add(value, InnerMap());
         newEntry.storedValue->value.add(deep, home);
         newEntry.storedValue->value.add(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)
@@ skipping 642 matching lines @@
         TraceIfNeededTester<Member<SimpleObject>>::create(
             Member<SimpleObject>(SimpleObject::create()));
     visitor.reset();
     m_obj->trace(&visitor);
     EXPECT_EQ(1u, visitor.count());
   }
 
   {
     TraceIfNeededTester<HeapVector<Member<SimpleObject>>>* m_vec =
         TraceIfNeededTester<HeapVector<Member<SimpleObject>>>::create();
-    m_vec->obj().append(SimpleObject::create());
+    m_vec->obj().push_back(SimpleObject::create());
     visitor.reset();
     m_vec->trace(&visitor);
     EXPECT_EQ(2u, visitor.count());
   }
 }
 
 class AllocatesOnAssignment {
  public:
   AllocatesOnAssignment(std::nullptr_t) : m_value(nullptr) {}
   AllocatesOnAssignment(int x) : m_value(new IntWrapper(x)) {}
@@ skipping 385 matching lines @@
     EXPECT_EQ(i + 50, part.value());
     i++;
   }
 }
 
 TEST(HeapTest, HeapVectorPartObjects) {
   HeapVector<PartObjectWithRef> vector1;
   HeapVector<PartObjectWithRef> vector2;
 
   for (int i = 0; i < 10; ++i) {
-    vector1.append(PartObjectWithRef(i));
-    vector2.append(PartObjectWithRef(i));
+    vector1.push_back(PartObjectWithRef(i));
+    vector2.push_back(PartObjectWithRef(i));
   }
 
   vector1.reserveCapacity(150);
   EXPECT_LE(150u, vector1.capacity());
   EXPECT_EQ(10u, vector1.size());
 
   vector2.reserveCapacity(100);
   EXPECT_LE(100u, vector2.capacity());
   EXPECT_EQ(10u, vector2.size());
 
   for (int i = 0; i < 4; ++i) {
-    vector1.append(PartObjectWithRef(10 + i));
-    vector2.append(PartObjectWithRef(10 + i));
-    vector2.append(PartObjectWithRef(10 + i));
+    vector1.push_back(PartObjectWithRef(10 + i));
+    vector2.push_back(PartObjectWithRef(10 + i));
+    vector2.push_back(PartObjectWithRef(10 + i));
   }
 
   // Shrinking heap vector backing stores always succeeds,
   // so these two will not currently exercise the code path
   // where shrinking causes copying into a new, small buffer.
   vector2.shrinkToReasonableCapacity();
   EXPECT_EQ(18u, vector2.size());
 
   vector1.shrinkToReasonableCapacity();
   EXPECT_EQ(14u, vector1.size());
@@ skipping 236 matching lines @@
   void checkUnused() { checkUnusedSlots(end(), end() + (capacity() - size())); }
 };
 
 TEST(HeapTest, TestPersistentHeapVectorWithUnusedSlots) {
   TestPersistentHeapVectorWithUnusedSlots vector1;
   TestPersistentHeapVectorWithUnusedSlots vector2(vector1);
 
   vector1.checkUnused();
   vector2.checkUnused();
 
-  vector2.append(VectorObject());
+  vector2.push_back(VectorObject());
   vector2.checkUnused();
 
   EXPECT_EQ(0u, vector1.size());
 
   EXPECT_EQ(1u, vector2.size());
 // TODO(Oilpan): when Vector.h's contiguous container support no longer disables
 // Vector<>s with inline capacity, remove.
 #if !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
   EXPECT_EQ(16u, vector1.capacity());
   EXPECT_EQ(16u, vector2.capacity());
 #endif
 }
 
 TEST(HeapTest, TestStaticLocals) {
   // Sanity check DEFINE_STATIC_LOCAL()s over heap allocated objects and
   // collections.
 
   DEFINE_STATIC_LOCAL(IntWrapper, intWrapper, (new IntWrapper(33)));
   DEFINE_STATIC_LOCAL(PersistentHeapVector<Member<IntWrapper>>,
                       persistentHeapVectorIntWrapper, ());
   DEFINE_STATIC_LOCAL(HeapVector<Member<IntWrapper>>, heapVectorIntWrapper,
                       (new HeapVector<Member<IntWrapper>>));
 
   EXPECT_EQ(33, intWrapper.value());
   EXPECT_EQ(0u, persistentHeapVectorIntWrapper.size());
   EXPECT_EQ(0u, heapVectorIntWrapper.size());
 
-  persistentHeapVectorIntWrapper.append(&intWrapper);
-  heapVectorIntWrapper.append(&intWrapper);
+  persistentHeapVectorIntWrapper.push_back(&intWrapper);
+  heapVectorIntWrapper.push_back(&intWrapper);
   EXPECT_EQ(1u, persistentHeapVectorIntWrapper.size());
   EXPECT_EQ(1u, heapVectorIntWrapper.size());
 
   EXPECT_EQ(persistentHeapVectorIntWrapper[0], heapVectorIntWrapper[0]);
   EXPECT_EQ(33, heapVectorIntWrapper[0]->value());
 }
 
 namespace {
 
 class ThreadedClearOnShutdownTester : public ThreadedTesterBase {
@@ skipping 182 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink