Allow assertions to be enabled in Blink Release builds.

Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * 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 106 matching lines @@
 
         void skipEmptyBuckets()
         {
             while (m_position != m_endPosition && HashTableType::isEmptyOrDeletedBucket(*m_position))
                 ++m_position;
         }
 
         HashTableConstIterator(PointerType position, PointerType endPosition, const HashTableType* container)
             : m_position(position)
             , m_endPosition(endPosition)
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
             , m_container(container)
             , m_containerModifications(container->modifications())
 #endif
         {
             skipEmptyBuckets();
         }
 
         HashTableConstIterator(PointerType position, PointerType endPosition, const HashTableType* container, HashItemKnownGoodTag)
             : m_position(position)
             , m_endPosition(endPosition)
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
             , m_container(container)
             , m_containerModifications(container->modifications())
 #endif
         {
             ASSERT(m_containerModifications == m_container->modifications());
         }
 
         void checkModifications() const
         {
             // HashTable and collections that build on it do not support
@@ skipping 41 matching lines @@
             return *this == static_cast<const_iterator>(other);
         }
         bool operator!=(const iterator& other) const
         {
             return *this != static_cast<const_iterator>(other);
         }
 
     private:
         PointerType m_position;
         PointerType m_endPosition;
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
         const HashTableType* m_container;
         int64_t m_containerModifications;
 #endif
     };
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     class HashTableIterator {
     private:
         typedef HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> HashTableType;
         typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> iterator;
@@ skipping 54 matching lines @@
     public:
         template<typename T> static unsigned hash(const T& key) { return HashFunctions::hash(key); }
         template<typename T, typename U> static bool equal(const T& a, const U& b) { return HashFunctions::equal(a, b); }
         template<typename T, typename U, typename V> static void translate(T& location, const U&, const V& value) { location = value; }
     };
 
     template<typename HashTableType, typename ValueType> struct HashTableAddResult {
         HashTableAddResult(const HashTableType* container, ValueType* storedValue, bool isNewEntry)
             : storedValue(storedValue)
             , isNewEntry(isNewEntry)
-#if SECURITY_ASSERT_ENABLED
+#if ENABLE(SECURITY_ASSERT)
             , m_container(container)
             , m_containerModifications(container->modifications())
 #endif
         {
             ASSERT_UNUSED(container, container);
         }
 
         ~HashTableAddResult()
         {
             // If rehash happened before accessing storedValue, it's
             // use-after-free. Any modification may cause a rehash, so we check
             // for modifications here.
             // Rehash after accessing storedValue is harmless but will assert if
             // the AddResult destructor takes place after a modification. You
             // may need to limit the scope of the AddResult.
             ASSERT_WITH_SECURITY_IMPLICATION(m_containerModifications == m_container->modifications());
         }
 
         ValueType* storedValue;
         bool isNewEntry;
 
-#if SECURITY_ASSERT_ENABLED
+#if ENABLE(SECURITY_ASSERT)
     private:
         const HashTableType* m_container;
         const int64_t m_containerModifications;
 #endif
     };
 
     template<typename Value, typename Extractor, typename KeyTraits>
     struct HashTableHelper {
         static bool isEmptyBucket(const Value& value) { return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value)); }
         static bool isDeletedBucket(const Value& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }
@@ skipping 147 matching lines @@
         static bool isEmptyBucket(const ValueType& value) { return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value)); }
         static bool isDeletedBucket(const ValueType& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }
         static bool isEmptyOrDeletedBucket(const ValueType& value) { return HashTableHelper<ValueType, Extractor, KeyTraits>:: isEmptyOrDeletedBucket(value); }
 
         ValueType* lookup(KeyPeekInType key) { return lookup<IdentityTranslatorType, KeyPeekInType>(key); }
         template<typename HashTranslator, typename T> ValueType* lookup(T);
         template<typename HashTranslator, typename T> const ValueType* lookup(T) const;
 
         void trace(typename Allocator::Visitor*);
 
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
         int64_t modifications() const { return m_modifications; }
         void registerModification() { m_modifications++; }
         // HashTable and collections that build on it do not support
         // modifications while there is an iterator in use. The exception is
         // ListHashSet, which has its own iterators that tolerate modification
         // of the underlying set.
         void checkModifications(int64_t mods) const { ASSERT(mods == m_modifications); }
 #else
         int64_t modifications() const { return 0; }
         void registerModification() { }
@@ skipping 45 matching lines @@
 
         void setEnqueued() { m_queueFlag = true; }
         void clearEnqueued() { m_queueFlag = false; }
         bool enqueued() { return m_queueFlag; }
 
         ValueType* m_table;
         unsigned m_tableSize;
         unsigned m_keyCount;
         unsigned m_deletedCount:31;
         bool m_queueFlag:1;
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
         unsigned m_modifications;
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
     public:
         mutable OwnPtr<Stats> m_stats;
 #endif
 
         template<WeakHandlingFlag x, typename T, typename U, typename V, typename W, typename X, typename Y, typename Z> friend struct WeakProcessingHashTableHelper;
         template<typename T, typename U, typename V, typename W> friend class LinkedHashSet;
@@ skipping 37 matching lines @@
         COMPILE_ASSERT(value > (2 * size), HashTableCapacityHoldsContentSize);
     };
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     inline HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable()
         : m_table(0)
         , m_tableSize(0)
         , m_keyCount(0)
         , m_deletedCount(0)
         , m_queueFlag(false)
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
         , m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
         , m_stats(adoptPtr(new Stats))
 #endif
     {
     }
 
     inline unsigned doubleHash(unsigned key)
     {
@@ skipping 458 matching lines @@
         m_keyCount = 0;
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable(const HashTable& other)
         : m_table(0)
         , m_tableSize(0)
         , m_keyCount(0)
         , m_deletedCount(0)
         , m_queueFlag(false)
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
         , m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
         , m_stats(adoptPtr(new Stats(*other.m_stats)))
 #endif
     {
         // Copy the hash table the dumb way, by adding each element to the new table.
         // It might be more efficient to copy the table slots, but it's not clear that efficiency is needed.
         const_iterator end = other.end();
         for (const_iterator it = other.begin(); it != end; ++it)
             add(*it);
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::swap(HashTable& other)
     {
         std::swap(m_table, other.m_table);
         std::swap(m_tableSize, other.m_tableSize);
         std::swap(m_keyCount, other.m_keyCount);
         // std::swap does not work for bit fields.
         unsigned deleted = m_deletedCount;
         m_deletedCount = other.m_deletedCount;
         other.m_deletedCount = deleted;
         ASSERT(!m_queueFlag);
         ASSERT(!other.m_queueFlag);
 
-#if ASSERT_ENABLED
+#if ENABLE(ASSERT)
         std::swap(m_modifications, other.m_modifications);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
         m_stats.swap(other.m_stats);
 #endif
     }
 
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
     HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>& HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::operator=(const HashTable& other)
@@ skipping 228 matching lines @@
         CollectionIterator end(toBeRemoved.end());
         for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
             collection.remove(*it);
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h