Replace ASSERTs in platform/heap/ with DCHECKs

third_party/WebKit/Source/platform/heap/PersistentNode.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/PersistentNode.h"
 
 #include "base/debug/alias.h"
 #include "platform/heap/Handle.h"
 
 namespace blink {
@@ skipping 24 matching lines @@
     }
   }
 #if DCHECK_IS_ON()
   DCHECK_EQ(persistentCount, m_persistentCount);
 #endif
   return persistentCount;
 }
 
 void PersistentRegion::ensurePersistentNodeSlots(void* self,
                                                  TraceCallback trace) {
-  ASSERT(!m_freeListHead);
+  DCHECK(!m_freeListHead);
   PersistentNodeSlots* slots = new PersistentNodeSlots;
   for (int i = 0; i < PersistentNodeSlots::slotCount; ++i) {
     PersistentNode* node = &slots->m_slot[i];
     node->setFreeListNext(m_freeListHead);
     m_freeListHead = node;
-    ASSERT(node->isUnused());
+    DCHECK(node->isUnused());
   }
   slots->m_next = m_slots;
   m_slots = slots;
 }
 
 void PersistentRegion::releasePersistentNode(
     PersistentNode* persistentNode,
     ThreadState::PersistentClearCallback callback) {
-  ASSERT(!persistentNode->isUnused());
+  DCHECK(!persistentNode->isUnused());
   // 'self' is in use, containing the persistent wrapper object.
   void* self = persistentNode->self();
   if (callback) {
     (*callback)(self);
-    ASSERT(persistentNode->isUnused());
+    DCHECK(persistentNode->isUnused());
     return;
   }
   Persistent<DummyGCBase>* persistent =
       reinterpret_cast<Persistent<DummyGCBase>*>(self);
   persistent->clear();
-  ASSERT(persistentNode->isUnused());
+  DCHECK(persistentNode->isUnused());
 }
 
 // This function traces all PersistentNodes. If we encounter
 // a PersistentNodeSlot that contains only freed PersistentNodes,
 // we delete the PersistentNodeSlot. This function rebuilds the free
 // list of PersistentNodes.
 void PersistentRegion::tracePersistentNodes(Visitor* visitor,
                                             ShouldTraceCallback shouldTrace) {
   size_t debugMarkedObjectSize = ProcessHeap::totalMarkedObjectSize();
   base::debug::Alias(&debugMarkedObjectSize);
@@ skipping 22 matching lines @@
         debugMarkedObjectSize = ProcessHeap::totalMarkedObjectSize();
       }
     }
     if (freeCount == PersistentNodeSlots::slotCount) {
       PersistentNodeSlots* deadSlots = slots;
       *prevNext = slots->m_next;
       slots = slots->m_next;
       delete deadSlots;
     } else {
       if (freeListLast) {
-        ASSERT(freeListNext);
-        ASSERT(!freeListLast->freeListNext());
+        DCHECK(freeListNext);
+        DCHECK(!freeListLast->freeListNext());
         freeListLast->setFreeListNext(m_freeListHead);
         m_freeListHead = freeListNext;
       }
       prevNext = &slots->m_next;
       slots = slots->m_next;
     }
   }
 #if DCHECK_IS_ON()
   DCHECK_EQ(persistentCount, m_persistentCount);
 #endif
@@ skipping 26 matching lines @@
   while (slots) {
     for (int i = 0; i < PersistentNodeSlots::slotCount; ++i) {
       if (slots->m_slot[i].isUnused())
         continue;
 
       // 'self' is in use, containing the cross-thread persistent wrapper
       // object.
       CrossThreadPersistent<DummyGCBase>* persistent =
           reinterpret_cast<CrossThreadPersistent<DummyGCBase>*>(
               slots->m_slot[i].self());
-      ASSERT(persistent);
+      DCHECK(persistent);
       void* rawObject = persistent->atomicGet();
       if (!rawObject)
         continue;
       BasePage* page = pageFromObject(rawObject);
-      ASSERT(page);
+      DCHECK(page);
       // The main thread will upon detach just mark its heap pages as orphaned,
       // but not invalidate its CrossThreadPersistent<>s.
       if (page->orphaned())
         continue;
       if (page->arena()->getThreadState() == threadState) {
         persistent->clear();
-        ASSERT(slots->m_slot[i].isUnused());
+        DCHECK(slots->m_slot[i].isUnused());
       }
     }
     slots = slots->m_next;
   }
 }
 
 #if defined(ADDRESS_SANITIZER)
 void CrossThreadPersistentRegion::unpoisonCrossThreadPersistents() {
   MutexLocker lock(m_mutex);
   int persistentCount = 0;
   for (PersistentNodeSlots* slots = m_persistentRegion->m_slots; slots;
        slots = slots->m_next) {
     for (int i = 0; i < PersistentNodeSlots::slotCount; ++i) {
       const PersistentNode& node = slots->m_slot[i];
       if (!node.isUnused()) {
         ASAN_UNPOISON_MEMORY_REGION(node.self(),
                                     sizeof(CrossThreadPersistent<void*>));
         ++persistentCount;
       }
     }
   }
 #if DCHECK_IS_ON()
   DCHECK_EQ(persistentCount, m_persistentRegion->m_persistentCount);
 #endif
 }
 #endif
 
 }  // namespace blink