Replace ENABLE(ASSERT) with DCHECK_IS_ON().

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 71 matching lines @@
     static_cast<LargeObjectPage*>(largePage)->setIsVectorBackingPage(); \
   }
 #else
 #define ENABLE_ASAN_CONTAINER_ANNOTATIONS 0
 #define ASAN_RETIRE_CONTAINER_ANNOTATION(payload, payloadSize)
 #define ASAN_MARK_LARGE_VECTOR_CONTAINER(arena, largeObject)
 #endif
 
 namespace blink {
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::zapMagic() {
   ASSERT(checkHeader());
   m_magic = zappedMagic;
 }
 #endif
 
 void HeapObjectHeader::finalize(Address object, size_t objectSize) {
   HeapAllocHooks::freeHookIfEnabled(object);
   const GCInfo* gcInfo = ThreadHeap::gcInfo(gcInfoIndex());
@@ skipping 48 matching lines @@
   allocatorDump->AddScalar("blink_page_count", "objects", pageCount);
 
   // When taking a full dump (w/ freelist), both the /buckets and /pages
   // report their free size but they are not meant to be added together.
   // Therefore, here we override the free_size of the parent heap to be
   // equal to the free_size of the sum of its heap pages.
   allocatorDump->AddScalar("free_size", "bytes", heapInfo.freeSize);
   allocatorDump->AddScalar("free_count", "objects", heapInfo.freeCount);
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 BasePage* BaseArena::findPageFromAddress(Address address) {
   for (BasePage* page = m_firstPage; page; page = page->next()) {
     if (page->contains(address))
       return page;
   }
   for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
     if (page->contains(address))
       return page;
   }
   return nullptr;
@@ skipping 383 matching lines @@
     size_t pageSize = availablePages->size();
 #if DEBUG_HEAP_COMPACTION
     if (!freedPageCount)
       LOG_HEAP_COMPACTION("Releasing:");
     LOG_HEAP_COMPACTION(" [%p, %p]", availablePages, availablePages + pageSize);
 #endif
     freedSize += pageSize;
     freedPageCount++;
     BasePage* nextPage;
     availablePages->unlink(&nextPage);
-#if !(ENABLE(ASSERT) || defined(LEAK_SANITIZER) || \
+#if !(DCHECK_IS_ON() || defined(LEAK_SANITIZER) || \
       defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER))
     // Clear out the page before adding it to the free page pool, which
     // decommits it. Recommitting the page must find a zeroed page later.
     // We cannot assume that the OS will hand back a zeroed page across
     // its "decommit" operation.
     //
     // If in a debug setting, the unused page contents will have been
     // zapped already; leave it in that state.
     DCHECK(!availablePages->isLargeObjectPage());
     NormalPage* unusedPage = reinterpret_cast<NormalPage*>(availablePages);
     memset(unusedPage->payload(), 0, unusedPage->payloadSize());
 #endif
     availablePages->removeFromHeap();
     availablePages = static_cast<NormalPage*>(nextPage);
   }
   if (freedPageCount)
     LOG_HEAP_COMPACTION("\n");
   heap.compaction()->finishedArenaCompaction(this, freedPageCount, freedSize);
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool NormalPageArena::isConsistentForGC() {
   // A thread heap is consistent for sweeping if none of the pages to be swept
   // contain a freelist block or the current allocation point.
   for (size_t i = 0; i < blinkPageSizeLog2; ++i) {
     for (FreeListEntry* freeListEntry = m_freeList.m_freeLists[i];
          freeListEntry; freeListEntry = freeListEntry->next()) {
       if (pagesToBeSweptContains(freeListEntry->getAddress()))
         return false;
     }
   }
@@ skipping 58 matching lines @@
         getThreadState()->heap().getFreePagePool()->addFreePage(arenaIndex(),
                                                                 memory);
       }
     }
   }
   NormalPage* page =
       new (pageMemory->writableStart()) NormalPage(pageMemory, this);
   page->link(&m_firstPage);
 
   getThreadState()->heap().heapStats().increaseAllocatedSpace(page->size());
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
   // Allow the following addToFreeList() to add the newly allocated memory
   // to the free list.
   ASAN_UNPOISON_MEMORY_REGION(page->payload(), page->payloadSize());
   Address address = page->payload();
   for (size_t i = 0; i < page->payloadSize(); i++)
     address[i] = reuseAllowedZapValue;
   ASAN_POISON_MEMORY_REGION(page->payload(), page->payloadSize());
 #endif
   addToFreeList(page->payload(), page->payloadSize());
 }
@@ skipping 217 matching lines @@
 void NormalPageArena::updateRemainingAllocationSize() {
   if (m_lastRemainingAllocationSize > remainingAllocationSize()) {
     getThreadState()->increaseAllocatedObjectSize(
         m_lastRemainingAllocationSize - remainingAllocationSize());
     m_lastRemainingAllocationSize = remainingAllocationSize();
   }
   ASSERT(m_lastRemainingAllocationSize == remainingAllocationSize());
 }
 
 void NormalPageArena::setAllocationPoint(Address point, size_t size) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   if (point) {
     ASSERT(size);
     BasePage* page = pageFromObject(point);
     ASSERT(!page->isLargeObjectPage());
     ASSERT(size <= static_cast<NormalPage*>(page)->payloadSize());
   }
 #endif
   if (hasCurrentAllocationArea()) {
     addToFreeList(currentAllocationPoint(), remainingAllocationSize());
   }
@@ skipping 114 matching lines @@
 #if defined(ADDRESS_SANITIZER)
   largeObjectSize += allocationGranularity;
 #endif
 
   getThreadState()->shouldFlushHeapDoesNotContainCache();
   PageMemory* pageMemory = PageMemory::allocate(
       largeObjectSize, getThreadState()->heap().getRegionTree());
   Address largeObjectAddress = pageMemory->writableStart();
   Address headerAddress =
       largeObjectAddress + LargeObjectPage::pageHeaderSize();
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // Verify that the allocated PageMemory is expectedly zeroed.
   for (size_t i = 0; i < largeObjectSize; ++i)
     ASSERT(!largeObjectAddress[i]);
 #endif
   ASSERT(gcInfoIndex > 0);
   HeapObjectHeader* header = new (NotNull, headerAddress)
       HeapObjectHeader(largeObjectSizeInHeader, gcInfoIndex);
   Address result = headerAddress + sizeof(*header);
   ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
   LargeObjectPage* largeObject = new (largeObjectAddress)
@@ skipping 92 matching lines @@
     ASSERT(size >= sizeof(HeapObjectHeader));
     // Free list encode the size to mark the lost memory as freelist memory.
     new (NotNull, address) HeapObjectHeader(size, gcInfoIndexForFreeListHeader);
 
     ASAN_POISON_MEMORY_REGION(address, size);
     // This memory gets lost. Sweeping can reclaim it.
     return;
   }
   entry = new (NotNull, address) FreeListEntry(size);
 
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
   // The following logic delays reusing free lists for (at least) one GC
   // cycle or coalescing. This is helpful to detect use-after-free errors
   // that could be caused by lazy sweeping etc.
   size_t allowedCount = 0;
   size_t forbiddenCount = 0;
   for (size_t i = sizeof(FreeListEntry); i < size; i++) {
     if (address[i] == reuseAllowedZapValue)
       allowedCount++;
     else if (address[i] == reuseForbiddenZapValue)
       forbiddenCount++;
@@ skipping 29 matching lines @@
 // region to the free list and reuse it for another object.
 #endif
   ASAN_POISON_MEMORY_REGION(address, size);
 
   int index = bucketIndexForSize(size);
   entry->link(&m_freeLists[index]);
   if (index > m_biggestFreeListIndex)
     m_biggestFreeListIndex = index;
 }
 
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
     defined(MEMORY_SANITIZER)
 NO_SANITIZE_ADDRESS
 NO_SANITIZE_MEMORY
 void NEVER_INLINE FreeList::zapFreedMemory(Address address, size_t size) {
   for (size_t i = 0; i < size; i++) {
     // See the comment in addToFreeList().
     if (address[i] != reuseAllowedZapValue)
       address[i] = reuseForbiddenZapValue;
   }
 }
@@ skipping 120 matching lines @@
 
 bool NormalPage::isEmpty() {
   HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(payload());
   return header->isFree() && header->size() == payloadSize();
 }
 
 void NormalPage::removeFromHeap() {
   arenaForNormalPage()->freePage(this);
 }
 
-#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+#if !DCHECK_IS_ON() && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
 static void discardPages(Address begin, Address end) {
   uintptr_t beginAddress =
       WTF::RoundUpToSystemPage(reinterpret_cast<uintptr_t>(begin));
   uintptr_t endAddress =
       WTF::RoundDownToSystemPage(reinterpret_cast<uintptr_t>(end));
   if (beginAddress < endAddress)
     WTF::DiscardSystemPages(reinterpret_cast<void*>(beginAddress),
                             endAddress - beginAddress);
 }
 #endif
@@ skipping 35 matching lines @@
       ASAN_UNPOISON_MEMORY_REGION(payload, payloadSize);
       header->finalize(payload, payloadSize);
       // This memory will be added to the freelist. Maintain the invariant
       // that memory on the freelist is zero filled.
       SET_MEMORY_INACCESSIBLE(headerAddress, size);
       headerAddress += size;
       continue;
     }
     if (startOfGap != headerAddress) {
       pageArena->addToFreeList(startOfGap, headerAddress - startOfGap);
-#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+#if !DCHECK_IS_ON() && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
       // Discarding pages increases page faults and may regress performance.
       // So we enable this only on low-RAM devices.
       if (MemoryCoordinator::isLowEndDevice())
         discardPages(startOfGap + sizeof(FreeListEntry), headerAddress);
 #endif
     }
     header->unmark();
     headerAddress += size;
     markedObjectSize += size;
     startOfGap = headerAddress;
   }
   if (startOfGap != payloadEnd()) {
     pageArena->addToFreeList(startOfGap, payloadEnd() - startOfGap);
-#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+#if !DCHECK_IS_ON() && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
     if (MemoryCoordinator::isLowEndDevice())
       discardPages(startOfGap + sizeof(FreeListEntry), payloadEnd());
 #endif
   }
 
   if (markedObjectSize)
     pageArena->getThreadState()->increaseMarkedObjectSize(markedObjectSize);
 }
 
 void NormalPage::sweepAndCompact(CompactionContext& context) {
@@ skipping 29 matching lines @@
       // finalized object will be zero-filled and poison'ed afterwards.
       // Given all other unmarked objects are poisoned, ASan will detect
       // an error if the finalizer touches any other on-heap object that
       // die at the same GC cycle.
       ASAN_UNPOISON_MEMORY_REGION(headerAddress, size);
       header->finalize(payload, payloadSize);
 
 // As compaction is under way, leave the freed memory accessible
 // while compacting the rest of the page. We just zap the payload
 // to catch out other finalizers trying to access it.
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
     defined(MEMORY_SANITIZER)
       FreeList::zapFreedMemory(payload, payloadSize);
 #endif
       headerAddress += size;
       continue;
     }
     header->unmark();
     // Allocate and copy over the live object.
     Address compactFrontier = currentPage->payload() + allocationPoint;
     if (compactFrontier + size > currentPage->payloadEnd()) {
@@ skipping 34 matching lines @@
       compact->relocate(payload, compactFrontier + sizeof(HeapObjectHeader));
     }
     headerAddress += size;
     markedObjectSize += size;
     allocationPoint += size;
     DCHECK(allocationPoint <= currentPage->payloadSize());
   }
   if (markedObjectSize)
     pageArena->getThreadState()->increaseMarkedObjectSize(markedObjectSize);
 
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
     defined(MEMORY_SANITIZER)
   // Zap the unused portion, until it is either compacted into or freed.
   if (currentPage != this) {
     FreeList::zapFreedMemory(payload(), payloadSize());
   } else {
     FreeList::zapFreedMemory(payload() + allocationPoint,
                              payloadSize() - allocationPoint);
   }
 #endif
 }
@@ skipping 130 matching lines @@
   objectStartNumber = (mapIndex * 8) + 7 - leadingZeroes;
   objectOffset = objectStartNumber * allocationGranularity;
   Address objectAddress = objectOffset + payload();
   HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(objectAddress);
   if (header->isFree())
     return nullptr;
   ASSERT(header->checkHeader());
   return header;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 static bool isUninitializedMemory(void* objectPointer, size_t objectSize) {
   // Scan through the object's fields and check that they are all zero.
   Address* objectFields = reinterpret_cast<Address*>(objectPointer);
   for (size_t i = 0; i < objectSize / sizeof(Address); ++i) {
     if (objectFields[i] != 0)
       return false;
   }
   return true;
 }
 #endif
@@ skipping 77 matching lines @@
   pageDump->AddScalar("live_count", "objects", liveCount);
   pageDump->AddScalar("dead_count", "objects", deadCount);
   pageDump->AddScalar("free_count", "objects", freeCount);
   pageDump->AddScalar("live_size", "bytes", liveSize);
   pageDump->AddScalar("dead_size", "bytes", deadSize);
   pageDump->AddScalar("free_size", "bytes", freeSize);
   heapInfo.freeSize += freeSize;
   heapInfo.freeCount += freeCount;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool NormalPage::contains(Address addr) {
   Address blinkPageStart = roundToBlinkPageStart(getAddress());
   // Page is at aligned address plus guard page size.
   ASSERT(blinkPageStart == getAddress() - blinkGuardPageSize);
   return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
 }
 #endif
 
 LargeObjectPage::LargeObjectPage(PageMemory* storage,
                                  BaseArena* arena,
@@ skipping 86 matching lines @@
     info.deadCount[gcInfoIndex]++;
     info.deadSize[gcInfoIndex] += payloadSize;
   }
 
   pageDump->AddScalar("live_count", "objects", liveCount);
   pageDump->AddScalar("dead_count", "objects", deadCount);
   pageDump->AddScalar("live_size", "bytes", liveSize);
   pageDump->AddScalar("dead_size", "bytes", deadSize);
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool LargeObjectPage::contains(Address object) {
   return roundToBlinkPageStart(getAddress()) <= object &&
          object < roundToBlinkPageEnd(getAddress() + size());
 }
 #endif
 
 void HeapDoesNotContainCache::flush() {
   if (m_hasEntries) {
     for (int i = 0; i < numberOfEntries; ++i)
       m_entries[i] = nullptr;
@@ skipping 27 matching lines @@
 
   m_hasEntries = true;
   size_t index = hash(address);
   ASSERT(!(index & 1));
   Address cachePage = roundToBlinkPageStart(address);
   m_entries[index + 1] = m_entries[index];
   m_entries[index] = cachePage;
 }
 
 }  // namespace blink