Migrate WTF::HashTable::remove() to ::erase()

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 739 matching lines @@
     return contains<IdentityTranslatorType>(key);
   }
 
   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;
 
-  void remove(KeyPeekInType);
-  void remove(iterator);
-  void remove(const_iterator);
+  void erase(KeyPeekInType);
+  void erase(iterator);
+  void erase(const_iterator);
   void clear();
 
   static bool isEmptyBucket(const ValueType& value) {
     return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value));
   }
   static bool isDeletedBucket(const ValueType& value) {
     return KeyTraits::isDeletedValue(Extractor::extract(value));
   }
   static bool isEmptyOrDeletedBucket(const ValueType& value) {
     return HashTableHelper<ValueType, Extractor,
@@ skipping 43 matching lines @@
   typedef std::pair<LookupType, unsigned> FullLookupType;
 
   LookupType lookupForWriting(const Key& key) {
     return lookupForWriting<IdentityTranslatorType>(key);
   }
   template <typename HashTranslator, typename T>
   FullLookupType fullLookupForWriting(const T&);
   template <typename HashTranslator, typename T>
   LookupType lookupForWriting(const T&);
 
-  void remove(ValueType*);
+  void erase(ValueType*);
 
   bool shouldExpand() const {
     return (m_keyCount + m_deletedCount) * m_maxLoad >= m_tableSize;
   }
   bool mustRehashInPlace() const {
     return m_keyCount * m_minLoad < m_tableSize * 2;
   }
   bool shouldShrink() const {
     // isAllocationAllowed check should be at the last because it's
     // expensive.
@@ skipping 454 matching lines @@
     entry = expand(entry);
   } else if (Traits::weakHandlingFlag == WeakHandlingInCollections &&
              shouldShrink()) {
     // When weak hash tables are processed by the garbage collector,
     // elements with no other strong references to them will have their
     // table entries cleared. But no shrinking of the backing store is
     // allowed at that time, as allocations are prohibited during that
     // GC phase.
     //
     // With that weak processing taking care of removals, explicit
-    // remove()s of elements is rarely done. Which implies that the
+    // erase()s of elements is rarely done. Which implies that the
     // weak hash table will never be checked if it can be shrunk.
     //
     // To prevent weak hash tables with very low load factors from
     // developing, we perform it when adding elements instead.
     entry = rehash(m_tableSize / 2, entry);
   }
 
   return AddResult(this, entry, true);
 }
 
@@ skipping 147 matching lines @@
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 void HashTable<Key,
                Value,
                Extractor,
                HashFunctions,
                Traits,
                KeyTraits,
-               Allocator>::remove(ValueType* pos) {
+               Allocator>::erase(ValueType* pos) {
   registerModification();
 #if DUMP_HASHTABLE_STATS
   atomicIncrement(&HashTableStats::instance().numRemoves);
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   ++m_stats->numRemoves;
 #endif
 
   enterAccessForbiddenScope();
   deleteBucket(*pos);
   leaveAccessForbiddenScope();
   ++m_deletedCount;
   --m_keyCount;
 
   if (shouldShrink())
     shrink();
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 inline void
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
-    remove(iterator it) {
+    erase(iterator it) {
   if (it == end())
     return;
-  remove(const_cast<ValueType*>(it.m_iterator.m_position));
+  erase(const_cast<ValueType*>(it.m_iterator.m_position));
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 inline void
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
-    remove(const_iterator it) {
+    erase(const_iterator it) {
   if (it == end())
     return;
-  remove(const_cast<ValueType*>(it.m_position));
+  erase(const_cast<ValueType*>(it.m_position));
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 inline void
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
-    remove(KeyPeekInType key) {
-  remove(find(key));
+    erase(KeyPeekInType key) {
+  erase(find(key));
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 Value*
@@ skipping 732 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