Ensure proper finalization of garbage-collected types.

Source/wtf/HashTable.h

Index: Source/wtf/HashTable.h
diff --git a/Source/wtf/HashTable.h b/Source/wtf/HashTable.h
index 30c8bbd5ef55f94a0169bbea561c132d835d5fcd..7fa35151df60091b9e2ffa8b3781006e83727c71 100644
--- a/Source/wtf/HashTable.h
+++ b/Source/wtf/HashTable.h
@@ -218,8 +218,21 @@ namespace WTF {
         static bool isEmptyOrDeletedBucket(const Value& value) { return isEmptyBucket(value) || isDeletedBucket(value); }
     };
 
+    // Don't declare a destructor for HeapAllocated hash tables.
+    template<typename Derived, bool isGarbageCollected>
+    class HashTableDestructorBase;
+
+    template<typename Derived>
+    class HashTableDestructorBase<Derived, true> { };
+
+    template<typename Derived>
+    class HashTableDestructorBase<Derived, false> {
+    public:
+        ~HashTableDestructorBase() { static_cast<Derived*>(this)->finalize(); }
+    };
+
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
-    class HashTable {
+    class HashTable : public HashTableDestructorBase<HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>, Allocator::isGarbageCollected> {

[Mikhail, 2014/03/11 09:58:13]

imho this inheritance looks a bit over-complicated, maybe we could follow the
"VectorDestructor" approach, and have for instance:
~HashTable()
{
HashTableDestructor<Allocator::isGarbageCollected>::destruct(m_table,
m_tableSize);
}

[zerny-chromium, 2014/03/11 10:04:48]

The issue with doing so is that then HashTable will have a non-trivial
destructor (because it is user-declared) and thus we can not in the clang
compiler plugin use its semantic knowledge of when a class has a trivial
finalizer to determine when a non-finalized garbage collected base class is
correct.

So while I agree that your proposed code is much nicer, it does not solve the
same issue.

[Mikhail, 2014/03/11 12:02:53]

Ah I see, thanks for the explanation.

     public:
         typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> iterator;
         typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> const_iterator;
@@ -278,10 +291,9 @@ namespace WTF {
 #endif
 
         HashTable();
-        ~HashTable()
+        void finalize()
         {
-            if (Allocator::isGarbageCollected)
-                return;
+            ASSERT(!Allocator::isGarbageCollected);
             if (LIKELY(!m_table))
                 return;
             deallocateTable(m_table, m_tableSize);