Migrate WTF::HashTable::add() to ::insert()

third_party/WebKit/Source/platform/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 266 matching lines @@
   // Add the value to the beginning of the collection. If the value was already
   // in the list, it is moved to the beginning.
   template <typename IncomingValueType>
   AddResult prependOrMoveToFirst(IncomingValueType&&);
 
   template <typename IncomingValueType>
   AddResult insertBefore(ValuePeekInType beforeValue,
                          IncomingValueType&& newValue);
   template <typename IncomingValueType>
   AddResult insertBefore(iterator it, IncomingValueType&& newValue) {
-    return m_impl.template add<NodeHashFunctions>(
+    return m_impl.template insert<NodeHashFunctions>(
         std::forward<IncomingValueType>(newValue), it.getNode());
   }
 
   void erase(ValuePeekInType);
   void erase(iterator);
   void clear() { m_impl.clear(); }
   template <typename Collection>
   void removeAll(const Collection& other) {
     WTF::removeAll(*this, other);
   }
@@ skipping 509 matching lines @@
 }
 
 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 m_impl.template add<NodeHashFunctions>(
+  return m_impl.template insert<NodeHashFunctions>(
       std::forward<IncomingValueType>(value), &m_anchor);
 }
 
 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);
+  typename ImplType::AddResult result =
+      m_impl.template insert<NodeHashFunctions>(
+          std::forward<IncomingValueType>(value), &m_anchor);
   return makeIterator(result.storedValue);
 }
 
 template <typename T, typename U, typename V, typename W>
 template <typename IncomingValueType>
 typename LinkedHashSet<T, U, V, W>::AddResult
 LinkedHashSet<T, U, V, W>::appendOrMoveToLast(IncomingValueType&& value) {
-  typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(
-      std::forward<IncomingValueType>(value), &m_anchor);
+  typename ImplType::AddResult result =
+      m_impl.template insert<NodeHashFunctions>(
+          std::forward<IncomingValueType>(value), &m_anchor);
   Node* node = result.storedValue;
   if (!result.isNewEntry) {
     node->unlink();
     m_anchor.insertBefore(*node);
   }
   return result;
 }
 
 template <typename T, typename U, typename V, typename W>
 template <typename IncomingValueType>
 typename LinkedHashSet<T, U, V, W>::AddResult
 LinkedHashSet<T, U, V, W>::prependOrMoveToFirst(IncomingValueType&& value) {
-  typename ImplType::AddResult result = m_impl.template add<NodeHashFunctions>(
-      std::forward<IncomingValueType>(value), m_anchor.m_next);
+  typename ImplType::AddResult result =
+      m_impl.template insert<NodeHashFunctions>(
+          std::forward<IncomingValueType>(value), m_anchor.m_next);
   Node* node = result.storedValue;
   if (!result.isNewEntry) {
     node->unlink();
     m_anchor.insertAfter(*node);
   }
   return result;
 }
 
 template <typename T, typename U, typename V, typename W>
 template <typename IncomingValueType>
@@ skipping 69 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 */