WTF/std normalization: replace WTF::Vector::first() with ::front()

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 146 matching lines @@
 
 typedef WTF::Vector<std::unique_ptr<DestructCounter>> OwnPtrVector;
 
 TEST(VectorTest, OwnPtr) {
   int destructNumber = 0;
   OwnPtrVector vector;
   vector.append(wrapUnique(new DestructCounter(0, &destructNumber)));
   vector.append(wrapUnique(new DestructCounter(1, &destructNumber)));
   EXPECT_EQ(2u, vector.size());
 
-  std::unique_ptr<DestructCounter>& counter0 = vector.first();
+  std::unique_ptr<DestructCounter>& counter0 = vector.front();
   ASSERT_EQ(0, counter0->get());
   int counter1 = vector.back()->get();
   ASSERT_EQ(1, counter1);
   ASSERT_EQ(0, destructNumber);
 
   size_t index = 0;
   for (OwnPtrVector::iterator iter = vector.begin(); iter != vector.end();
        ++iter) {
     std::unique_ptr<DestructCounter>* refCounter = iter;
     EXPECT_EQ(index, static_cast<size_t>(refCounter->get()->get()));
@@ skipping 63 matching lines @@
   WTF_MAKE_NONCOPYABLE(MoveOnly);
   int m_i;
 };
 
 TEST(VectorTest, MoveOnlyType) {
   WTF::Vector<MoveOnly> vector;
   vector.append(MoveOnly(1));
   vector.append(MoveOnly(2));
   EXPECT_EQ(2u, vector.size());
 
-  ASSERT_EQ(1, vector.first().value());
+  ASSERT_EQ(1, vector.front().value());
   ASSERT_EQ(2, vector.back().value());
 
   vector.remove(0);
   EXPECT_EQ(2, vector[0].value());
   EXPECT_EQ(1u, vector.size());
 
   MoveOnly moveOnly(std::move(vector[0]));
   vector.remove(0);
   ASSERT_EQ(2, moveOnly.value());
   ASSERT_EQ(0u, vector.size());
@@ skipping 160 matching lines @@
   compare<WTF::String>();
 }
 
 TEST(VectorTest, AppendFirst) {
   Vector<WTF::String> vector;
   vector.append("string");
   // Test passes if it does not crash (reallocation did not make
   // the input reference stale).
   size_t limit = vector.capacity() + 1;
   for (size_t i = 0; i < limit; i++)
-    vector.append(vector.first());
+    vector.append(vector.front());
 
   limit = vector.capacity() + 1;
   for (size_t i = 0; i < limit; i++)
-    vector.append(const_cast<const WTF::String&>(vector.first()));
+    vector.append(const_cast<const WTF::String&>(vector.front()));
 }
 
 // The test below is for the following issue:
 //
 // https://bugs.chromium.org/p/chromium/issues/detail?id=592767
 //
 // where deleted copy assignment operator made canMoveWithMemcpy true because
 // of the implementation of IsTriviallyMoveAssignable<T>.
 
 class MojoMoveOnlyType final {
@@ skipping 252 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