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 (Allocator::isGarbageCollected)
+                return;
             if (LIKELY(!m_table))
                 return;
             deallocateTable(m_table, m_tableSize);
             m_table = 0;
         }
 
         HashTable(const HashTable&);
         void swap(HashTable&);
         HashTable& operator=(const HashTable&);
 
@@ skipping 587 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 (Allocator::isGarbageCollected)
+            return;
         if (Traits::needsDestruction) {
             for (unsigned i = 0; i < size; ++i) {
                 if (!isDeletedBucket(table[i]))
                     table[i].~ValueType();
             }
         }
         Allocator::backingFree(table);
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
@@ skipping 264 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