Make sure all destructors are called in HeapHashMap and HeapHashSet

Source/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1294 matching lines @@
     // typedef ensures that the allocation is done with the correct templated
     // instantiation of the allocation function. This ensures the correct GC
     // map is written when backing allocations take place.
     template<typename T, typename Traits>
     struct VectorBackingHelper {
         typedef HeapVectorBacking<T, Traits> Type;
     };
 
     // Like the VectorBackingHelper, but this type is used for HashSet and
     // HashMap, both of which are implemented using HashTable.
-    template<typename T, typename U, typename V, typename W, typename X>
+    template<typename Table>
     struct HashTableBackingHelper {
-        typedef HeapHashTableBacking<T, U, V, W, X> Type;
+        typedef HeapHashTableBacking<Table> Type;
     };
 
     template<typename T>
     struct OtherType {
         typedef T* Type;
     };
 
     template<typename T>
     static T& getOther(T* other)
     {
@@ skipping 64 matching lines @@
 struct ThreadingTrait<Member<T> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T>
 struct ThreadingTrait<WeakMember<T> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename Key, typename Value, typename T, typename U, typename V>
-struct ThreadingTrait<HashMap<Key, Value, HeapAllocator, T, U, V> > {
+struct ThreadingTrait<HashMap<Key, Value, T, U, V, HeapAllocator> > {
     static const ThreadAffinity Affinity =
         (ThreadingTrait<Key>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
 template<typename First, typename Second>
 struct ThreadingTrait<WTF::KeyValuePair<First, Second> > {
     static const ThreadAffinity Affinity =
         (ThreadingTrait<First>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Second>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
 template<typename T, typename U, typename V>
-struct ThreadingTrait<HashSet<T, HeapAllocator, U, V> > {
+struct ThreadingTrait<HashSet<T, U, V, HeapAllocator> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename T, typename Traits>
 struct ThreadingTrait<HeapVectorBacking<T, Traits> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
-template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
-struct ThreadingTrait<HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
+template<typename Table>
+struct ThreadingTrait<HeapHashTableBacking<Table> > {
+    typedef typename Table::KeyType Key;
+    typedef typename Table::ValueType Value;
     static const ThreadAffinity Affinity =
         (ThreadingTrait<Key>::Affinity == MainThreadOnly)
         && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
 };
 
-template<typename Key, typename Value>
-struct ThreadingTrait<HeapHashMap<Key, Value> > : public ThreadingTrait<HashMap<Key, Value, HeapAllocator> > { };
-template<typename Value>
-struct ThreadingTrait<HeapHashSet<Value> > : public ThreadingTrait<HashSet<Value, HeapAllocator> > { };
+template<typename T, typename U, typename V, typename W, typename X>
+struct ThreadingTrait<HeapHashMap<T, U, V, W, X> > : public ThreadingTrait<HashMap<T, U, V, W, X, HeapAllocator> > { };
+
+template<typename T, typename U, typename V>
+struct ThreadingTrait<HeapHashSet<T, U, V> > : public ThreadingTrait<HashSet<T, U, V, HeapAllocator> > { };
+
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<HeapVector<T, inlineCapacity> > : public ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
 
 // The standard implementation of GCInfoTrait<T>::get() just returns a static
 // from the class T, but we can't do that for HashMap, HashSet and Vector
 // because they are in WTF and know nothing of GCInfos. Instead we have a
 // specialization of GCInfoTrait for these three classes here.
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 struct GCInfoTrait<HashMap<Key, Value, T, U, V, HeapAllocator> > {
@@ skipping 57 matching lines @@
     static const GCInfo info;
 };
 
 template<typename T, typename Traits>
 const GCInfo GCInfoTrait<HeapVectorBacking<T, Traits> >::info = {
     TraceTrait<HeapVectorBacking<T, Traits> >::trace,
     FinalizerTrait<HeapVectorBacking<T, Traits> >::finalize,
     Traits::needsDestruction,
 };
 
-template<typename T, typename U, typename V, typename W, typename X>
-struct GCInfoTrait<HeapHashTableBacking<T, U, V, W, X> > {
+template<typename Table>
+struct GCInfoTrait<HeapHashTableBacking<Table> > {
     static const GCInfo* get() { return &info; }
     static const GCInfo info;
 };
 
-template<typename T, typename U, typename V, typename Traits, typename W>
-const GCInfo GCInfoTrait<HeapHashTableBacking<T, U, V, Traits, W> >::info = {
-    TraceTrait<HeapHashTableBacking<T, U, V, Traits, W> >::trace,
-    FinalizerTrait<HeapHashTableBacking<T, U, V, Traits, W> >::finalize,
-    Traits::needsDestruction,
+template<typename Table>
+const GCInfo GCInfoTrait<HeapHashTableBacking<Table> >::info = {
+    TraceTrait<HeapHashTableBacking<Table> >::trace,
+    HeapHashTableBacking<Table>::finalize,
+    Table::ValueTraits::needsDestruction,
 };
 
 template<bool markWeakMembersStrongly, typename T, typename Traits>
 struct BaseVisitVectorBackingTrait {
     static void mark(WebCore::Visitor* visitor, void* self)
     {
         // The allocator can oversize the allocation a little, according to
         // the allocation granularity. The extra size is included in the
         // payloadSize call below, since there is nowhere to store the
         // originally allocated memory. This assert ensures that visiting the
         // last bit of memory can't cause trouble.
         COMPILE_ASSERT(!WTF::ShouldBeTraced<Traits>::value || sizeof(T) > allocationGranularity || Traits::canInitializeWithMemset, HeapOverallocationCanCauseSpuriousVisits);
 
         T* array = reinterpret_cast<T*>(self);
         WebCore::FinalizedHeapObjectHeader* header = WebCore::FinalizedHeapObjectHeader::fromPayload(self);
         // Use the payload size as recorded by the heap to determine how many
         // elements to mark.
         size_t length = header->payloadSize() / sizeof(T);
         for (size_t i = 0; i < length; i++)
             CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, markWeakMembersStrongly, T, Traits>::mark(visitor, array[i]);
     }
 };
 
-template<bool markWeakMembersStrongly, typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
+template<bool markWeakMembersStrongly, typename Table>
 struct BaseVisitHashTableBackingTrait {
+    typedef typename Table::ValueType Value;
+    typedef typename Table::ValueTraits Traits;
     static void mark(WebCore::Visitor* visitor, void* self)
     {
         Value* array = reinterpret_cast<Value*>(self);
         WebCore::FinalizedHeapObjectHeader* header = WebCore::FinalizedHeapObjectHeader::fromPayload(self);
         size_t length = header->payloadSize() / sizeof(Value);
         for (size_t i = 0; i < length; i++) {
-            if (!WTF::HashTableHelper<Value, Extractor, KeyTraits>::isEmptyOrDeletedBucket(array[i]))
+            if (!WTF::HashTableHelper<Value, typename Table::ExtractorType, typename Table::KeyTraitsType>::isEmptyOrDeletedBucket(array[i]))
                 CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, markWeakMembersStrongly, Value, Traits>::mark(visitor, array[i]);
         }
     }
 };
 
 template<bool markWeakMembersStrongly, typename Key, typename Value, typename Traits>
 struct BaseVisitKeyValuePairTrait {
     static void mark(WebCore::Visitor* visitor, WTF::KeyValuePair<Key, Value>& self)
     {
         ASSERT(WTF::ShouldBeTraced<Traits>::value || (Traits::isWeak && markWeakMembersStrongly));
@@ skipping 26 matching lines @@
 template<typename T, typename Traits>
 struct CollectionBackingTraceTrait<false, true, true, HeapVectorBacking<T, Traits>, void> : public BaseVisitVectorBackingTrait<true, T, Traits> {
 };
 
 // TXX (vector)
 template<bool isWeak, bool markWeakMembersStrongly, typename T, typename Traits>
 struct CollectionBackingTraceTrait<true, isWeak, markWeakMembersStrongly, HeapVectorBacking<T, Traits>, void> : public BaseVisitVectorBackingTrait<markWeakMembersStrongly, T, Traits> {
 };
 
 // FTT (hash table)
-template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
-struct CollectionBackingTraceTrait<false, true, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void> : public BaseVisitHashTableBackingTrait<true, Key, Value, Extractor, Traits, KeyTraits> {
+template<typename Table>
+struct CollectionBackingTraceTrait<false, true, true, HeapHashTableBacking<Table>, void> : public BaseVisitHashTableBackingTrait<true, Table> {
 };
 
 // TXX (hash table)
-template<bool isWeak, bool markWeakMembersStrongly, typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
-struct CollectionBackingTraceTrait<true, isWeak, markWeakMembersStrongly, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void> : public BaseVisitHashTableBackingTrait<markWeakMembersStrongly, Key, Value, Extractor, Traits, KeyTraits> {
+template<bool isWeak, bool markWeakMembersStrongly, typename Table>
+struct CollectionBackingTraceTrait<true, isWeak, markWeakMembersStrongly, HeapHashTableBacking<Table>, void> : public BaseVisitHashTableBackingTrait<markWeakMembersStrongly, Table> {
 };
 
 // FTT (key value pair)
 template<typename Key, typename Value, typename Traits>
 struct CollectionBackingTraceTrait<false, true, true, WTF::KeyValuePair<Key, Value>, Traits> : public BaseVisitKeyValuePairTrait<true, Key, Value, Traits> {
 };
 
 // TXX (key value pair)
 template<bool isWeak, bool markWeakMembersStrongly, typename Key, typename Value, typename Traits>
 struct CollectionBackingTraceTrait<true, isWeak, markWeakMembersStrongly, WTF::KeyValuePair<Key, Value>, Traits> : public BaseVisitKeyValuePairTrait<markWeakMembersStrongly, Key, Value, Traits> {
@@ skipping 53 matching lines @@
 #endif
     }
 };
 
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner. This
 // normally indicates that there is an ongoing iteration over the table, and so
 // we disable weak processing of table entries. When the backing is found
 // through the owning hash table we mark differently, in order to do weak
 // processing.
-template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
-struct TraceTrait<HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
-    typedef HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> Backing;
+template<typename Table>
+struct TraceTrait<HeapHashTableBacking<Table> > {
+    typedef HeapHashTableBacking<Table> Backing;
+    typedef typename Table::ValueTraits Traits;
     static void trace(WebCore::Visitor* visitor, void* self)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::isWeak)
-            CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void>::mark(visitor, self);
+            CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, true, Backing, void>::mark(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::isWeak)
             visitor->mark(backing, &trace);
         else
             visitor->mark(backing, 0);
     }
     static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
 #ifndef NDEBUG
         visitor->checkGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::get());
 #endif
     }
 };
 
+template<typename Table>
+void HeapHashTableBacking<Table>::finalize(void* pointer)
+{
+    typedef typename Table::ValueType Value;
+    ASSERT(Table::ValueTraits::needsDestruction);
+    FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPayload(pointer);
+    // Use the payload size as recorded by the heap to determine how many
+    // elements to finalize.
+    size_t length = header->payloadSize() / sizeof(Value);
+    Value* table = reinterpret_cast<Value*>(pointer);
+    for (unsigned i = 0; i < length; i++) {
+        if (!Table::isEmptyOrDeletedBucket(table[i]))
+            table[i].~Value();
+    }
+}
+
 template<typename T, typename U, typename V, typename W, typename X>
 struct GCInfoTrait<HeapHashMap<T, U, V, W, X> > : public GCInfoTrait<HashMap<T, U, V, W, X, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashSet<T, U, V> > : public GCInfoTrait<HashSet<T, U, V, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity> > : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
 
 template<typename T>
 struct IfWeakMember;
 
@@ skipping 13 matching lines @@
 // to export. This forces it to export all the methods from ThreadHeap.
 template<> void ThreadHeap<FinalizedHeapObjectHeader>::addPageToHeap(const GCInfo*);
 template<> void ThreadHeap<HeapObjectHeader>::addPageToHeap(const GCInfo*);
 extern template class HEAP_EXPORT ThreadHeap<FinalizedHeapObjectHeader>;
 extern template class HEAP_EXPORT ThreadHeap<HeapObjectHeader>;
 #endif
 
 }
 
 #endif // Heap_h