Migrate WTF::LinkedHashSet/ListHashSet::add() to ::insert()

third_party/WebKit/Source/wtf/LinkedHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * 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.
  *
@@ skipping 239 matching lines @@
   // An alternate version of find() that finds the object by hashing and
   // comparing with some other type, to avoid the cost of type conversion.
   // The HashTranslator interface is defined in HashSet.
   template <typename HashTranslator, typename T>
   iterator find(const T&);
   template <typename HashTranslator, typename T>
   const_iterator find(const T&) const;
   template <typename HashTranslator, typename T>
   bool contains(const T&) const;
 
-  // The return value of add is a pair of a pointer to the stored value,
+  // The return value of insert is a pair of a pointer to the stored value,
   // and a bool that is true if an new entry was added.
   template <typename IncomingValueType>
-  AddResult add(IncomingValueType&&);
-  template <typename IncomingValueType>
   AddResult insert(IncomingValueType&&);
 
-  // Same as add() except that the return value is an
+  // Same as insert() except that the return value is an
   // iterator. Useful in cases where it's needed to have the
   // same return value as find() and where it's not possible to
   // use a pointer to the storedValue.
   template <typename IncomingValueType>
   iterator addReturnIterator(IncomingValueType&&);
 
   // Add the value to the end of the collection. If the value was already in
   // the list, it is moved to the end.
   template <typename IncomingValueType>
   AddResult appendOrMoveToLast(IncomingValueType&&);
@@ skipping 380 matching lines @@
           !IsPointerToGarbageCollectedType<T>::value,
       "Cannot put raw pointers to garbage-collected classes into "
       "an off-heap LinkedHashSet. Use HeapLinkedHashSet<Member<T>> instead.");
 }
 
 template <typename T, typename U, typename V, typename W>
 inline LinkedHashSet<T, U, V, W>::LinkedHashSet(const LinkedHashSet& other)
     : m_anchor() {
   const_iterator end = other.end();
   for (const_iterator it = other.begin(); it != end; ++it)
-    add(*it);
+    insert(*it);
 }
 
 template <typename T, typename U, typename V, typename W>
 inline LinkedHashSet<T, U, V, W>::LinkedHashSet(LinkedHashSet&& other)
     : m_anchor() {
   swap(other);
 }
 
 template <typename T, typename U, typename V, typename W>
 inline LinkedHashSet<T, U, V, W>& LinkedHashSet<T, U, V, W>::operator=(
@@ skipping 128 matching lines @@
 inline bool LinkedHashSet<T, U, V, W>::contains(ValuePeekInType value) const {
   return m_impl.template contains<NodeHashFunctions>(value);
 }
 
 template <typename Value,
           typename HashFunctions,
           typename Traits,
           typename Allocator>
 template <typename IncomingValueType>
 typename LinkedHashSet<Value, HashFunctions, Traits, Allocator>::AddResult
-LinkedHashSet<Value, HashFunctions, Traits, Allocator>::add(
+LinkedHashSet<Value, HashFunctions, Traits, Allocator>::insert(
     IncomingValueType&& value) {
   return m_impl.template add<NodeHashFunctions>(
       std::forward<IncomingValueType>(value), &m_anchor);
 }
 
-template <typename Value,
-          typename HashFunctions,
-          typename Traits,
-          typename Allocator>
-template <typename IncomingValueType>
-typename LinkedHashSet<Value, HashFunctions, Traits, Allocator>::AddResult
-LinkedHashSet<Value, HashFunctions, Traits, Allocator>::insert(
-    IncomingValueType&& value) {
-  return add(value);
-}
-
 template <typename T, typename U, typename V, typename W>
 template <typename IncomingValueType>
 typename LinkedHashSet<T, U, V, W>::iterator
 LinkedHashSet<T, U, V, W>::addReturnIterator(IncomingValueType&& value) {
   typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(
       std::forward<IncomingValueType>(value), &m_anchor);
   return makeIterator(result.storedValue);
 }
 
 template <typename T, typename U, typename V, typename W>
@@ skipping 98 matching lines @@
   swap(static_cast<Base&>(a), static_cast<Base&>(b));
   swap(a.m_value, b.m_value);
   Allocator::leaveGCForbiddenScope();
 }
 
 }  // namespace WTF
 
 using WTF::LinkedHashSet;
 
 #endif /* WTF_LinkedHashSet_h */