Replace ASSERTs in platform/heap/ with DCHECKs

third_party/WebKit/Source/platform/heap/Heap.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 99 matching lines @@
   GCInfoTable::init();
   CallbackStackMemoryPool::instance().initialize();
 }
 
 void ProcessHeap::resetHeapCounters() {
   s_totalAllocatedObjectSize = 0;
   s_totalMarkedObjectSize = 0;
 }
 
 void ProcessHeap::shutdown() {
-  ASSERT(!s_shutdownComplete);
+  DCHECK(!s_shutdownComplete);
 
   {
     // The main thread must be the last thread that gets detached.
     MutexLocker locker(ThreadHeap::allHeapsMutex());
-    RELEASE_ASSERT(ThreadHeap::allHeaps().isEmpty());
+    CHECK(ThreadHeap::allHeaps().isEmpty());
   }
 
   CallbackStackMemoryPool::instance().shutdown();
   GCInfoTable::shutdown();
-  ASSERT(ProcessHeap::totalAllocatedSpace() == 0);
+  DCHECK_EQ(ProcessHeap::totalAllocatedSpace(), 0UL);
   s_shutdownComplete = true;
 }
 
 CrossThreadPersistentRegion& ProcessHeap::crossThreadPersistentRegion() {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(CrossThreadPersistentRegion, persistentRegion,
                                   new CrossThreadPersistentRegion());
   return persistentRegion;
 }
 
 bool ProcessHeap::s_shutdownComplete = false;
@@ skipping 92 matching lines @@
   DEFINE_STATIC_LOCAL(HashSet<ThreadHeap*>, heaps, ());
   return heaps;
 }
 
 void ThreadHeap::attach(ThreadState* thread) {
   MutexLocker locker(m_threadAttachMutex);
   m_threads.add(thread);
 }
 
 void ThreadHeap::detach(ThreadState* thread) {
-  ASSERT(ThreadState::current() == thread);
+  DCHECK_EQ(ThreadState::current(), thread);
   bool isLastThread = false;
   {
     // Grab the threadAttachMutex to ensure only one thread can shutdown at
     // a time and that no other thread can do a global GC. It also allows
     // safe iteration of the m_threads set which happens as part of
     // thread local GC asserts. We enter a safepoint while waiting for the
     // lock to avoid a dead-lock where another thread has already requested
     // GC.
     SafePointAwareMutexLocker locker(m_threadAttachMutex,
                                      BlinkGC::NoHeapPointersOnStack);
     thread->runTerminationGC();
-    ASSERT(m_threads.contains(thread));
+    DCHECK(m_threads.contains(thread));
     m_threads.remove(thread);
     isLastThread = m_threads.isEmpty();
   }
   // The last thread begin detached should be the owning thread, which would
   // be the main thread for the mainThreadHeap and a per thread heap enabled
   // thread otherwise.
   if (isLastThread)
     DCHECK(thread->threadHeapMode() == BlinkGC::PerThreadHeapMode ||
            thread->isMainThread());
   if (thread->isMainThread())
     DCHECK_EQ(heapStats().allocatedSpace(), 0u);
   if (isLastThread)
     delete this;
 }
 
 bool ThreadHeap::park() {
   return m_safePointBarrier->parkOthers();
 }
 
 void ThreadHeap::resume() {
   m_safePointBarrier->resumeOthers();
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 BasePage* ThreadHeap::findPageFromAddress(Address address) {
   MutexLocker locker(m_threadAttachMutex);
   for (ThreadState* state : m_threads) {
     if (BasePage* page = state->findPageFromAddress(address))
       return page;
   }
   return nullptr;
 }
 
 bool ThreadHeap::isAtSafePoint() {
   MutexLocker locker(m_threadAttachMutex);
   for (ThreadState* state : m_threads) {
     if (!state->isAtSafePoint())
       return false;
   }
   return true;
 }
 #endif
 
 Address ThreadHeap::checkAndMarkPointer(Visitor* visitor, Address address) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
-#if !ENABLE(ASSERT)
+#if !DCHECK_IS_ON()
   if (m_heapDoesNotContainCache->lookup(address))
     return nullptr;
 #endif
 
   if (BasePage* page = lookupPageForAddress(address)) {
-    ASSERT(page->contains(address));
-    ASSERT(!page->orphaned());
-    ASSERT(!m_heapDoesNotContainCache->lookup(address));
-    DCHECK(&visitor->heap() == &page->arena()->getThreadState()->heap());
+    DCHECK(page->contains(address));
+    DCHECK(!page->orphaned());
+    DCHECK(!m_heapDoesNotContainCache->lookup(address));
+    DCHECK_EQ(&visitor->heap(), &page->arena()->getThreadState()->heap());
     page->checkAndMarkPointer(visitor, address);
     return address;
   }
 
-#if !ENABLE(ASSERT)
+#if !DCHECK_IS_ON()
   m_heapDoesNotContainCache->addEntry(address);
 #else
   if (!m_heapDoesNotContainCache->lookup(address))
     m_heapDoesNotContainCache->addEntry(address);
 #endif
   return nullptr;
 }
 
 void ThreadHeap::pushTraceCallback(void* object, TraceCallback callback) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
   // Trace should never reach an orphaned page.
-  ASSERT(!getOrphanedPagePool()->contains(object));
+  DCHECK(!getOrphanedPagePool()->contains(object));
   CallbackStack::Item* slot = m_markingStack->allocateEntry();
   *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadHeap::popAndInvokeTraceCallback(Visitor* visitor) {
   CallbackStack::Item* item = m_markingStack->pop();
   if (!item)
     return false;
   item->call(visitor);
   return true;
 }
 
 void ThreadHeap::pushPostMarkingCallback(void* object, TraceCallback callback) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
   // Trace should never reach an orphaned page.
-  ASSERT(!getOrphanedPagePool()->contains(object));
+  DCHECK(!getOrphanedPagePool()->contains(object));
   CallbackStack::Item* slot = m_postMarkingCallbackStack->allocateEntry();
   *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadHeap::popAndInvokePostMarkingCallback(Visitor* visitor) {
   if (CallbackStack::Item* item = m_postMarkingCallbackStack->pop()) {
     item->call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadHeap::pushGlobalWeakCallback(void** cell, WeakCallback callback) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
   // Trace should never reach an orphaned page.
-  ASSERT(!getOrphanedPagePool()->contains(cell));
+  DCHECK(!getOrphanedPagePool()->contains(cell));
   CallbackStack::Item* slot = m_globalWeakCallbackStack->allocateEntry();
   *slot = CallbackStack::Item(cell, callback);
 }
 
 void ThreadHeap::pushThreadLocalWeakCallback(void* closure,
                                              void* object,
                                              WeakCallback callback) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
   // Trace should never reach an orphaned page.
-  ASSERT(!getOrphanedPagePool()->contains(object));
+  DCHECK(!getOrphanedPagePool()->contains(object));
   ThreadState* state = pageFromObject(object)->arena()->getThreadState();
   state->pushThreadLocalWeakCallback(closure, callback);
 }
 
 bool ThreadHeap::popAndInvokeGlobalWeakCallback(Visitor* visitor) {
   if (CallbackStack::Item* item = m_globalWeakCallbackStack->pop()) {
     item->call(visitor);
     return true;
   }
   return false;
 }
 
 void ThreadHeap::registerWeakTable(void* table,
                                    EphemeronCallback iterationCallback,
                                    EphemeronCallback iterationDoneCallback) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
   // Trace should never reach an orphaned page.
-  ASSERT(!getOrphanedPagePool()->contains(table));
+  DCHECK(!getOrphanedPagePool()->contains(table));
   CallbackStack::Item* slot = m_ephemeronStack->allocateEntry();
   *slot = CallbackStack::Item(table, iterationCallback);
 
   // Register a post-marking callback to tell the tables that
   // ephemeron iteration is complete.
   pushPostMarkingCallback(table, iterationDoneCallback);
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool ThreadHeap::weakTableRegistered(const void* table) {
-  ASSERT(m_ephemeronStack);
+  DCHECK(m_ephemeronStack);
   return m_ephemeronStack->hasCallbackForObject(table);
 }
 #endif
 
 void ThreadHeap::commitCallbackStacks() {
   m_markingStack->commit();
   m_postMarkingCallbackStack->commit();
   m_globalWeakCallbackStack->commit();
   m_ephemeronStack->commit();
 }
@@ skipping 18 matching lines @@
 }
 
 void ThreadHeap::decommitCallbackStacks() {
   m_markingStack->decommit();
   m_postMarkingCallbackStack->decommit();
   m_globalWeakCallbackStack->decommit();
   m_ephemeronStack->decommit();
 }
 
 void ThreadHeap::preGC() {
-  ASSERT(!ThreadState::current()->isInGC());
+  DCHECK(!ThreadState::current()->isInGC());
   for (ThreadState* state : m_threads)
     state->preGC();
 }
 
 void ThreadHeap::postGC(BlinkGC::GCType gcType) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
   for (ThreadState* state : m_threads)
     state->postGC(gcType);
 }
 
 void ThreadHeap::processMarkingStack(Visitor* visitor) {
   // Ephemeron fixed point loop.
   do {
     {
       // Iteratively mark all objects that are reachable from the objects
       // currently pushed onto the marking stack.
@@ skipping 19 matching lines @@
   // 1. the ephemeronIterationDone callbacks on weak tables to do cleanup
   //    (specifically to clear the queued bits for weak hash tables), and
   // 2. the markNoTracing callbacks on collection backings to mark them
   //    if they are only reachable from their front objects.
   while (popAndInvokePostMarkingCallback(visitor)) {
   }
 
   // Post-marking callbacks should not trace any objects and
   // therefore the marking stack should be empty after the
   // post-marking callbacks.
-  ASSERT(m_markingStack->isEmpty());
+  DCHECK(m_markingStack->isEmpty());
 }
 
 void ThreadHeap::globalWeakProcessing(Visitor* visitor) {
   TRACE_EVENT0("blink_gc", "ThreadHeap::globalWeakProcessing");
   double startTime = WTF::currentTimeMS();
 
   // Call weak callbacks on objects that may now be pointing to dead objects.
   while (popAndInvokeGlobalWeakCallback(visitor)) {
   }
 
   // It is not permitted to trace pointers of live objects in the weak
   // callback phase, so the marking stack should still be empty here.
-  ASSERT(m_markingStack->isEmpty());
+  DCHECK(m_markingStack->isEmpty());
 
   double timeForGlobalWeakProcessing = WTF::currentTimeMS() - startTime;
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       CustomCountHistogram, globalWeakTimeHistogram,
       new CustomCountHistogram("BlinkGC.TimeForGlobalWeakProcessing", 1,
                                10 * 1000, 50));
   globalWeakTimeHistogram.count(timeForGlobalWeakProcessing);
 }
 
 void ThreadHeap::reportMemoryUsageHistogram() {
@@ skipping 94 matching lines @@
     state->makeConsistentForGC();
     objectPayloadSize += state->objectPayloadSizeForTesting();
     state->setGCState(ThreadState::EagerSweepScheduled);
     state->setGCState(ThreadState::Sweeping);
     state->setGCState(ThreadState::NoGCScheduled);
   }
   return objectPayloadSize;
 }
 
 void ThreadHeap::visitPersistentRoots(Visitor* visitor) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitPersistentRoots");
   ProcessHeap::crossThreadPersistentRegion().tracePersistentNodes(visitor);
 
   for (ThreadState* state : m_threads)
     state->visitPersistents(visitor);
 }
 
 void ThreadHeap::visitStackRoots(Visitor* visitor) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
   TRACE_EVENT0("blink_gc", "ThreadHeap::visitStackRoots");
   for (ThreadState* state : m_threads)
     state->visitStack(visitor);
 }
 
 void ThreadHeap::checkAndPark(ThreadState* threadState,
                               SafePointAwareMutexLocker* locker) {
   m_safePointBarrier->checkAndPark(threadState, locker);
 }
 
 void ThreadHeap::enterSafePoint(ThreadState* threadState) {
   m_safePointBarrier->enterSafePoint(threadState);
 }
 
 void ThreadHeap::leaveSafePoint(ThreadState* threadState,
                                 SafePointAwareMutexLocker* locker) {
   m_safePointBarrier->leaveSafePoint(threadState, locker);
 }
 
 BasePage* ThreadHeap::lookupPageForAddress(Address address) {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
   if (PageMemoryRegion* region = m_regionTree->lookup(address)) {
     BasePage* page = region->pageFromAddress(address);
     return page && !page->orphaned() ? page : nullptr;
   }
   return nullptr;
 }
 
 void ThreadHeap::resetHeapCounters() {
-  ASSERT(ThreadState::current()->isInGC());
+  DCHECK(ThreadState::current()->isInGC());
 
   ThreadHeap::reportMemoryUsageForTracing();
 
   ProcessHeap::decreaseTotalAllocatedObjectSize(m_stats.allocatedObjectSize());
   ProcessHeap::decreaseTotalMarkedObjectSize(m_stats.markedObjectSize());
 
   m_stats.reset();
   for (ThreadState* state : m_threads)
     state->resetHeapCounters();
 }
 
 ThreadHeap* ThreadHeap::s_mainThreadHeap = nullptr;
 
 }  // namespace blink