Shrink weak hash tables when adding elements, if needed.

third_party/WebKit/Source/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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 837 matching lines @@
         initializeBucket(*deletedEntry);
         entry = deletedEntry;
         --m_deletedCount;
     }
 
     HashTranslator::translate(*entry, std::forward<T>(key), std::forward<Extra>(extra));
     ASSERT(!isEmptyOrDeletedBucket(*entry));
 
     ++m_keyCount;
 
-    if (shouldExpand())
+    if (shouldExpand()) {
         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
+        // 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);
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, 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)
 {
     ASSERT(!m_accessForbidden);
     ASSERT(Allocator::isAllocationAllowed());
@@ skipping 650 matching lines @@
     CollectionIterator end(toBeRemoved.end());
     for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
         collection.remove(*it);
 }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h