Replace ASSERTs in platform/heap/ with DCHECKs

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

 // Copyright 2015 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/PagePool.h"
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/PageMemory.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 FreePagePool::~FreePagePool() {
   for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
     while (PoolEntry* entry = m_pool[index]) {
       m_pool[index] = entry->next;
       PageMemory* memory = entry->data;
-      ASSERT(memory);
+      DCHECK(memory);
       delete memory;
       delete entry;
     }
   }
 }
 
 void FreePagePool::addFreePage(int index, PageMemory* memory) {
   // When adding a page to the pool we decommit it to ensure it is unused
   // while in the pool.  This also allows the physical memory, backing the
   // page, to be given back to the OS.
   memory->decommit();
   MutexLocker locker(m_mutex[index]);
   PoolEntry* entry = new PoolEntry(memory, m_pool[index]);
   m_pool[index] = entry;
 }
 
 PageMemory* FreePagePool::takeFreePage(int index) {
   MutexLocker locker(m_mutex[index]);
   while (PoolEntry* entry = m_pool[index]) {
     m_pool[index] = entry->next;
     PageMemory* memory = entry->data;
-    ASSERT(memory);
+    DCHECK(memory);
     delete entry;
     if (memory->commit())
       return memory;
 
     // We got some memory, but failed to commit it, try again.
     delete memory;
   }
   return nullptr;
 }
 
 OrphanedPagePool::~OrphanedPagePool() {
   for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
     while (PoolEntry* entry = m_pool[index]) {
       m_pool[index] = entry->next;
       BasePage* page = entry->data;
       delete entry;
       PageMemory* memory = page->storage();
-      ASSERT(memory);
+      DCHECK(memory);
       page->~BasePage();
       delete memory;
     }
   }
 }
 
 void OrphanedPagePool::addOrphanedPage(int index, BasePage* page) {
   page->markOrphaned();
   PoolEntry* entry = new PoolEntry(page, m_pool[index]);
   m_pool[index] = entry;
 }
 
 NO_SANITIZE_ADDRESS
 void OrphanedPagePool::decommitOrphanedPages() {
-  ASSERT(ThreadState::current()->isInGC());
-  ASSERT(ThreadState::current()->heap().isAtSafePoint());
+  DCHECK(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->heap().isAtSafePoint());
 
   for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
     PoolEntry* entry = m_pool[index];
     PoolEntry** prevNext = &m_pool[index];
     while (entry) {
       BasePage* page = entry->data;
       // Check if we should reuse the memory or just free it.
       // Large object memory is not reused but freed, normal blink heap
       // pages are reused.
       // NOTE: We call the destructor before freeing or adding to the
@@ skipping 34 matching lines @@
   for (Address current = address; current < address + size; ++current) {
     breakOptimization(current);
     *current = value;
   }
 }
 
 void OrphanedPagePool::clearMemory(PageMemory* memory) {
   asanDisabledMemset(memory->writableStart(), 0, blinkPagePayloadSize());
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool OrphanedPagePool::contains(void* object) {
   for (int index = 0; index < BlinkGC::NumberOfArenas; ++index) {
     for (PoolEntry* entry = m_pool[index]; entry; entry = entry->next) {
       BasePage* page = entry->data;
       if (page->contains(reinterpret_cast<Address>(object)))
         return true;
     }
   }
   return false;
 }
 #endif
 
 }  // namespace blink