Replace ASSERTs in platform/heap/ with DCHECKs

third_party/WebKit/Source/platform/heap/CallbackStack.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/heap/CallbackStack.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/allocator/Partitions.h"
 
 namespace blink {
 
@@ skipping 49 matching lines @@
     return;
   }
   // Otherwise, return the memory back to the free list.
   DCHECK_EQ(m_freeListNext[index], -1);
   m_freeListNext[index] = m_freeListFirst;
   m_freeListFirst = index;
 }
 
 CallbackStack::Block::Block(Block* next) {
   m_buffer = CallbackStackMemoryPool::instance().allocate();
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   clear();
 #endif
 
   m_limit = &(m_buffer[CallbackStackMemoryPool::kBlockSize]);
   m_current = &(m_buffer[0]);
   m_next = next;
 }
 
 CallbackStack::Block::~Block() {
   CallbackStackMemoryPool::instance().free(m_buffer);
   m_buffer = nullptr;
   m_limit = nullptr;
   m_current = nullptr;
   m_next = nullptr;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 void CallbackStack::Block::clear() {
   for (size_t i = 0; i < CallbackStackMemoryPool::kBlockSize; i++)
     m_buffer[i] = Item(0, 0);
 }
 #endif
 
 void CallbackStack::Block::invokeEphemeronCallbacks(Visitor* visitor) {
   // This loop can tolerate entries being added by the callbacks after
   // iteration starts.
   for (unsigned i = 0; m_buffer + i < m_current; i++) {
     Item& item = m_buffer[i];
     item.call(visitor);
   }
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool CallbackStack::Block::hasCallbackForObject(const void* object) {
   for (unsigned i = 0; m_buffer + i < m_current; i++) {
     Item* item = &m_buffer[i];
     if (item->object() == object)
       return true;
   }
   return false;
 }
 #endif
 
@@ skipping 38 matching lines @@
   return m_first->allocateEntry();
 }
 
 CallbackStack::Item* CallbackStack::popSlow() {
   DCHECK(m_first);
   DCHECK(m_first->isEmptyBlock());
 
   for (;;) {
     Block* next = m_first->next();
     if (!next) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       m_first->clear();
 #endif
       return nullptr;
     }
     delete m_first;
     m_first = next;
     if (Item* item = m_first->pop())
       return item;
   }
 }
@@ skipping 24 matching lines @@
   // Recurse first so we get to the newly added entries last.
   invokeOldestCallbacks(from->next(), upto, visitor);
   from->invokeEphemeronCallbacks(visitor);
 }
 
 bool CallbackStack::hasJustOneBlock() const {
   DCHECK(m_first);
   return !m_first->next();
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool CallbackStack::hasCallbackForObject(const void* object) {
   for (Block* current = m_first; current; current = current->next()) {
     if (current->hasCallbackForObject(object))
       return true;
   }
   return false;
 }
 #endif
 
 }  // namespace blink