Replace ASSERTs in platform/heap/ with DCHECKs

third_party/WebKit/Source/platform/heap/ThreadState.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 159 matching lines @@
       m_invalidateDeadObjectsInWrappersMarkingDeque(nullptr),
 #if defined(ADDRESS_SANITIZER)
       m_asanFakeStack(__asan_get_current_fake_stack()),
 #endif
 #if defined(LEAK_SANITIZER)
       m_disabledStaticPersistentsRegistration(0),
 #endif
       m_allocatedObjectSize(0),
       m_markedObjectSize(0),
       m_reportedMemoryToV8(0) {
-  ASSERT(checkThread());
-  ASSERT(!**s_threadSpecific);
+  DCHECK(checkThread());
+  DCHECK(!**s_threadSpecific);
   **s_threadSpecific = this;
 
   switch (m_threadHeapMode) {
     case BlinkGC::MainThreadHeapMode:
       if (isMainThread()) {
         s_mainThreadStackStart =
             reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
         size_t underestimatedStackSize =
             StackFrameDepth::getUnderestimatedStackSize();
         if (underestimatedStackSize > sizeof(void*))
           s_mainThreadUnderestimatedStackSize =
               underestimatedStackSize - sizeof(void*);
         m_heap = new ThreadHeap();
       } else {
         m_heap = &ThreadState::mainThreadState()->heap();
       }
       break;
     case BlinkGC::PerThreadHeapMode:
       m_heap = new ThreadHeap();
       break;
   }
-  ASSERT(m_heap);
+  DCHECK(m_heap);
   m_heap->attach(this);
 
   for (int arenaIndex = 0; arenaIndex < BlinkGC::LargeObjectArenaIndex;
        arenaIndex++)
     m_arenas[arenaIndex] = new NormalPageArena(this, arenaIndex);
   m_arenas[BlinkGC::LargeObjectArenaIndex] =
       new LargeObjectArena(this, BlinkGC::LargeObjectArenaIndex);
 
   m_likelyToBePromptlyFreed =
       wrapArrayUnique(new int[likelyToBePromptlyFreedArraySize]);
   clearArenaAges();
 }
 
 ThreadState::~ThreadState() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     delete m_arenas[i];
 
   **s_threadSpecific = nullptr;
   if (isMainThread()) {
     s_mainThreadStackStart = 0;
     s_mainThreadUnderestimatedStackSize = 0;
   }
 }
 
 #if OS(WIN) && COMPILER(MSVC)
 size_t ThreadState::threadStackSize() {
   if (m_threadStackSize)
     return m_threadStackSize;
 
   // Notice that we cannot use the TIB's StackLimit for the stack end, as it
   // tracks the end of the committed range. We're after the end of the reserved
   // stack area (most of which will be uncommitted, most times.)
   MEMORY_BASIC_INFORMATION stackInfo;
   memset(&stackInfo, 0, sizeof(MEMORY_BASIC_INFORMATION));
   size_t resultSize =
       VirtualQuery(&stackInfo, &stackInfo, sizeof(MEMORY_BASIC_INFORMATION));
   DCHECK_GE(resultSize, sizeof(MEMORY_BASIC_INFORMATION));
   Address stackEnd = reinterpret_cast<Address>(stackInfo.AllocationBase);
 
   Address stackStart =
       reinterpret_cast<Address>(StackFrameDepth::getStackStart());
-  RELEASE_ASSERT(stackStart && stackStart > stackEnd);
+  CHECK(stackStart && stackStart > stackEnd);
   m_threadStackSize = static_cast<size_t>(stackStart - stackEnd);
   // When the third last page of the reserved stack is accessed as a
   // guard page, the second last page will be committed (along with removing
   // the guard bit on the third last) _and_ a stack overflow exception
   // is raised.
   //
   // We have zero interest in running into stack overflow exceptions while
   // marking objects, so simply consider the last three pages + one above
   // as off-limits and adjust the reported stack size accordingly.
   //
   // http://blogs.msdn.com/b/satyem/archive/2012/08/13/thread-s-stack-memory-management.aspx
   // explains the details.
-  RELEASE_ASSERT(m_threadStackSize > 4 * 0x1000);
+  CHECK(m_threadStackSize > 4 * 0x1000);
   m_threadStackSize -= 4 * 0x1000;
   return m_threadStackSize;
 }
 #endif
 
 void ThreadState::attachMainThread() {
-  RELEASE_ASSERT(!ProcessHeap::s_shutdownComplete);
+  CHECK(!ProcessHeap::s_shutdownComplete);
   s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
   new (s_mainThreadStateStorage) ThreadState(BlinkGC::MainThreadHeapMode);
 }
 
 void ThreadState::attachCurrentThread(BlinkGC::ThreadHeapMode threadHeapMode) {
-  RELEASE_ASSERT(!ProcessHeap::s_shutdownComplete);
+  CHECK(!ProcessHeap::s_shutdownComplete);
   new ThreadState(threadHeapMode);
 }
 
 void ThreadState::cleanupPages() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     m_arenas[i]->cleanupPages();
 }
 
 void ThreadState::runTerminationGC() {
   if (isMainThread()) {
     cleanupPages();
     return;
   }
-  ASSERT(checkThread());
+  DCHECK(checkThread());
 
   // Finish sweeping.
   completeSweep();
 
   releaseStaticPersistentNodes();
 
   // From here on ignore all conservatively discovered
   // pointers into the heap owned by this thread.
   m_isTerminating = true;
 
   // Set the terminate flag on all heap pages of this thread. This is used to
   // ensure we don't trace pages on other threads that are not part of the
   // thread local GC.
   prepareForThreadStateTermination();
 
   ProcessHeap::crossThreadPersistentRegion().prepareForThreadStateTermination(
       this);
 
   // Do thread local GC's as long as the count of thread local Persistents
   // changes and is above zero.
   int oldCount = -1;
   int currentCount = getPersistentRegion()->numberOfPersistents();
-  ASSERT(currentCount >= 0);
+  DCHECK_GE(currentCount, 0);
   while (currentCount != oldCount) {
     collectGarbageForTerminatingThread();
     // Release the thread-local static persistents that were
     // instantiated while running the termination GC.
     releaseStaticPersistentNodes();
     oldCount = currentCount;
     currentCount = getPersistentRegion()->numberOfPersistents();
   }
   // We should not have any persistents left when getting to this point,
-  // if we have it is probably a bug so adding a debug ASSERT to catch this.
-  ASSERT(!currentCount);
+  // if we have it is probably a bug so adding a debug DCHECK to catch this.
+  DCHECK(!currentCount);
   // All of pre-finalizers should be consumed.
-  ASSERT(m_orderedPreFinalizers.isEmpty());
-  RELEASE_ASSERT(gcState() == NoGCScheduled);
+  DCHECK(m_orderedPreFinalizers.isEmpty());
+  CHECK(gcState() == NoGCScheduled);
 
   // Add pages to the orphaned page pool to ensure any global GCs from this
   // point on will not trace objects on this thread's arenas.
   cleanupPages();
 }
 
 void ThreadState::cleanupMainThread() {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
 
   releaseStaticPersistentNodes();
 
   // Finish sweeping before shutting down V8. Otherwise, some destructor
   // may access V8 and cause crashes.
   completeSweep();
 
   // It is unsafe to trigger GCs after this point because some
   // destructor may access already-detached V8 and cause crashes.
   // Also it is useless. So we forbid GCs.
   enterGCForbiddenScope();
 }
 
 void ThreadState::detachMainThread() {
   // Enter a safe point before trying to acquire threadAttachMutex
   // to avoid dead lock if another thread is preparing for GC, has acquired
   // threadAttachMutex and waiting for other threads to pause or reach a
   // safepoint.
   ThreadState* state = mainThreadState();
-  ASSERT(!state->isSweepingInProgress());
+  DCHECK(!state->isSweepingInProgress());
 
   state->heap().detach(state);
   state->~ThreadState();
 }
 
 void ThreadState::detachCurrentThread() {
   ThreadState* state = current();
   state->heap().detach(state);
-  RELEASE_ASSERT(state->gcState() == ThreadState::NoGCScheduled);
+  CHECK(state->gcState() == ThreadState::NoGCScheduled);
   delete state;
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr) {
 #if defined(ADDRESS_SANITIZER)
   Address* start = reinterpret_cast<Address*>(m_startOfStack);
   Address* end = reinterpret_cast<Address*>(m_endOfStack);
   Address* fakeFrameStart = nullptr;
   Address* fakeFrameEnd = nullptr;
@@ skipping 77 matching lines @@
       liveSize(Vector<size_t>(numObjectTypes)),
       deadSize(Vector<size_t>(numObjectTypes)) {}
 
 void ThreadState::pushThreadLocalWeakCallback(void* object,
                                               WeakCallback callback) {
   CallbackStack::Item* slot = m_threadLocalWeakCallbackStack->allocateEntry();
   *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadState::popAndInvokeThreadLocalWeakCallback(Visitor* visitor) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   // For weak processing we should never reach orphaned pages since orphaned
   // pages are not traced and thus objects on those pages are never be
   // registered as objects on orphaned pages. We cannot assert this here since
   // we might have an off-heap collection. We assert it in
   // ThreadHeap::pushThreadLocalWeakCallback.
   if (CallbackStack::Item* item = m_threadLocalWeakCallbackStack->pop()) {
     item->call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadState::threadLocalWeakProcessing() {
-  ASSERT(checkThread());
-  ASSERT(!sweepForbidden());
+  DCHECK(checkThread());
+  DCHECK(!sweepForbidden());
   TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
   double startTime = WTF::currentTimeMS();
 
   SweepForbiddenScope sweepForbiddenScope(this);
   ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
   // Disallow allocation during weak processing.
   // It would be technically safe to allow allocations, but it is unsafe
   // to mutate an object graph in a way in which a dead object gets
   // resurrected or mutate a HashTable (because HashTable's weak processing
@@ skipping 129 matching lines @@
 
 // If we're consuming too much memory, trigger a conservative GC
 // aggressively. This is a safe guard to avoid OOM.
 bool ThreadState::shouldForceMemoryPressureGC() {
   if (totalMemorySize() < 300 * 1024 * 1024)
     return false;
   return judgeGCThreshold(0, 0, 1.5);
 }
 
 void ThreadState::scheduleV8FollowupGCIfNeeded(BlinkGC::V8GCType gcType) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   ThreadHeap::reportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
   dataLogF("ThreadState::scheduleV8FollowupGCIfNeeded (gcType=%s)\n",
            gcType == BlinkGC::V8MajorGC ? "MajorGC" : "MinorGC");
 #endif
 
   if (isGCForbidden())
     return;
 
   // This completeSweep() will do nothing in common cases since we've
   // called completeSweep() before V8 starts minor/major GCs.
   completeSweep();
-  ASSERT(!isSweepingInProgress());
-  ASSERT(!sweepForbidden());
+  DCHECK(!isSweepingInProgress());
+  DCHECK(!sweepForbidden());
 
   if ((gcType == BlinkGC::V8MajorGC && shouldForceMemoryPressureGC()) ||
       shouldScheduleV8FollowupGC()) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled PreciseGC\n");
 #endif
     schedulePreciseGC();
     return;
   }
   if (gcType == BlinkGC::V8MajorGC && shouldScheduleIdleGC()) {
@@ skipping 12 matching lines @@
   // TODO(haraken): It's a bit too late for a major GC to schedule
   // completeSweep() here, because gcPrologue for a major GC is called
   // not at the point where the major GC started but at the point where
   // the major GC requests object grouping.
   if (gcType == BlinkGC::V8MajorGC)
     completeSweep();
 }
 
 void ThreadState::schedulePageNavigationGCIfNeeded(
     float estimatedRemovalRatio) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   ThreadHeap::reportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
   dataLogF(
       "ThreadState::schedulePageNavigationGCIfNeeded "
       "(estimatedRemovalRatio=%.2lf)\n",
       estimatedRemovalRatio);
 #endif
 
   if (isGCForbidden())
     return;
 
   // Finish on-going lazy sweeping.
   // TODO(haraken): It might not make sense to force completeSweep() for all
   // page navigations.
   completeSweep();
-  ASSERT(!isSweepingInProgress());
-  ASSERT(!sweepForbidden());
+  DCHECK(!isSweepingInProgress());
+  DCHECK(!sweepForbidden());
 
   if (shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled MemoryPressureGC\n");
 #endif
     collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep,
                    BlinkGC::MemoryPressureGC);
     return;
   }
   if (shouldSchedulePageNavigationGC(estimatedRemovalRatio)) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled PageNavigationGC\n");
 #endif
     schedulePageNavigationGC();
   }
 }
 
 void ThreadState::schedulePageNavigationGC() {
-  ASSERT(checkThread());
-  ASSERT(!isSweepingInProgress());
+  DCHECK(checkThread());
+  DCHECK(!isSweepingInProgress());
   setGCState(PageNavigationGCScheduled);
 }
 
 void ThreadState::scheduleGCIfNeeded() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   ThreadHeap::reportMemoryUsageForTracing();
 
 #if PRINT_HEAP_STATS
   dataLogF("ThreadState::scheduleGCIfNeeded\n");
 #endif
 
   // Allocation is allowed during sweeping, but those allocations should not
   // trigger nested GCs.
   if (isGCForbidden())
     return;
 
   if (isSweepingInProgress())
     return;
-  ASSERT(!sweepForbidden());
+  DCHECK(!sweepForbidden());
 
   reportMemoryToV8();
 
   if (shouldForceMemoryPressureGC()) {
     completeSweep();
     if (shouldForceMemoryPressureGC()) {
 #if PRINT_HEAP_STATS
       dataLogF("Scheduled MemoryPressureGC\n");
 #endif
       collectGarbage(BlinkGC::HeapPointersOnStack, BlinkGC::GCWithoutSweep,
@@ skipping 16 matching lines @@
   if (shouldScheduleIdleGC()) {
 #if PRINT_HEAP_STATS
     dataLogF("Scheduled IdleGC\n");
 #endif
     scheduleIdleGC();
     return;
   }
 }
 
 ThreadState* ThreadState::fromObject(const void* object) {
-  ASSERT(object);
+  DCHECK(object);
   BasePage* page = pageFromObject(object);
-  ASSERT(page);
-  ASSERT(page->arena());
+  DCHECK(page);
+  DCHECK(page->arena());
   return page->arena()->getThreadState();
 }
 
 void ThreadState::performIdleGC(double deadlineSeconds) {
-  ASSERT(checkThread());
-  ASSERT(isMainThread());
-  ASSERT(Platform::current()->currentThread()->scheduler());
+  DCHECK(checkThread());
+  DCHECK(isMainThread());
+  DCHECK(Platform::current()->currentThread()->scheduler());
 
   if (gcState() != IdleGCScheduled)
     return;
 
   if (isGCForbidden()) {
     // If GC is forbidden at this point, try again.
     scheduleIdleGC();
     return;
   }
 
@@ skipping 10 matching lines @@
   }
 
   TRACE_EVENT2("blink_gc", "ThreadState::performIdleGC", "idleDeltaInSeconds",
                idleDeltaInSeconds, "estimatedMarkingTime",
                m_heap->heapStats().estimatedMarkingTime());
   collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithoutSweep,
                  BlinkGC::IdleGC);
 }
 
 void ThreadState::performIdleLazySweep(double deadlineSeconds) {
-  ASSERT(checkThread());
-  ASSERT(isMainThread());
+  DCHECK(checkThread());
+  DCHECK(isMainThread());
 
   // If we are not in a sweeping phase, there is nothing to do here.
   if (!isSweepingInProgress())
     return;
 
   // This check is here to prevent performIdleLazySweep() from being called
   // recursively. I'm not sure if it can happen but it would be safer to have
   // the check just in case.
   if (sweepForbidden())
     return;
@@ skipping 59 matching lines @@
   // Some threads (e.g. PPAPI thread) don't have a scheduler.
   if (!Platform::current()->currentThread()->scheduler())
     return;
 
   Platform::current()->currentThread()->scheduler()->postIdleTask(
       BLINK_FROM_HERE,
       WTF::bind(&ThreadState::performIdleLazySweep, WTF::unretained(this)));
 }
 
 void ThreadState::schedulePreciseGC() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   if (isSweepingInProgress()) {
     setGCState(SweepingAndPreciseGCScheduled);
     return;
   }
 
   setGCState(PreciseGCScheduled);
 }
 
 namespace {
 
 #define UNEXPECTED_GCSTATE(s)                                   \
   case ThreadState::s:                                          \
     LOG(FATAL) << "Unexpected transition while in GCState " #s; \
     return
 
 void unexpectedGCState(ThreadState::GCState gcState) {
   switch (gcState) {
     UNEXPECTED_GCSTATE(NoGCScheduled);
     UNEXPECTED_GCSTATE(IdleGCScheduled);
     UNEXPECTED_GCSTATE(PreciseGCScheduled);
     UNEXPECTED_GCSTATE(FullGCScheduled);
     UNEXPECTED_GCSTATE(GCRunning);
     UNEXPECTED_GCSTATE(EagerSweepScheduled);
     UNEXPECTED_GCSTATE(LazySweepScheduled);
     UNEXPECTED_GCSTATE(Sweeping);
     UNEXPECTED_GCSTATE(SweepingAndIdleGCScheduled);
     UNEXPECTED_GCSTATE(SweepingAndPreciseGCScheduled);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return;
   }
 }
 
 #undef UNEXPECTED_GCSTATE
 
 }  // namespace
 
 #define VERIFY_STATE_TRANSITION(condition) \
-  if (UNLIKELY(!(condition)))              \
-  unexpectedGCState(m_gcState)
+  if (UNLIKELY(!(condition))) {            \
+    unexpectedGCState(m_gcState);          \
+  }
 
 void ThreadState::setGCState(GCState gcState) {
   switch (gcState) {
     case NoGCScheduled:
-      ASSERT(checkThread());
+      DCHECK(checkThread());
       VERIFY_STATE_TRANSITION(m_gcState == Sweeping ||
                               m_gcState == SweepingAndIdleGCScheduled);
       break;
     case IdleGCScheduled:
     case PreciseGCScheduled:
     case FullGCScheduled:
     case PageNavigationGCScheduled:
-      ASSERT(checkThread());
+      DCHECK(checkThread());
       VERIFY_STATE_TRANSITION(
           m_gcState == NoGCScheduled || m_gcState == IdleGCScheduled ||
           m_gcState == PreciseGCScheduled || m_gcState == FullGCScheduled ||
           m_gcState == PageNavigationGCScheduled || m_gcState == Sweeping ||
           m_gcState == SweepingAndIdleGCScheduled ||
           m_gcState == SweepingAndPreciseGCScheduled);
       completeSweep();
       break;
     case GCRunning:
-      ASSERT(!isInGC());
+      DCHECK(!isInGC());
       VERIFY_STATE_TRANSITION(m_gcState != GCRunning);
       break;
     case EagerSweepScheduled:
     case LazySweepScheduled:
-      ASSERT(isInGC());
+      DCHECK(isInGC());
       VERIFY_STATE_TRANSITION(m_gcState == GCRunning);
       break;
     case Sweeping:
-      ASSERT(checkThread());
+      DCHECK(checkThread());
       VERIFY_STATE_TRANSITION(m_gcState == EagerSweepScheduled ||
                               m_gcState == LazySweepScheduled);
       break;
     case SweepingAndIdleGCScheduled:
     case SweepingAndPreciseGCScheduled:
-      ASSERT(checkThread());
+      DCHECK(checkThread());
       VERIFY_STATE_TRANSITION(m_gcState == Sweeping ||
                               m_gcState == SweepingAndIdleGCScheduled ||
                               m_gcState == SweepingAndPreciseGCScheduled);
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
   m_gcState = gcState;
 }
 
 #undef VERIFY_STATE_TRANSITION
 
 void ThreadState::runScheduledGC(BlinkGC::StackState stackState) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   if (stackState != BlinkGC::NoHeapPointersOnStack)
     return;
 
   // If a safe point is entered while initiating a GC, we clearly do
   // not want to do another as part of that -- the safe point is only
   // entered after checking if a scheduled GC ought to run first.
   // Prevent that from happening by marking GCs as forbidden while
   // one is initiated and later running.
   if (isGCForbidden())
     return;
@@ skipping 19 matching lines @@
 }
 
 void ThreadState::flushHeapDoesNotContainCacheIfNeeded() {
   if (m_shouldFlushHeapDoesNotContainCache) {
     m_heap->flushHeapDoesNotContainCache();
     m_shouldFlushHeapDoesNotContainCache = false;
   }
 }
 
 void ThreadState::makeConsistentForGC() {
-  ASSERT(isInGC());
+  DCHECK(isInGC());
   TRACE_EVENT0("blink_gc", "ThreadState::makeConsistentForGC");
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     m_arenas[i]->makeConsistentForGC();
 }
 
 void ThreadState::compact() {
   if (!heap().compaction()->isCompacting())
     return;
 
   SweepForbiddenScope scope(this);
@@ skipping 14 matching lines @@
   // TODO: implement bail out wrt any overall deadline, not compacting
   // the remaining arenas if the time budget has been exceeded.
   heap().compaction()->startThreadCompaction();
   for (int i = BlinkGC::HashTableArenaIndex; i >= BlinkGC::Vector1ArenaIndex;
        --i)
     static_cast<NormalPageArena*>(m_arenas[i])->sweepAndCompact();
   heap().compaction()->finishThreadCompaction();
 }
 
 void ThreadState::makeConsistentForMutator() {
-  ASSERT(isInGC());
+  DCHECK(isInGC());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     m_arenas[i]->makeConsistentForMutator();
 }
 
 void ThreadState::preGC() {
   if (RuntimeEnabledFeatures::traceWrappablesEnabled() && m_isolate &&
       m_performCleanup)
     m_performCleanup(m_isolate);
 
-  ASSERT(!isInGC());
+  DCHECK(!isInGC());
   setGCState(GCRunning);
   makeConsistentForGC();
   flushHeapDoesNotContainCacheIfNeeded();
   clearArenaAges();
 
   // It is possible, albeit rare, for a thread to be kept
   // at a safepoint across multiple GCs, as resuming all attached
   // threads after the "global" GC phases will contend for the shared
   // safepoint barrier mutexes etc, which can additionally delay
   // a thread. Enough so that another thread may initiate
   // a new GC before this has happened.
   //
   // In which case the parked thread's ThreadState will have unprocessed
   // entries on its local weak callback stack when that later GC goes
   // ahead. Clear out and invalidate the stack now, as the thread
   // should only process callbacks that's found to be reachable by
   // the latest GC, when it eventually gets to next perform
   // thread-local weak processing.
   m_threadLocalWeakCallbackStack->decommit();
   m_threadLocalWeakCallbackStack->commit();
 }
 
 void ThreadState::postGC(BlinkGC::GCType gcType) {
   if (RuntimeEnabledFeatures::traceWrappablesEnabled() &&
       m_invalidateDeadObjectsInWrappersMarkingDeque) {
     m_invalidateDeadObjectsInWrappersMarkingDeque(m_isolate);
   }
 
-  ASSERT(isInGC());
+  DCHECK(isInGC());
   for (int i = 0; i < BlinkGC::NumberOfArenas; i++)
     m_arenas[i]->prepareForSweep();
 
   if (gcType == BlinkGC::GCWithSweep) {
     setGCState(EagerSweepScheduled);
   } else if (gcType == BlinkGC::GCWithoutSweep) {
     setGCState(LazySweepScheduled);
   } else {
     takeSnapshot(SnapshotType::HeapSnapshot);
 
     // This unmarks all marked objects and marks all unmarked objects dead.
     makeConsistentForMutator();
 
     takeSnapshot(SnapshotType::FreelistSnapshot);
 
     // Force setting NoGCScheduled to circumvent checkThread()
     // in setGCState().
     m_gcState = NoGCScheduled;
   }
 }
 
 void ThreadState::preSweep() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   if (gcState() != EagerSweepScheduled && gcState() != LazySweepScheduled)
     return;
 
   threadLocalWeakProcessing();
 
   GCState previousGCState = gcState();
   // We have to set the GCState to Sweeping before calling pre-finalizers
   // to disallow a GC during the pre-finalizers.
   setGCState(Sweeping);
 
@@ skipping 49 matching lines @@
   // threads (e.g. in CrossThreadPersistentRegion::shouldTracePersistent) and
   // that would be fine.
   ProcessHeap::crossThreadPersistentRegion().unpoisonCrossThreadPersistents();
 }
 #endif
 
 void ThreadState::eagerSweep() {
 #if defined(ADDRESS_SANITIZER)
   poisonEagerArena();
 #endif
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   // Some objects need to be finalized promptly and cannot be handled
   // by lazy sweeping. Keep those in a designated heap and sweep it
   // eagerly.
-  ASSERT(isSweepingInProgress());
+  DCHECK(isSweepingInProgress());
 
   // Mirroring the completeSweep() condition; see its comment.
   if (sweepForbidden())
     return;
 
   SweepForbiddenScope scope(this);
   ScriptForbiddenIfMainThreadScope scriptForbiddenScope;
 
   double startTime = WTF::currentTimeMS();
   m_arenas[BlinkGC::EagerSweepArenaIndex]->completeSweep();
   accumulateSweepingTime(WTF::currentTimeMS() - startTime);
 }
 
 void ThreadState::completeSweep() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   // If we are not in a sweeping phase, there is nothing to do here.
   if (!isSweepingInProgress())
     return;
 
   // completeSweep() can be called recursively if finalizers can allocate
   // memory and the allocation triggers completeSweep(). This check prevents
   // the sweeping from being executed recursively.
   if (sweepForbidden())
     return;
 
@@ skipping 16 matching lines @@
       DEFINE_STATIC_LOCAL(CustomCountHistogram, completeSweepHistogram,
                           ("BlinkGC.CompleteSweep", 1, 10 * 1000, 50));
       completeSweepHistogram.count(timeForCompleteSweep);
     }
   }
 
   postSweep();
 }
 
 void ThreadState::postSweep() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   ThreadHeap::reportMemoryUsageForTracing();
 
   if (isMainThread()) {
     double collectionRate = 0;
     if (m_heap->heapStats().objectSizeAtLastGC() > 0)
       collectionRate = 1 -
                        1.0 * m_heap->heapStats().markedObjectSize() /
                            m_heap->heapStats().objectSizeAtLastGC();
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink_gc"),
                    "ThreadState::collectionRate",
@@ skipping 50 matching lines @@
       setGCState(NoGCScheduled);
       break;
     case SweepingAndPreciseGCScheduled:
       setGCState(PreciseGCScheduled);
       break;
     case SweepingAndIdleGCScheduled:
       setGCState(NoGCScheduled);
       scheduleIdleGC();
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 void ThreadState::prepareForThreadStateTermination() {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     m_arenas[i]->prepareHeapForTermination();
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 BasePage* ThreadState::findPageFromAddress(Address address) {
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i) {
     if (BasePage* page = m_arenas[i]->findPageFromAddress(address))
       return page;
   }
   return nullptr;
 }
 #endif
 
 size_t ThreadState::objectPayloadSizeForTesting() {
   size_t objectPayloadSize = 0;
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     objectPayloadSize += m_arenas[i]->objectPayloadSizeForTesting();
   return objectPayloadSize;
 }
 
 void ThreadState::safePoint(BlinkGC::StackState stackState) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   ThreadHeap::reportMemoryUsageForTracing();
 
   runScheduledGC(stackState);
-  ASSERT(!m_atSafePoint);
+  DCHECK(!m_atSafePoint);
   m_stackState = stackState;
   m_atSafePoint = true;
   m_heap->checkAndPark(this, nullptr);
   m_atSafePoint = false;
   m_stackState = BlinkGC::HeapPointersOnStack;
   preSweep();
 }
 
 #ifdef ADDRESS_SANITIZER
 // When we are running under AddressSanitizer with
 // detect_stack_use_after_return=1 then stack marker obtained from
 // SafePointScope will point into a fake stack.  Detect this case by checking if
 // it falls in between current stack frame and stack start and use an arbitrary
 // high enough value for it.  Don't adjust stack marker in any other case to
 // match behavior of code running without AddressSanitizer.
 NO_SANITIZE_ADDRESS static void* adjustScopeMarkerForAdressSanitizer(
     void* scopeMarker) {
   Address start = reinterpret_cast<Address>(StackFrameDepth::getStackStart());
   Address end = reinterpret_cast<Address>(&start);
-  RELEASE_ASSERT(end < start);
+  CHECK(end < start);
 
   if (end <= scopeMarker && scopeMarker < start)
     return scopeMarker;
 
   // 256 is as good an approximation as any else.
   const size_t bytesToCopy = sizeof(Address) * 256;
   if (static_cast<size_t>(start - end) < bytesToCopy)
     return start;
 
   return end + bytesToCopy;
 }
 #endif
 
 void ThreadState::enterSafePoint(BlinkGC::StackState stackState,
                                  void* scopeMarker) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
 #ifdef ADDRESS_SANITIZER
   if (stackState == BlinkGC::HeapPointersOnStack)
     scopeMarker = adjustScopeMarkerForAdressSanitizer(scopeMarker);
 #endif
-  ASSERT(stackState == BlinkGC::NoHeapPointersOnStack || scopeMarker);
+  DCHECK(stackState == BlinkGC::NoHeapPointersOnStack || scopeMarker);
   runScheduledGC(stackState);
-  ASSERT(!m_atSafePoint);
+  DCHECK(!m_atSafePoint);
   m_atSafePoint = true;
   m_stackState = stackState;
   m_safePointScopeMarker = scopeMarker;
   m_heap->enterSafePoint(this);
 }
 
 void ThreadState::leaveSafePoint(SafePointAwareMutexLocker* locker) {
-  ASSERT(checkThread());
-  ASSERT(m_atSafePoint);
+  DCHECK(checkThread());
+  DCHECK(m_atSafePoint);
   m_heap->leaveSafePoint(this, locker);
   m_atSafePoint = false;
   m_stackState = BlinkGC::HeapPointersOnStack;
   clearSafePointScopeMarker();
   preSweep();
 }
 
 void ThreadState::reportMemoryToV8() {
   if (!m_isolate)
     return;
@@ skipping 24 matching lines @@
   m_markedObjectSize += delta;
   m_heap->heapStats().increaseMarkedObjectSize(delta);
 }
 
 void ThreadState::copyStackUntilSafePointScope() {
   if (!m_safePointScopeMarker || m_stackState == BlinkGC::NoHeapPointersOnStack)
     return;
 
   Address* to = reinterpret_cast<Address*>(m_safePointScopeMarker);
   Address* from = reinterpret_cast<Address*>(m_endOfStack);
-  RELEASE_ASSERT(from < to);
-  RELEASE_ASSERT(to <= reinterpret_cast<Address*>(m_startOfStack));
+  CHECK(from < to);
+  CHECK(to <= reinterpret_cast<Address*>(m_startOfStack));
   size_t slotCount = static_cast<size_t>(to - from);
 // Catch potential performance issues.
 #if defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
   // ASan/LSan use more space on the stack and we therefore
   // increase the allowed stack copying for those builds.
-  ASSERT(slotCount < 2048);
+  DCHECK_LT(slotCount, 2048UL);
 #else
-  ASSERT(slotCount < 1024);
+  DCHECK_LT(slotCount, 1024UL);
 #endif
 
-  ASSERT(!m_safePointStackCopy.size());
+  DCHECK(!m_safePointStackCopy.size());
   m_safePointStackCopy.resize(slotCount);
   for (size_t i = 0; i < slotCount; ++i) {
     m_safePointStackCopy[i] = from[i];
   }
 }
 
 void ThreadState::addInterruptor(
     std::unique_ptr<BlinkGCInterruptor> interruptor) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   SafePointScope scope(BlinkGC::HeapPointersOnStack);
   {
     MutexLocker locker(m_heap->threadAttachMutex());
     m_interruptors.append(std::move(interruptor));
   }
 }
 
 void ThreadState::registerStaticPersistentNode(
     PersistentNode* node,
     PersistentClearCallback callback) {
 #if defined(LEAK_SANITIZER)
   if (m_disabledStaticPersistentsRegistration)
     return;
 #endif
 
-  ASSERT(!m_staticPersistents.contains(node));
+  DCHECK(!m_staticPersistents.contains(node));
   m_staticPersistents.add(node, callback);
 }
 
 void ThreadState::releaseStaticPersistentNodes() {
   HashMap<PersistentNode*, ThreadState::PersistentClearCallback>
       staticPersistents;
   staticPersistents.swap(m_staticPersistents);
 
   PersistentRegion* persistentRegion = getPersistentRegion();
   for (const auto& it : staticPersistents)
     persistentRegion->releasePersistentNode(it.key, it.value);
 }
 
 void ThreadState::freePersistentNode(PersistentNode* persistentNode) {
   PersistentRegion* persistentRegion = getPersistentRegion();
   persistentRegion->freePersistentNode(persistentNode);
   // Do not allow static persistents to be freed before
   // they're all released in releaseStaticPersistentNodes().
   //
   // There's no fundamental reason why this couldn't be supported,
   // but no known use for it.
-  ASSERT(!m_staticPersistents.contains(persistentNode));
+  DCHECK(!m_staticPersistents.contains(persistentNode));
 }
 
 #if defined(LEAK_SANITIZER)
 void ThreadState::enterStaticReferenceRegistrationDisabledScope() {
   m_disabledStaticPersistentsRegistration++;
 }
 
 void ThreadState::leaveStaticReferenceRegistrationDisabledScope() {
-  ASSERT(m_disabledStaticPersistentsRegistration);
+  DCHECK(m_disabledStaticPersistentsRegistration);
   m_disabledStaticPersistentsRegistration--;
 }
 #endif
 
 void ThreadState::lockThreadAttachMutex() {
   m_heap->threadAttachMutex().lock();
 }
 
 void ThreadState::unlockThreadAttachMutex() {
   m_heap->threadAttachMutex().unlock();
 }
 
 void ThreadState::invokePreFinalizers() {
-  ASSERT(checkThread());
-  ASSERT(!sweepForbidden());
+  DCHECK(checkThread());
+  DCHECK(!sweepForbidden());
   TRACE_EVENT0("blink_gc", "ThreadState::invokePreFinalizers");
 
   double startTime = WTF::currentTimeMS();
   if (!m_orderedPreFinalizers.isEmpty()) {
     SweepForbiddenScope sweepForbidden(this);
     ScriptForbiddenIfMainThreadScope scriptForbidden;
 
     // Call the prefinalizers in the opposite order to their registration.
     //
     // The prefinalizer callback wrapper returns |true| when its associated
@@ skipping 32 matching lines @@
     int endArenaIndex) {
   size_t minArenaAge = m_arenaAges[beginArenaIndex];
   int arenaIndexWithMinArenaAge = beginArenaIndex;
   for (int arenaIndex = beginArenaIndex + 1; arenaIndex <= endArenaIndex;
        arenaIndex++) {
     if (m_arenaAges[arenaIndex] < minArenaAge) {
       minArenaAge = m_arenaAges[arenaIndex];
       arenaIndexWithMinArenaAge = arenaIndex;
     }
   }
-  ASSERT(isVectorArenaIndex(arenaIndexWithMinArenaAge));
+  DCHECK(isVectorArenaIndex(arenaIndexWithMinArenaAge));
   return arenaIndexWithMinArenaAge;
 }
 
 BaseArena* ThreadState::expandedVectorBackingArena(size_t gcInfoIndex) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
   --m_likelyToBePromptlyFreed[entryIndex];
   int arenaIndex = m_vectorBackingArenaIndex;
   m_arenaAges[arenaIndex] = ++m_currentArenaAges;
   m_vectorBackingArenaIndex = arenaIndexOfVectorArenaLeastRecentlyExpanded(
       BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
   return m_arenas[arenaIndex];
 }
 
 void ThreadState::allocationPointAdjusted(int arenaIndex) {
   m_arenaAges[arenaIndex] = ++m_currentArenaAges;
   if (m_vectorBackingArenaIndex == arenaIndex)
     m_vectorBackingArenaIndex = arenaIndexOfVectorArenaLeastRecentlyExpanded(
         BlinkGC::Vector1ArenaIndex, BlinkGC::Vector4ArenaIndex);
 }
 
 void ThreadState::promptlyFreed(size_t gcInfoIndex) {
-  ASSERT(checkThread());
+  DCHECK(checkThread());
   size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
   // See the comment in vectorBackingArena() for why this is +3.
   m_likelyToBePromptlyFreed[entryIndex] += 3;
 }
 
 void ThreadState::takeSnapshot(SnapshotType type) {
-  ASSERT(isInGC());
+  DCHECK(isInGC());
 
   // 0 is used as index for freelist entries. Objects are indexed 1 to
   // gcInfoIndex.
   GCSnapshotInfo info(GCInfoTable::gcInfoIndex() + 1);
   String threadDumpName = String::format("blink_gc/thread_%lu",
                                          static_cast<unsigned long>(m_thread));
   const String heapsDumpName = threadDumpName + "/heaps";
   const String classesDumpName = threadDumpName + "/classes";
 
   int numberOfHeapsReported = 0;
 #define SNAPSHOT_HEAP(ArenaType)                                        \
   {                                                                     \
     numberOfHeapsReported++;                                            \
     switch (type) {                                                     \
       case SnapshotType::HeapSnapshot:                                  \
         m_arenas[BlinkGC::ArenaType##ArenaIndex]->takeSnapshot(         \
             heapsDumpName + "/" #ArenaType, info);                      \
         break;                                                          \
       case SnapshotType::FreelistSnapshot:                              \
         m_arenas[BlinkGC::ArenaType##ArenaIndex]->takeFreelistSnapshot( \
             heapsDumpName + "/" #ArenaType);                            \
         break;                                                          \
       default:                                                          \
-        ASSERT_NOT_REACHED();                                           \
+        NOTREACHED();                                                   \
     }                                                                   \
   }
 
   SNAPSHOT_HEAP(NormalPage1);
   SNAPSHOT_HEAP(NormalPage2);
   SNAPSHOT_HEAP(NormalPage3);
   SNAPSHOT_HEAP(NormalPage4);
   SNAPSHOT_HEAP(EagerSweep);
   SNAPSHOT_HEAP(Vector1);
   SNAPSHOT_HEAP(Vector2);
   SNAPSHOT_HEAP(Vector3);
   SNAPSHOT_HEAP(Vector4);
   SNAPSHOT_HEAP(InlineVector);
   SNAPSHOT_HEAP(HashTable);
   SNAPSHOT_HEAP(LargeObject);
   FOR_EACH_TYPED_ARENA(SNAPSHOT_HEAP);
 
-  ASSERT(numberOfHeapsReported == BlinkGC::NumberOfArenas);
+  DCHECK_EQ(numberOfHeapsReported, BlinkGC::NumberOfArenas);
 
 #undef SNAPSHOT_HEAP
 
   if (type == SnapshotType::FreelistSnapshot)
     return;
 
   size_t totalLiveCount = 0;
   size_t totalDeadCount = 0;
   size_t totalLiveSize = 0;
   size_t totalDeadSize = 0;
@@ skipping 21 matching lines @@
           ->createMemoryAllocatorDumpForCurrentGC(classesDumpName);
   BlinkGCMemoryDumpProvider::instance()
       ->currentProcessMemoryDump()
       ->AddOwnershipEdge(classesDump->guid(), heapsDump->guid());
 }
 
 void ThreadState::collectGarbage(BlinkGC::StackState stackState,
                                  BlinkGC::GCType gcType,
                                  BlinkGC::GCReason reason) {
   // Nested collectGarbage() invocations aren't supported.
-  RELEASE_ASSERT(!isGCForbidden());
+  CHECK(!isGCForbidden());
   completeSweep();
 
   GCForbiddenScope gcForbiddenScope(this);
 
   SafePointScope safePointScope(stackState, this);
 
   // Resume all parked threads upon leaving this scope.
   ParkThreadsScope parkThreadsScope(this);
 
   // Try to park the other threads. If we're unable to, bail out of the GC.
@@ skipping 154 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink