Oilpan: HeapVectorBacking should call destructors for its elements

Source/platform/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 1483 matching lines @@
 
     if (UNLIKELY(isUrgentGCRequested()))
         return;
 
     size_t externalBytesAliveAtLastGC = externallyAllocatedBytesAlive();
     if (UNLIKELY(externalBytesAllocatedSinceLastGC > externalBytesAliveAtLastGC / 2))
         Heap::requestUrgentGC();
 }
 
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
-template<typename T, typename Traits = WTF::VectorTraits<T>> class HeapVectorBacking;
+template<typename T, typename Traits = WTF::VectorTraits<T>> class HeapVectorBacking {
+public:
+    static void finalize(void* pointer);
+    void finalizeGarbageCollectedObject() { finalize(this); }
+};
 template<typename Table> class HeapHashTableBacking {
 public:
     static void finalize(void* pointer);
     void finalizeGarbageCollectedObject() { finalize(this); }
 };
 
 class HeapAllocatorQuantizer {
 public:
     template<typename T>
     static size_t quantizedSize(size_t count)
@@ skipping 689 matching lines @@
             visitor->markNoTracing(backing); // If we know the trace function will do nothing there is no need to call it.
     }
     static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
 #if ENABLE(ASSERT)
         assertObjectHasGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::index());
 #endif
     }
 };
 
+template<typename T, typename Traits>
+void HeapVectorBacking<T, Traits>::finalize(void* pointer)
+{
+    ASSERT(!WTF::IsTriviallyDestructible<T>::value);
+    HeapObjectHeader* header = HeapObjectHeader::fromPayload(pointer);
+    // Use the payload size as recorded by the heap to determine how many
+    // elements to finalize.
+    size_t length = header->payloadSize() / sizeof(T);
+    T* array = reinterpret_cast<T*>(pointer);
+    for (unsigned i = 0; i < length; ++i) {
+        array[i].~T();
+    }
+}
+
 template<typename Table>
 void HeapHashTableBacking<Table>::finalize(void* pointer)
 {
     using Value = typename Table::ValueType;
     ASSERT(!WTF::IsTriviallyDestructible<Value>::value);
     HeapObjectHeader* header = HeapObjectHeader::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();
     }
 }
 
 } // namespace blink
 
 #endif // Heap_h