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

third_party/WebKit/Source/platform/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * 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 711 matching lines @@
     return m_tableSize;
   }
   bool isEmpty() const {
     DCHECK(!accessForbidden());
     return !m_keyCount;
   }
 
   void reserveCapacityForSize(unsigned size);
 
   template <typename IncomingValueType>
-  AddResult add(IncomingValueType&& value) {
-    return add<IdentityTranslatorType>(Extractor::extract(value),
-                                       std::forward<IncomingValueType>(value));
+  AddResult insert(IncomingValueType&& value) {
+    return insert<IdentityTranslatorType>(
+        Extractor::extract(value), std::forward<IncomingValueType>(value));
   }
 
-  // A special version of add() that finds the object by hashing and comparing
-  // with some other type, to avoid the cost of type conversion if the object
-  // is already in the table.
+  // A special version of insert() that finds the object by hashing and
+  // comparing with some other type, to avoid the cost of type conversion if the
+  // object is already in the table.
   template <typename HashTranslator, typename T, typename Extra>
-  AddResult add(T&& key, Extra&&);
+  AddResult insert(T&& key, Extra&&);
   template <typename HashTranslator, typename T, typename Extra>
-  AddResult addPassingHashCode(T&& key, Extra&&);
+  AddResult insertPassingHashCode(T&& key, Extra&&);
 
   iterator find(KeyPeekInType key) { return find<IdentityTranslatorType>(key); }
   const_iterator find(KeyPeekInType key) const {
     return find<IdentityTranslatorType>(key);
   }
   bool contains(KeyPeekInType key) const {
     return contains<IdentityTranslatorType>(key);
   }
 
   template <typename HashTranslator, typename T>
@@ skipping 468 matching lines @@
           typename Allocator>
 template <typename HashTranslator, typename T, typename Extra>
 typename HashTable<Key,
                    Value,
                    Extractor,
                    HashFunctions,
                    Traits,
                    KeyTraits,
                    Allocator>::AddResult
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
-    add(T&& key, Extra&& extra) {
+    insert(T&& key, Extra&& extra) {
   DCHECK(!accessForbidden());
   DCHECK(Allocator::isAllocationAllowed());
   if (!m_table)
     expand();
 
   DCHECK(m_table);
 
   ValueType* table = m_table;
   size_t k = 0;
   size_t sizeMask = tableSizeMask();
@@ skipping 75 matching lines @@
           typename Allocator>
 template <typename HashTranslator, typename T, typename Extra>
 typename HashTable<Key,
                    Value,
                    Extractor,
                    HashFunctions,
                    Traits,
                    KeyTraits,
                    Allocator>::AddResult
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
-    addPassingHashCode(T&& key, Extra&& extra) {
+    insertPassingHashCode(T&& key, Extra&& extra) {
   DCHECK(!accessForbidden());
   DCHECK(Allocator::isAllocationAllowed());
   if (!m_table)
     expand();
 
   FullLookupType lookupResult = fullLookupForWriting<HashTranslator>(key);
 
   ValueType* entry = lookupResult.first.first;
   bool found = lookupResult.first.second;
   unsigned h = lookupResult.second;
@@ skipping 487 matching lines @@
       ,
       m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
 #endif
 {
   if (other.size())
     reserveCapacityForSize(other.size());
   // Copy the hash table the dumb way, by adding each element to the new
   // table.  It might be more efficient to copy the table slots, but it's not
   // clear that efficiency is needed.
   for (const auto& element : other)
-    add(element);
+    insert(element);
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
@@ skipping 424 matching lines @@
   CollectionIterator end(toBeRemoved.end());
   for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
     collection.erase(*it);
 }
 
 }  // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif  // WTF_HashTable_h