Replace ASSERT, ENABLE(ASSERT), and ASSERT_NOT_REACHED in wtf

third_party/WebKit/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.
  *
@@ skipping 276 matching lines @@
     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 ENABLE(ASSERT)
+#if DCHECK_IS_ON()
         ,
         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 ENABLE(ASSERT)
+#if DCHECK_IS_ON()
         ,
         m_container(container),
         m_containerModifications(container->modifications())
 #endif
   {
-    ASSERT(m_containerModifications == m_container->modifications());
+#if DCHECK_IS_ON()
+    DCHECK_EQ(m_containerModifications, m_container->modifications());
+#endif
   }
 
   void checkModifications() const {
+#if DCHECK_IS_ON()
     // 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.
-    ASSERT(m_containerModifications == m_container->modifications());
-    ASSERT(!m_container->accessForbidden());
+    DCHECK_EQ(m_containerModifications, m_container->modifications());
+    DCHECK(!m_container->accessForbidden());
+#endif
   }
 
  public:
   HashTableConstIterator() {}
 
   GetType get() const {
     checkModifications();
     return m_position;
   }
   typename Traits::IteratorConstReferenceType operator*() const {
     return Traits::getToReferenceConstConversion(get());
   }
   GetType operator->() const { return get(); }
 
   const_iterator& operator++() {
-    ASSERT(m_position != m_endPosition);
+    DCHECK_NE(m_position, m_endPosition);
     checkModifications();
     ++m_position;
     skipEmptyBuckets();
     return *this;
   }
 
   // postfix ++ intentionally omitted
 
   // Comparison.
   bool operator==(const const_iterator& other) const {
@@ skipping 13 matching lines @@
     if (m_position == m_endPosition)
       return stream << "iterator representing <end>";
     // TODO(tkent): Change |m_position| to |*m_position| to show the
     // pointed object. It requires a lot of new stream printer functions.
     return stream << "iterator pointing to " << m_position;
   }
 
  private:
   PointerType m_position;
   PointerType m_endPosition;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   const HashTableType* m_container;
   int64_t m_containerModifications;
 #endif
 };
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename Hash,
           typename Traits,
@@ skipping 285 matching lines @@
   typedef Key KeyType;
   typedef typename KeyTraits::PeekInType KeyPeekInType;
   typedef Value ValueType;
   typedef Extractor ExtractorType;
   typedef KeyTraits KeyTraitsType;
   typedef IdentityHashTranslator<HashFunctions> IdentityTranslatorType;
   typedef HashTableAddResult<HashTable, ValueType> AddResult;
 
   HashTable();
   void finalize() {
-    ASSERT(!Allocator::isGarbageCollected);
+    DCHECK(!Allocator::isGarbageCollected);
     if (LIKELY(!m_table))
       return;
-    ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-    m_accessForbidden = true;
-#endif
+    enterAccessForbiddenScope();
     deleteAllBucketsAndDeallocate(m_table, m_tableSize);
-#if ENABLE(ASSERT)
-    m_accessForbidden = false;
-#endif
+    leaveAccessForbiddenScope();
     m_table = nullptr;
   }
 
   HashTable(const HashTable&);
   HashTable(HashTable&&);
   void swap(HashTable&);
   HashTable& operator=(const HashTable&);
   HashTable& operator=(HashTable&&);
 
   // When the hash table is empty, just return the same iterator for end as
   // for begin.  This is more efficient because we don't have to skip all the
   // empty and deleted buckets, and iterating an empty table is a common case
   // that's worth optimizing.
   iterator begin() { return isEmpty() ? end() : makeIterator(m_table); }
   iterator end() { return makeKnownGoodIterator(m_table + m_tableSize); }
   const_iterator begin() const {
     return isEmpty() ? end() : makeConstIterator(m_table);
   }
   const_iterator end() const {
     return makeKnownGoodConstIterator(m_table + m_tableSize);
   }
 
   unsigned size() const {
-    ASSERT(!m_accessForbidden);
+    DCHECK(!accessForbidden());
     return m_keyCount;
   }
   unsigned capacity() const {
-    ASSERT(!m_accessForbidden);
+    DCHECK(!accessForbidden());
     return m_tableSize;
   }
   bool isEmpty() const {
-    ASSERT(!m_accessForbidden);
+    DCHECK(!accessForbidden());
     return !m_keyCount;
   }
 
   void reserveCapacityForSize(unsigned size);
 
   template <typename IncomingValueType>
   AddResult add(IncomingValueType&& value) {
     return add<IdentityTranslatorType>(Extractor::extract(value),
                                        std::forward<IncomingValueType>(value));
   }
@@ skipping 41 matching lines @@
     return lookup<IdentityTranslatorType, KeyPeekInType>(key);
   }
   template <typename HashTranslator, typename T>
   ValueType* lookup(const T&);
   template <typename HashTranslator, typename T>
   const ValueType* lookup(const T&) const;
 
   template <typename VisitorDispatcher>
   void trace(VisitorDispatcher);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
+  void enterAccessForbiddenScope() {
+    DCHECK(!m_accessForbidden);
+    m_accessForbidden = true;
+  }
+  void leaveAccessForbiddenScope() { m_accessForbidden = false; }
   bool accessForbidden() const { return m_accessForbidden; }
   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);
+    DCHECK_EQ(mods, m_modifications);
   }
 #else
+  void enterAccessForbiddenScope() {}
+  void leaveAccessForbiddenScope() {}
+  bool accessForbidden() const { return false; }
   int64_t modifications() const { return 0; }
   void registerModification() {}
   void checkModifications(int64_t mods) const {}
 #endif
 
  private:
   static ValueType* allocateTable(unsigned size);
   static void deleteAllBucketsAndDeallocate(ValueType* table, unsigned size);
 
   typedef std::pair<ValueType*, bool> LookupType;
@@ skipping 55 matching lines @@
   }
   const_iterator makeKnownGoodConstIterator(ValueType* pos) const {
     return const_iterator(pos, m_table + m_tableSize, this, HashItemKnownGood);
   }
 
   static const unsigned m_maxLoad = 2;
   static const unsigned m_minLoad = 6;
 
   unsigned tableSizeMask() const {
     size_t mask = m_tableSize - 1;
-    ASSERT((mask & m_tableSize) == 0);
+    DCHECK_EQ((mask & m_tableSize), 0u);
     return mask;
   }
 
   void setEnqueued() { m_queueFlag = true; }
   void clearEnqueued() { m_queueFlag = false; }
   bool enqueued() { return m_queueFlag; }
 
   ValueType* m_table;
   unsigned m_tableSize;
   unsigned m_keyCount;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   unsigned m_deletedCount : 30;
   unsigned m_queueFlag : 1;
   unsigned m_accessForbidden : 1;
   unsigned m_modifications;
 #else
   unsigned m_deletedCount : 31;
   unsigned m_queueFlag : 1;
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
@@ skipping 29 matching lines @@
                  Extractor,
                  HashFunctions,
                  Traits,
                  KeyTraits,
                  Allocator>::HashTable()
     : m_table(nullptr),
       m_tableSize(0),
       m_keyCount(0),
       m_deletedCount(0),
       m_queueFlag(false)
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       ,
       m_accessForbidden(false),
       m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
       m_stats(nullptr)
 #endif
 {
   static_assert(Allocator::isGarbageCollected ||
@@ skipping 63 matching lines @@
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 template <typename HashTranslator, typename T>
 inline const Value*
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     lookup(const T& key) const {
-  ASSERT(!m_accessForbidden);
-  ASSERT((HashTableKeyChecker<
+  DCHECK(!accessForbidden());
+  DCHECK((HashTableKeyChecker<
           HashTranslator, KeyTraits,
           HashFunctions::safeToCompareToEmptyOrDeleted>::checkKey(key)));
   const ValueType* table = m_table;
   if (!table)
     return nullptr;
 
   size_t k = 0;
   size_t sizeMask = tableSizeMask();
   unsigned h = HashTranslator::hash(key);
   size_t i = h & sizeMask;
@@ skipping 34 matching lines @@
 template <typename HashTranslator, typename T>
 inline typename HashTable<Key,
                           Value,
                           Extractor,
                           HashFunctions,
                           Traits,
                           KeyTraits,
                           Allocator>::LookupType
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     lookupForWriting(const T& key) {
-  ASSERT(!m_accessForbidden);
-  ASSERT(m_table);
+  DCHECK(!accessForbidden());
+  DCHECK(m_table);
   registerModification();
 
   ValueType* table = m_table;
   size_t k = 0;
   size_t sizeMask = tableSizeMask();
   unsigned h = HashTranslator::hash(key);
   size_t i = h & sizeMask;
 
   UPDATE_ACCESS_COUNTS();
 
@@ skipping 34 matching lines @@
 template <typename HashTranslator, typename T>
 inline typename HashTable<Key,
                           Value,
                           Extractor,
                           HashFunctions,
                           Traits,
                           KeyTraits,
                           Allocator>::FullLookupType
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     fullLookupForWriting(const T& key) {
-  ASSERT(!m_accessForbidden);
-  ASSERT(m_table);
+  DCHECK(!accessForbidden());
+  DCHECK(m_table);
   registerModification();
 
   ValueType* table = m_table;
   size_t k = 0;
   size_t sizeMask = tableSizeMask();
   unsigned h = HashTranslator::hash(key);
   size_t i = h & sizeMask;
 
   UPDATE_ACCESS_COUNTS();
 
@@ skipping 73 matching lines @@
 template <typename HashTranslator, typename T, typename Extra>
 typename HashTable<Key,
                    Value,
                    Extractor,
                    HashFunctions,
                    Traits,
                    KeyTraits,
                    Allocator>::AddResult
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     add(T&& key, Extra&& extra) {
-  ASSERT(!m_accessForbidden);
-  ASSERT(Allocator::isAllocationAllowed());
+  DCHECK(!accessForbidden());
+  DCHECK(Allocator::isAllocationAllowed());
   if (!m_table)
     expand();
 
-  ASSERT(m_table);
+  DCHECK(m_table);
 
   ValueType* table = m_table;
   size_t k = 0;
   size_t sizeMask = tableSizeMask();
   unsigned h = HashTranslator::hash(key);
   size_t i = h & sizeMask;
 
   UPDATE_ACCESS_COUNTS();
 
   ValueType* deletedEntry = nullptr;
@@ skipping 27 matching lines @@
   if (deletedEntry) {
     // Overwrite any data left over from last use, using placement new or
     // memset.
     initializeBucket(*deletedEntry);
     entry = deletedEntry;
     --m_deletedCount;
   }
 
   HashTranslator::translate(*entry, std::forward<T>(key),
                             std::forward<Extra>(extra));
-  ASSERT(!isEmptyOrDeletedBucket(*entry));
+  DCHECK(!isEmptyOrDeletedBucket(*entry));
 
   ++m_keyCount;
 
   if (shouldExpand()) {
     entry = expand(entry);
   } else if (Traits::weakHandlingFlag == WeakHandlingInCollections &&
              shouldShrink()) {
     // When weak hash tables are processed by the garbage collector,
     // elements with no other strong references to them will have their
     // table entries cleared. But no shrinking of the backing store is
@@ skipping 22 matching lines @@
 template <typename HashTranslator, typename T, typename Extra>
 typename HashTable<Key,
                    Value,
                    Extractor,
                    HashFunctions,
                    Traits,
                    KeyTraits,
                    Allocator>::AddResult
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     addPassingHashCode(T&& key, Extra&& extra) {
-  ASSERT(!m_accessForbidden);
-  ASSERT(Allocator::isAllocationAllowed());
+  DCHECK(!accessForbidden());
+  DCHECK(Allocator::isAllocationAllowed());
   if (!m_table)
     expand();
 
   FullLookupType lookupResult = fullLookupForWriting<HashTranslator>(key);
 
   ValueType* entry = lookupResult.first.first;
   bool found = lookupResult.first.second;
   unsigned h = lookupResult.second;
 
   if (found)
     return AddResult(this, entry, false);
 
   registerModification();
 
   if (isDeletedBucket(*entry)) {
     initializeBucket(*entry);
     --m_deletedCount;
   }
 
   HashTranslator::translate(*entry, std::forward<T>(key),
                             std::forward<Extra>(extra), h);
-  ASSERT(!isEmptyOrDeletedBucket(*entry));
+  DCHECK(!isEmptyOrDeletedBucket(*entry));
 
   ++m_keyCount;
   if (shouldExpand())
     entry = expand(entry);
 
   return AddResult(this, entry, true);
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 Value*
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     reinsert(ValueType&& entry) {
-  ASSERT(m_table);
+  DCHECK(m_table);
   registerModification();
-  ASSERT(!lookupForWriting(Extractor::extract(entry)).second);
-  ASSERT(
+  DCHECK(!lookupForWriting(Extractor::extract(entry)).second);
+  DCHECK(
       !isDeletedBucket(*(lookupForWriting(Extractor::extract(entry)).first)));
 #if DUMP_HASHTABLE_STATS
   atomicIncrement(&HashTableStats::instance().numReinserts);
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   ++m_stats->numReinserts;
 #endif
   Value* newEntry = lookupForWriting(Extractor::extract(entry)).first;
   Mover<ValueType, Allocator,
         Traits::template NeedsToForbidGCOnMove<>::value>::move(std::move(entry),
@@ skipping 83 matching lines @@
                KeyTraits,
                Allocator>::remove(ValueType* pos) {
   registerModification();
 #if DUMP_HASHTABLE_STATS
   atomicIncrement(&HashTableStats::instance().numRemoves);
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   ++m_stats->numRemoves;
 #endif
 
-  ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-  m_accessForbidden = true;
-#endif
+  enterAccessForbiddenScope();
   deleteBucket(*pos);
-#if ENABLE(ASSERT)
-  m_accessForbidden = false;
-#endif
+  leaveAccessForbiddenScope();
   ++m_deletedCount;
   --m_keyCount;
 
   if (shouldShrink())
     shrink();
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
@@ skipping 142 matching lines @@
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 Value*
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     expandBuffer(unsigned newTableSize, Value* entry, bool& success) {
   success = false;
-  ASSERT(m_tableSize < newTableSize);
+  DCHECK_LT(m_tableSize, newTableSize);
   if (!Allocator::expandHashTableBacking(m_table,
                                          newTableSize * sizeof(ValueType)))
     return nullptr;
 
   success = true;
 
   Value* newEntry = nullptr;
   unsigned oldTableSize = m_tableSize;
   ValueType* originalTable = m_table;
 
   ValueType* temporaryTable = allocateTable(oldTableSize);
   for (unsigned i = 0; i < oldTableSize; i++) {
     if (&m_table[i] == entry)
       newEntry = &temporaryTable[i];
     if (isEmptyOrDeletedBucket(m_table[i])) {
-      ASSERT(&m_table[i] != entry);
+      DCHECK_NE(&m_table[i], entry);
       if (Traits::emptyValueIsZero) {
         memset(&temporaryTable[i], 0, sizeof(ValueType));
       } else {
         initializeBucket(temporaryTable[i]);
       }
     } else {
       Mover<ValueType, Allocator,
             Traits::template NeedsToForbidGCOnMove<>::value>::
           move(std::move(m_table[i]), temporaryTable[i]);
     }
   }
   m_table = temporaryTable;
 
   if (Traits::emptyValueIsZero) {
     memset(originalTable, 0, newTableSize * sizeof(ValueType));
   } else {
     for (unsigned i = 0; i < newTableSize; i++)
       initializeBucket(originalTable[i]);
   }
   newEntry = rehashTo(originalTable, newTableSize, newEntry);
 
-  ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-  m_accessForbidden = true;
-#endif
+  enterAccessForbiddenScope();
   deleteAllBucketsAndDeallocate(temporaryTable, oldTableSize);
-#if ENABLE(ASSERT)
-  m_accessForbidden = false;
-#endif
+  leaveAccessForbiddenScope();
 
   return newEntry;
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
@@ skipping 13 matching lines @@
   if (oldTableSize != 0)
     ++m_stats->numRehashes;
 #endif
 
   m_table = newTable;
   m_tableSize = newTableSize;
 
   Value* newEntry = nullptr;
   for (unsigned i = 0; i != oldTableSize; ++i) {
     if (isEmptyOrDeletedBucket(oldTable[i])) {
-      ASSERT(&oldTable[i] != entry);
+      DCHECK_NE(&oldTable[i], entry);
       continue;
     }
     Value* reinsertedEntry = reinsert(std::move(oldTable[i]));
     if (&oldTable[i] == entry) {
-      ASSERT(!newEntry);
+      DCHECK(!newEntry);
       newEntry = reinsertedEntry;
     }
   }
 
   m_deletedCount = 0;
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   if (!m_stats)
     m_stats = HashTableStatsPtr<Allocator>::create();
 #endif
@@ skipping 30 matching lines @@
   if (Allocator::isGarbageCollected && newTableSize > oldTableSize) {
     bool success;
     Value* newEntry = expandBuffer(newTableSize, entry, success);
     if (success)
       return newEntry;
   }
 
   ValueType* newTable = allocateTable(newTableSize);
   Value* newEntry = rehashTo(newTable, newTableSize, entry);
 
-  ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-  m_accessForbidden = true;
-#endif
+  enterAccessForbiddenScope();
   deleteAllBucketsAndDeallocate(oldTable, oldTableSize);
-#if ENABLE(ASSERT)
-  m_accessForbidden = false;
-#endif
+  leaveAccessForbiddenScope();
 
   return newEntry;
 }
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 void HashTable<Key,
                Value,
                Extractor,
                HashFunctions,
                Traits,
                KeyTraits,
                Allocator>::clear() {
   registerModification();
   if (!m_table)
     return;
 
-  ASSERT(!m_accessForbidden);
-#if ENABLE(ASSERT)
-  m_accessForbidden = true;
-#endif
+  enterAccessForbiddenScope();
   deleteAllBucketsAndDeallocate(m_table, m_tableSize);
-#if ENABLE(ASSERT)
-  m_accessForbidden = false;
-#endif
+  leaveAccessForbiddenScope();
   m_table = nullptr;
   m_tableSize = 0;
   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(nullptr),
       m_tableSize(0),
       m_keyCount(0),
       m_deletedCount(0),
       m_queueFlag(false)
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       ,
       m_accessForbidden(false),
       m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
       m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
 #endif
 {
   // Copy the hash table the dumb way, by adding each element to the new
@@ skipping 11 matching lines @@
           typename Traits,
           typename KeyTraits,
           typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     HashTable(HashTable&& other)
     : m_table(nullptr),
       m_tableSize(0),
       m_keyCount(0),
       m_deletedCount(0),
       m_queueFlag(false)
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       ,
       m_accessForbidden(false),
       m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
       ,
       m_stats(HashTableStatsPtr<Allocator>::copy(other.m_stats))
 #endif
 {
   swap(other);
 }
 
 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) {
-  ASSERT(!m_accessForbidden);
+  DCHECK(!accessForbidden());
   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);
+  DCHECK(!m_queueFlag);
+  DCHECK(!other.m_queueFlag);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   std::swap(m_modifications, other.m_modifications);
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
   HashTableStatsPtr<Allocator>::swap(m_stats, other.m_stats);
 #endif
 }
 
 template <typename Key,
           typename Value,
@@ skipping 111 matching lines @@
           // because that would cause allocation during GC.
         }
       }
     }
   }
 
   // Called repeatedly for tables that have both weak and strong pointers.
   static void ephemeronIteration(typename Allocator::Visitor* visitor,
                                  void* closure) {
     HashTableType* table = reinterpret_cast<HashTableType*>(closure);
-    ASSERT(table->m_table);
+    DCHECK(table->m_table);
     // Check the hash table for elements that we now know will not be
     // removed by weak processing. Those elements need to have their strong
     // pointers traced.
     for (ValueType* element = table->m_table + table->m_tableSize - 1;
          element >= table->m_table; element--) {
       if (!HashTableType::isEmptyOrDeletedBucket(*element))
         TraceInCollectionTrait<WeakHandlingInCollections, WeakPointersActWeak,
                                ValueType, Traits>::trace(visitor, *element);
     }
   }
 
   // Called when the ephemeron iteration is done and before running the per
   // thread weak processing. It is guaranteed to be called before any thread
   // is resumed.
   static void ephemeronIterationDone(typename Allocator::Visitor* visitor,
                                      void* closure) {
     HashTableType* table = reinterpret_cast<HashTableType*>(closure);
-    ASSERT(Allocator::weakTableRegistered(visitor, table));
+#if DCHECK_IS_ON()
+    DCHECK(Allocator::weakTableRegistered(visitor, table));
+#endif
     table->clearEnqueued();
   }
 };
 
 template <typename Key,
           typename Value,
           typename Extractor,
           typename HashFunctions,
           typename Traits,
           typename KeyTraits,
@@ skipping 48 matching lines @@
   // by the visitor.
   Allocator::registerBackingStoreReference(visitor, &m_table);
   if (!IsTraceableInCollectionTrait<Traits>::value)
     return;
   if (Traits::weakHandlingFlag == WeakHandlingInCollections) {
     // If we have both strong and weak pointers in the collection then
     // we queue up the collection for fixed point iteration a la
     // Ephemerons:
     // http://dl.acm.org/citation.cfm?doid=263698.263733 - see also
     // http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
-    ASSERT(!enqueued() || Allocator::weakTableRegistered(visitor, this));
+#if DCHECK_IS_ON()
+    DCHECK(!enqueued() || Allocator::weakTableRegistered(visitor, this));
+#endif
     if (!enqueued()) {
       Allocator::registerWeakTable(
           visitor, this,
           WeakProcessingHashTableHelper<
               Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions,
               Traits, KeyTraits, Allocator>::ephemeronIteration,
           WeakProcessingHashTableHelper<
               Traits::weakHandlingFlag, Key, Value, Extractor, HashFunctions,
               Traits, KeyTraits, Allocator>::ephemeronIterationDone);
       setEnqueued();
@@ skipping 146 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