Migrate WTF::Vector::remove() to ::erase()

third_party/WebKit/Source/wtf/VectorTest.cpp

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 61 matching lines @@
   intVector.push_back(1);
   intVector.push_back(2);
   intVector.push_back(3);
 
   EXPECT_EQ(4u, intVector.size());
   EXPECT_EQ(0, intVector[0]);
   EXPECT_EQ(1, intVector[1]);
   EXPECT_EQ(2, intVector[2]);
   EXPECT_EQ(3, intVector[3]);
 
-  intVector.remove(2, 0);
+  intVector.erase(2, 0);
   EXPECT_EQ(4u, intVector.size());
   EXPECT_EQ(2, intVector[2]);
 
-  intVector.remove(2, 1);
+  intVector.erase(2, 1);
   EXPECT_EQ(3u, intVector.size());
   EXPECT_EQ(3, intVector[2]);
 
-  intVector.remove(0, 0);
+  intVector.erase(0, 0);
   EXPECT_EQ(3u, intVector.size());
   EXPECT_EQ(0, intVector[0]);
 
-  intVector.remove(0);
+  intVector.erase(0);
   EXPECT_EQ(2u, intVector.size());
   EXPECT_EQ(1, intVector[0]);
 }
 
 TEST(VectorTest, Iterator) {
   Vector<int> intVector;
   intVector.push_back(10);
   intVector.push_back(11);
   intVector.push_back(12);
   intVector.push_back(13);
@@ skipping 76 matching lines @@
   EXPECT_EQ(0, destructNumber);
 
   for (index = 0; index < vector.size(); index++) {
     std::unique_ptr<DestructCounter>& refCounter = vector[index];
     EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
   }
   EXPECT_EQ(0, destructNumber);
 
   EXPECT_EQ(0, vector[0]->get());
   EXPECT_EQ(1, vector[1]->get());
-  vector.remove(0);
+  vector.erase(0);
   EXPECT_EQ(1, vector[0]->get());
   EXPECT_EQ(1u, vector.size());
   EXPECT_EQ(1, destructNumber);
 
   std::unique_ptr<DestructCounter> ownCounter1 = std::move(vector[0]);
-  vector.remove(0);
+  vector.erase(0);
   ASSERT_EQ(counter1, ownCounter1->get());
   ASSERT_EQ(0u, vector.size());
   ASSERT_EQ(1, destructNumber);
 
   ownCounter1.reset();
   EXPECT_EQ(2, destructNumber);
 
   size_t count = 1025;
   destructNumber = 0;
   for (size_t i = 0; i < count; i++)
@@ skipping 36 matching lines @@
 
 TEST(VectorTest, MoveOnlyType) {
   WTF::Vector<MoveOnly> vector;
   vector.push_back(MoveOnly(1));
   vector.push_back(MoveOnly(2));
   EXPECT_EQ(2u, vector.size());
 
   ASSERT_EQ(1, vector.front().value());
   ASSERT_EQ(2, vector.back().value());
 
-  vector.remove(0);
+  vector.erase(0);
   EXPECT_EQ(2, vector[0].value());
   EXPECT_EQ(1u, vector.size());
 
   MoveOnly moveOnly(std::move(vector[0]));
-  vector.remove(0);
+  vector.erase(0);
   ASSERT_EQ(2, moveOnly.value());
   ASSERT_EQ(0u, vector.size());
 
   size_t count = vector.capacity() + 1;
   for (size_t i = 0; i < count; i++)
     vector.push_back(
         MoveOnly(i + 1));  // +1 to distinguish from default-constructed.
 
   // Reallocation did not affect the vector's content.
   EXPECT_EQ(count, vector.size());
@@ skipping 245 matching lines @@
       unsigned size2 = vector2.size();
 
       for (unsigned k = 0; k < 5; k++) {
         vector.swap(vector2);
         std::swap(size, size2);
         EXPECT_EQ(i + j, LivenessCounter::s_live);
         EXPECT_EQ(size, vector.size());
         EXPECT_EQ(size2, vector2.size());
 
         vector2.push_back(&counter);
-        vector2.remove(0);
+        vector2.erase(0);
       }
     }
   }
 }
 
 TEST(VectorTest, SwapWithConstructorsAndDestructors) {
   testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity<0>();
   testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity<2>();
   testDestructorAndConstructorCallsWhenSwappingWithInlineCapacity<10>();
 }
@@ skipping 41 matching lines @@
   EXPECT_EQ(0, *vector[0]);
   EXPECT_EQ(1, *vector[1]);
   EXPECT_EQ(2, *vector[2]);
   EXPECT_EQ(3, *vector[3]);
 
   vector.shrink(3);
   EXPECT_EQ(3u, vector.size());
   vector.grow(4);
   ASSERT_EQ(4u, vector.size());
   EXPECT_TRUE(!vector[3]);
-  vector.remove(3);
+  vector.erase(3);
   vector[0] = Pointer(new int(-1));
   ASSERT_EQ(3u, vector.size());
   EXPECT_EQ(-1, *vector[0]);
 }
 
 bool isOneTwoThree(const Vector<int>& vector) {
   return vector.size() == 3 && vector[0] == 1 && vector[1] == 2 &&
          vector[2] == 3;
 }
 
@@ skipping 118 matching lines @@
 static_assert(VectorTraits<UChar>::canCopyWithMemcpy,
               "UChar should be copied with memcpy.");
 
 class UnknownType;
 static_assert(VectorTraits<UnknownType*>::canCopyWithMemcpy,
               "Pointers should be copied with memcpy.");
 
 }  // anonymous namespace
 
 }  // namespace WTF