Oilpan: Avoid declaring a destructor for garbage collected ListHashSet.

Source/wtf/ListHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * 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 38 matching lines @@
     template<typename Set> class ListHashSetReverseIterator;
     template<typename Set> class ListHashSetConstReverseIterator;
 
     template<typename ValueArg> class ListHashSetNodeBase;
     template<typename ValueArg, typename Allocator> class ListHashSetNode;
     template<typename ValueArg, size_t inlineCapacity> struct ListHashSetAllocator;
 
     template<typename HashArg> struct ListHashSetNodeHashFunctions;
     template<typename HashArg> struct ListHashSetTranslator;
 
+    // Don't declare a destructor for HeapAllocated ListHashSet.
+    template<typename Derived, typename Allocator, bool isGarbageCollected>
+    class ListHashSetDestructorBase;
+
+    template<typename Derived, typename Allocator>
+    class ListHashSetDestructorBase<Derived, Allocator, true> {
+    protected:
+        typename Allocator::AllocatorProvider m_allocatorProvider;
+    };
+
+    template<typename Derived, typename Allocator>
+    class ListHashSetDestructorBase<Derived, Allocator, false> {
+    public:
+        ~ListHashSetDestructorBase() { static_cast<Derived*>(this)->finalize(); }
+    protected:
+        typename Allocator::AllocatorProvider m_allocatorProvider;
+    };
+
     // Note that for a ListHashSet you cannot specify the HashTraits as a
     // template argument. It uses the default hash traits for the ValueArg
     // type.
-    template<typename ValueArg, size_t inlineCapacity = 256, typename HashArg = typename DefaultHash<ValueArg>::Hash, typename AllocatorArg = ListHashSetAllocator<ValueArg, inlineCapacity> > class ListHashSet {
+    template<typename ValueArg, size_t inlineCapacity = 256, typename HashArg = typename DefaultHash<ValueArg>::Hash, typename AllocatorArg = ListHashSetAllocator<ValueArg, inlineCapacity> > class ListHashSet
+        : public ListHashSetDestructorBase<ListHashSet<ValueArg, inlineCapacity, HashArg, AllocatorArg>, AllocatorArg, AllocatorArg::isGarbageCollected> {
         typedef AllocatorArg Allocator;
         WTF_USE_ALLOCATOR(ListHashSet, Allocator);
 
         typedef ListHashSetNode<ValueArg, Allocator> Node;
         typedef HashTraits<Node*> NodeTraits;
         typedef ListHashSetNodeHashFunctions<HashArg> NodeHash;
         typedef ListHashSetTranslator<HashArg> BaseTranslator;
 
         typedef HashTable<Node*, Node*, IdentityExtractor, NodeHash, NodeTraits, NodeTraits, typename Allocator::TableAllocator> ImplType;
         typedef HashTableIterator<Node*, Node*, IdentityExtractor, NodeHash, NodeTraits, NodeTraits, typename Allocator::TableAllocator> ImplTypeIterator;
@@ skipping 18 matching lines @@
         template<typename ValueType> struct HashTableAddResult {
         HashTableAddResult(Node* storedValue, bool isNewEntry) : storedValue(storedValue), isNewEntry(isNewEntry) { }
             Node* storedValue;
             bool isNewEntry;
         };
         typedef HashTableAddResult<ValueType> AddResult;
 
         ListHashSet();
         ListHashSet(const ListHashSet&);
         ListHashSet& operator=(const ListHashSet&);
-        ~ListHashSet();
+        void finalize();
 
         void swap(ListHashSet&);
 
         unsigned size() const { return m_impl.size(); }
         unsigned capacity() const { return m_impl.capacity(); }
         bool isEmpty() const { return m_impl.isEmpty(); }
 
         iterator begin() { return makeIterator(m_head); }
         iterator end() { return makeIterator(0); }
         const_iterator begin() const { return makeConstIterator(m_head); }
@@ skipping 52 matching lines @@
 
         void trace(typename Allocator::Visitor*);
 
     private:
         void unlink(Node*);
         void unlinkAndDelete(Node*);
         void appendNode(Node*);
         void prependNode(Node*);
         void insertNodeBefore(Node* beforeNode, Node* newNode);
         void deleteAllNodes();
-        Allocator* allocator() const { return m_allocatorProvider.get(); }
-        void createAllocatorIfNeeded() { m_allocatorProvider.createAllocatorIfNeeded(); }
-        void deallocate(Node* node) const { m_allocatorProvider.deallocate(node); }
+        Allocator* allocator() const { return this->m_allocatorProvider.get(); }
+        void createAllocatorIfNeeded() { this->m_allocatorProvider.createAllocatorIfNeeded(); }
+        void deallocate(Node* node) const { this->m_allocatorProvider.deallocate(node); }
 
         iterator makeIterator(Node* position) { return iterator(this, position); }
         const_iterator makeConstIterator(Node* position) const { return const_iterator(this, position); }
         reverse_iterator makeReverseIterator(Node* position) { return reverse_iterator(this, position); }
         const_reverse_iterator makeConstReverseIterator(Node* position) const { return const_reverse_iterator(this, position); }
 
         friend void deleteAllValues<>(const ListHashSet&);
 
         ImplType m_impl;
         Node* m_head;
         Node* m_tail;
-        typename Allocator::AllocatorProvider m_allocatorProvider;
     };
 
     // ListHashSetNode has this base class to hold the members because the MSVC
     // compiler otherwise gets into circular template dependencies when trying
     // to do sizeof on a node.
     template<typename ValueArg> class ListHashSetNodeBase {
     protected:
         ListHashSetNodeBase(const ValueArg& value)
             : m_value(value)
             , m_prev(0)
@@ skipping 463 matching lines @@
         swap(tmp);
         return *this;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
     inline void ListHashSet<T, inlineCapacity, U, V>::swap(ListHashSet& other)
     {
         m_impl.swap(other.m_impl);
         std::swap(m_head, other.m_head);
         std::swap(m_tail, other.m_tail);
-        m_allocatorProvider.swap(other.m_allocatorProvider);
+        this->m_allocatorProvider.swap(other.m_allocatorProvider);
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
-    inline ListHashSet<T, inlineCapacity, U, V>::~ListHashSet()
+    inline void ListHashSet<T, inlineCapacity, U, V>::finalize()
     {
-        if (!Allocator::isGarbageCollected)
-            deleteAllNodes();
+        COMPILE_ASSERT(!Allocator::isGarbageCollected, FinalizeOnHeapAllocatedListHashSetShouldNeverBeCalled);
+        deleteAllNodes();
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
     inline T& ListHashSet<T, inlineCapacity, U, V>::first()
     {
         ASSERT(!isEmpty());
         return m_head->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U, typename V>
@@ skipping 282 matching lines @@
     inline void deleteAllValues(const ListHashSet<T, inlineCapacity, U, V>& collection)
     {
         deleteAllValues<true, typename ListHashSet<T, inlineCapacity, U, V>::ValueType>(collection.m_impl);
     }
 
 } // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif /* WTF_ListHashSet_h */