WTF/std normalization: replace WTF::Vector::emplaceAppend with ::emplace_back

third_party/WebKit/Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 928 matching lines @@
       shrinkCapacity(size() + size() / 4 + 1);
   }
 
   void clear() { shrinkCapacity(0); }
 
   template <typename U>
   void append(const U*, size_t);
   template <typename U>
   void append(U&&);
   template <typename... Args>
-  void emplaceAppend(Args&&...);
+  T& emplace_back(Args&&...);
   template <typename U>
   void uncheckedAppend(U&& val);
   template <typename U, size_t otherCapacity, typename V>
   void appendVector(const Vector<U, otherCapacity, V>&);
 
   template <typename U>
   void insert(size_t position, const U*, size_t);
   template <typename U>
   void insert(size_t position, U&&);
   template <typename U, size_t c, typename V>
@@ skipping 429 matching lines @@
     new (NotNull, end()) T(std::forward<U>(val));
     ++m_size;
     return;
   }
 
   appendSlowCase(std::forward<U>(val));
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename... Args>
-ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::emplaceAppend(
+ALWAYS_INLINE T& Vector<T, inlineCapacity, Allocator>::emplace_back(
     Args&&... args) {
   static_assert(sizeof...(Args), "grow() must be called instead");
   static_assert(sizeof...(Args) != 1, "append() must be called instead");
 
   DCHECK(Allocator::isAllocationAllowed());
   if (UNLIKELY(size() == capacity()))
     expandCapacity(size() + 1);
 
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
-  new (NotNull, end()) T(std::forward<Args>(args)...);
+  T* t = new (NotNull, end()) T(std::forward<Args>(args)...);
   ++m_size;
+  return *t;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 NEVER_INLINE void Vector<T, inlineCapacity, Allocator>::appendSlowCase(
     U&& val) {
   ASSERT(size() == capacity());
 
   typename std::remove_reference<U>::type* ptr = &val;
   ptr = expandCapacity(size() + 1, ptr);
@@ skipping 183 matching lines @@
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h