Allow WTF::Vector::emplace_back accept one or zero arguments

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 1095 matching lines @@
   //     iterators (for appendRange) to the back. The elements will be copied.
   // uncheckedAppend(value)
   //     Insert a single element like push_back(), but this function assumes
   //     the vector has enough capacity such that it can store the new element
   //     without a reallocation. Using this function could improve the
   //     performance when you append many elements repeatedly.
   template <typename U>
   void push_back(U&&);
   template <typename... Args>
   T& emplace_back(Args&&...);
+  ALWAYS_INLINE T& emplace_back() {
+    grow(m_size + 1);
+    return back();
+  }
   template <typename U>
   void append(const U*, size_t);
   template <typename U, size_t otherCapacity, typename V>
   void appendVector(const Vector<U, otherCapacity, V>&);
   template <typename Iterator>
   void appendRange(Iterator begin, Iterator end);
   template <typename U>
   void uncheckedAppend(U&&);
 
   // Insertion to an arbitrary position. All of these functions will take
@@ skipping 534 matching lines @@
     return;
   }
 
   appendSlowCase(std::forward<U>(val));
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename... Args>
 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);
   T* t = new (NotNull, end()) T(std::forward<Args>(args)...);
   ++m_size;
   return *t;
 }
 
@@ skipping 217 matching lines @@
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h