Migrate WTF::Deque::append() to ::push_back()

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 2408 matching lines @@
       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);
       vector->push_back(oneB);
-      deque->append(oneB);
+      deque->push_back(oneB);
       vector2->push_back(threeB);
       vector2->push_back(fourB);
-      deque2->append(threeE);
-      deque2->append(fourE);
+      deque2->push_back(threeE);
+      deque2->push_back(fourE);
       vectorWU->push_back(PairWrappedUnwrapped(&*oneC, 42));
-      dequeWU->append(PairWrappedUnwrapped(&*oneE, 42));
+      dequeWU->push_back(PairWrappedUnwrapped(&*oneE, 42));
       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));
+      dequeWU2->push_back(PairWrappedUnwrapped(&*threeE, 43));
+      dequeWU2->push_back(PairWrappedUnwrapped(&*fourE, 44));
+      dequeWU2->push_back(PairWrappedUnwrapped(&*fiveE, 45));
       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));
+      dequeUW->push_back(PairUnwrappedWrapped(1, &*oneF));
+      dequeUW2->push_back(PairUnwrappedWrapped(103, &*threeF));
+      dequeUW2->push_back(PairUnwrappedWrapped(104, &*fourF));
+      dequeUW2->push_back(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();
 
       EXPECT_TRUE(dequeContains(*deque, oneB));
 
       EXPECT_EQ(0u, memberMember->size());
@@ skipping 405 matching lines @@
     EXPECT_TRUE(set2.contains(one2));
   }
 }
 
 class NonTrivialObject final {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   NonTrivialObject() {}
   explicit NonTrivialObject(int num) {
-    m_deque.append(IntWrapper::create(num));
+    m_deque.push_back(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 961 matching lines @@
     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.push_back(one);
     pVec.push_back(two);
 
-    pDeque.append(seven);
-    pDeque.append(two);
+    pDeque.push_back(seven);
+    pDeque.push_back(two);
 
     Vec* vec = new Vec();
     vec->swap(pVec);
 
     pVec.push_back(two);
     pVec.push_back(three);
 
     pSet.insert(four);
     pListSet.insert(eight);
     pLinkedSet.insert(nine);
@@ skipping 58 matching lines @@
 
   HeapHashMap<void*, IntVector>::iterator it = map->find(key);
   EXPECT_EQ(0u, map->at(key).size());
 
   HeapHashMap<void*, IntDeque>::iterator it2 = map2->find(key);
   EXPECT_EQ(0u, map2->at(key).size());
 
   it->value.push_back(IntWrapper::create(42));
   EXPECT_EQ(1u, map->at(key).size());
 
-  it2->value.append(IntWrapper::create(42));
+  it2->value.push_back(IntWrapper::create(42));
   EXPECT_EQ(1u, map2->at(key).size());
 
   Persistent<HeapHashMap<void*, IntVector>> keepAlive(map);
   Persistent<HeapHashMap<void*, IntDeque>> keepAlive2(map2);
 
   for (int i = 0; i < 100; i++) {
     map->insert(key + 1 + i, IntVector());
     map2->insert(key + 1 + i, IntDeque());
   }
 
@@ skipping 50 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->push_back(IntVector());
-  deque->append(IntDeque());
+  deque->push_back(IntDeque());
 
   HeapVector<IntVector>::iterator it = vector->begin();
   HeapDeque<IntDeque>::iterator it2 = deque->begin();
   EXPECT_EQ(0u, it->size());
   EXPECT_EQ(0u, it2->size());
 
   it->push_back(IntWrapper::create(42));
-  it2->append(IntWrapper::create(42));
+  it2->push_back(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);
 }
@@ skipping 24 matching lines @@
   EXPECT_EQ(6, SimpleFinalizedObject::s_destructorCalls);
 }
 
 TEST(HeapTest, EmbeddedInDeque) {
   clearOutOldGarbage();
   SimpleFinalizedObject::s_destructorCalls = 0;
   {
     PersistentHeapDeque<VectorObject, 2> inlineDeque;
     PersistentHeapDeque<VectorObject> outlineDeque;
     VectorObject i1, i2;
-    inlineDeque.append(i1);
-    inlineDeque.append(i2);
+    inlineDeque.push_back(i1);
+    inlineDeque.push_back(i2);
 
     VectorObject o1, o2;
-    outlineDeque.append(o1);
-    outlineDeque.append(o2);
+    outlineDeque.push_back(o1);
+    outlineDeque.push_back(o2);
 
     PersistentHeapDeque<VectorObjectInheritedTrace> dequeInheritedTrace;
     VectorObjectInheritedTrace it1, it2;
-    dequeInheritedTrace.append(it1);
-    dequeInheritedTrace.append(it2);
+    dequeInheritedTrace.push_back(it1);
+    dequeInheritedTrace.push_back(it2);
 
     preciselyCollectGarbage();
     EXPECT_EQ(0, SimpleFinalizedObject::s_destructorCalls);
   }
   preciselyCollectGarbage();
   EXPECT_EQ(6, SimpleFinalizedObject::s_destructorCalls);
 }
 
 class InlinedVectorObject {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
@@ skipping 1622 matching lines @@
   // Test expansion of a HeapDeque<>'s buffer.
 
   typedef HeapDeque<Member<IntWrapper>> IntDeque;
 
   Persistent<IntDeque> deque = new IntDeque();
 
   // Append a sequence, bringing about repeated expansions of the
   // deque's buffer.
   int i = 0;
   for (; i < 60; ++i)
-    deque->append(IntWrapper::create(i));
+    deque->push_back(IntWrapper::create(i));
 
   EXPECT_EQ(60u, deque->size());
   i = 0;
   for (const auto& intWrapper : *deque) {
     EXPECT_EQ(i, intWrapper->value());
     i++;
   }
 
   // Remove most of the queued objects and have the buffer's start index
   // 'point' somewhere into the buffer, just behind the end index.
   for (i = 0; i < 50; ++i)
     deque->takeFirst();
 
   EXPECT_EQ(10u, deque->size());
   i = 0;
   for (const auto& intWrapper : *deque) {
     EXPECT_EQ(50 + i, intWrapper->value());
     i++;
   }
 
   // Append even more, eventually causing an expansion of the underlying
   // buffer once the end index wraps around and reaches the start index.
   for (i = 0; i < 70; ++i)
-    deque->append(IntWrapper::create(60 + i));
+    deque->push_back(IntWrapper::create(60 + i));
 
   // Verify that the final buffer expansion copied the start and end segments
   // of the old buffer to both ends of the expanded buffer, along with
   // re-adjusting both start&end indices in terms of that expanded buffer.
   EXPECT_EQ(80u, deque->size());
   i = 0;
   for (const auto& intWrapper : *deque) {
     EXPECT_EQ(i + 50, intWrapper->value());
     i++;
   }
@@ skipping 39 matching lines @@
   using PartDeque = HeapDeque<PartObjectWithRef>;
 
   Persistent<PartDeque> deque = new PartDeque();
   // Auxillary Deque used to prevent 'inline' buffer expansion.
   Persistent<PartDeque> dequeUnused = new PartDeque();
 
   // Append a sequence, bringing about repeated expansions of the
   // deque's buffer.
   int i = 0;
   for (; i < 60; ++i) {
-    deque->append(PartObjectWithRef(i));
-    dequeUnused->append(PartObjectWithRef(i));
+    deque->push_back(PartObjectWithRef(i));
+    dequeUnused->push_back(PartObjectWithRef(i));
   }
 
   EXPECT_EQ(60u, deque->size());
   i = 0;
   for (const PartObjectWithRef& part : *deque) {
     EXPECT_EQ(i, part.value());
     i++;
   }
 
   // Remove most of the queued objects and have the buffer's start index
   // 'point' somewhere into the buffer, just behind the end index.
   for (i = 0; i < 50; ++i)
     deque->takeFirst();
 
   EXPECT_EQ(10u, deque->size());
   i = 0;
   for (const PartObjectWithRef& part : *deque) {
     EXPECT_EQ(50 + i, part.value());
     i++;
   }
 
   // Append even more, eventually causing an expansion of the underlying
   // buffer once the end index wraps around and reaches the start index.
   for (i = 0; i < 70; ++i)
-    deque->append(PartObjectWithRef(60 + i));
+    deque->push_back(PartObjectWithRef(60 + i));
 
   // Verify that the final buffer expansion copied the start and end segments
   // of the old buffer to both ends of the expanded buffer, along with
   // re-adjusting both start&end indices in terms of that expanded buffer.
   EXPECT_EQ(80u, deque->size());
   i = 0;
   for (const PartObjectWithRef& part : *deque) {
     EXPECT_EQ(i + 50, part.value());
     i++;
   }
 
   for (i = 0; i < 70; ++i)
-    deque->append(PartObjectWithRef(130 + i));
+    deque->push_back(PartObjectWithRef(130 + i));
 
   EXPECT_EQ(150u, deque->size());
   i = 0;
   for (const PartObjectWithRef& part : *deque) {
     EXPECT_EQ(i + 50, part.value());
     i++;
   }
 }
 
 TEST(HeapTest, HeapVectorPartObjects) {
@@ skipping 497 matching lines @@
       "HeapVector");
   static_assert(
       WTF::IsGarbageCollectedType<HeapDeque<Member<IntWrapper>>>::value,
       "HeapDeque");
   static_assert(WTF::IsGarbageCollectedType<
                     HeapTerminatedArray<Member<IntWrapper>>>::value,
                 "HeapTerminatedArray");
 }
 
 }  // namespace blink