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 41 matching lines @@
     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;
 
     // 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 HashTableDestructorBase<ListHashSet<ValueArg, inlineCapacity, HashArg, 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 554 matching lines @@
     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);
     }
 
     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();
+        ASSERT(!Allocator::isGarbageCollected);

[Mikhail, 2014/05/09 08:06:36]

think now it can be COMPILE_ASSERT

[zerny-chromium, 2014/05/09 09:19:48]

Done.

+        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 */