Don't deallocate the HashTable backing explicitly when it is managed by GC.

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 262 matching lines @@
                 }
                 dataLogF("%d rehashes\n", numRehashes);
                 dataLogF("%d reinserts\n", numReinserts);
             }
         };
 #endif
 
         HashTable();
         ~HashTable()
         {
-            if (LIKELY(!m_table))
-                return;
-            deallocateTable(m_table, m_tableSize);
-            m_table = 0;
+            if (!Allocator::isGarbageCollected) {

[tkent, 2014/03/05 01:12:40]

nit: We prefer early return.

{
    if (Allocator::isGarbageCollected)
        return;
    if (LIKELY(...))

+                if (LIKELY(!m_table))
+                    return;
+                deallocateTable(m_table, m_tableSize);
+                m_table = 0;
+            }
         }
 
         HashTable(const HashTable&);
         void swap(HashTable&);
         HashTable& operator=(const HashTable&);
 
         // When the hash table is empty, just return the same iterator for end as for begin.
         // This is more efficient because we don't have to skip all the empty and deleted
         // buckets, and iterating an empty table is a common case that's worth optimizing.
         iterator begin() { return isEmpty() ? end() : makeIterator(m_table); }
@@ skipping 583 matching lines @@
             result = Allocator::template backingMalloc<ValueType*, HashTableBacking>(allocSize);
             for (unsigned i = 0; i < size; i++)
                 initializeBucket(result[i]);
         }
         return result;
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::deallocateTable(ValueType* table, unsigned size)
     {
-        if (Traits::needsDestruction) {
-            for (unsigned i = 0; i < size; ++i) {
-                if (!isDeletedBucket(table[i]))
-                    table[i].~ValueType();
+        if (!Allocator::isGarbageCollected) {
+            if (Traits::needsDestruction) {
+                for (unsigned i = 0; i < size; ++i) {
+                    if (!isDeletedBucket(table[i]))
+                        table[i].~ValueType();
+                }
             }
+            Allocator::backingFree(table);
         }
-        Allocator::backingFree(table);
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::expand()
     {
         unsigned newSize;
         if (!m_tableSize) {
             newSize = KeyTraits::minimumTableSize;
         } else if (mustRehashInPlace()) {
             newSize = m_tableSize;
@@ skipping 257 matching lines @@
     inline bool operator!=(const HashTableIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
     {
         return a.m_impl != b.m_impl;
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h