Oilpan: HeapVectorBacking should call destructors for its elements

Source/platform/heap/GCInfo.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GCInfo_h
 #define GCInfo_h
 
 #include "platform/heap/Visitor.h"
 #include "wtf/Assertions.h"
 #include "wtf/Atomics.h"
@@ skipping 138 matching lines @@
     static const bool nonTrivialFinalizer = inlineCapacity && VectorTraits<T>::needsDestruction;
     static void finalize(void* obj) { FinalizerTraitImpl<Deque<T, inlineCapacity, HeapAllocator>, nonTrivialFinalizer>::finalize(obj); }
 };
 
 template<typename Table>
 struct FinalizerTrait<HeapHashTableBacking<Table>> {
     static const bool nonTrivialFinalizer = !WTF::IsTriviallyDestructible<typename Table::ValueType>::value;
     static void finalize(void* obj) { FinalizerTraitImpl<HeapHashTableBacking<Table>, nonTrivialFinalizer>::finalize(obj); }
 };
 
-// TODO(haraken): Replace this GCInfoTraits with FinalizerTraits.
 template<typename T, typename Traits>
-struct GCInfoTrait<HeapVectorBacking<T, Traits>> {
-    static size_t index()
-    {
-        using TargetType = HeapVectorBacking<T, Traits>;
-        static const GCInfo gcInfo = {
-            TraceTrait<TargetType>::trace,
-            FinalizerTrait<TargetType>::finalize,
-            Traits::needsDestruction,
-            false, // We don't support embedded objects in HeapVectors with vtables.
-#if ENABLE(GC_PROFILING)
-            TypenameStringTrait<TargetType>::get()
-#endif
-        };
-        RETURN_GCINFO_INDEX();
-    }
+struct FinalizerTrait<HeapVectorBacking<T, Traits>> {
+    static const bool nonTrivialFinalizer = Traits::needsDestruction;
+    static void finalize(void* obj) { FinalizerTraitImpl<HeapVectorBacking<T, Traits>, nonTrivialFinalizer>::finalize(obj); }
 };
 
 template<typename T, typename U, typename V, typename W, typename X> class HeapHashMap;
 template<typename T, typename U, typename V> class HeapHashSet;
 template<typename T, typename U, typename V> class HeapLinkedHashSet;
 template<typename T, size_t inlineCapacity, typename U> class HeapListHashSet;
 template<typename T, size_t inlineCapacity> class HeapVector;
 template<typename T, size_t inlineCapacity> class HeapDeque;
 template<typename T, typename U, typename V> class HeapHashCountedSet;
 
 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, typename U, typename V>
 struct GCInfoTrait<HeapLinkedHashSet<T, U, V>> : public GCInfoTrait<LinkedHashSet<T, U, V, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity, typename U>
 struct GCInfoTrait<HeapListHashSet<T, inlineCapacity, U>> : public GCInfoTrait<ListHashSet<T, inlineCapacity, U, HeapListHashSetAllocator<T, inlineCapacity>>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif