Replace ASSERT with DHCECK_op in platform/heap

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(persistent_count, persistent_count_);
 #endif
   return persistent_count;
 }
 
 void PersistentRegion::EnsurePersistentNodeSlots(void* self,
                                                  TraceCallback trace) {
-  ASSERT(!free_list_head_);
+  DCHECK(!free_list_head_);
   PersistentNodeSlots* slots = new PersistentNodeSlots;
   for (int i = 0; i < PersistentNodeSlots::kSlotCount; ++i) {
     PersistentNode* node = &slots->slot_[i];
     node->SetFreeListNext(free_list_head_);
     free_list_head_ = node;
-    ASSERT(node->IsUnused());
+    DCHECK(node->IsUnused());
   }
   slots->next_ = slots_;
   slots_ = slots;
 }
 
 void PersistentRegion::ReleasePersistentNode(
     PersistentNode* persistent_node,
     ThreadState::PersistentClearCallback callback) {
-  ASSERT(!persistent_node->IsUnused());
+  DCHECK(!persistent_node->IsUnused());
   // 'self' is in use, containing the persistent wrapper object.
   void* self = persistent_node->Self();
   if (callback) {
     (*callback)(self);
-    ASSERT(persistent_node->IsUnused());
+    DCHECK(persistent_node->IsUnused());
     return;
   }
   Persistent<DummyGCBase>* persistent =
       reinterpret_cast<Persistent<DummyGCBase>*>(self);
   persistent->Clear();
-  ASSERT(persistent_node->IsUnused());
+  DCHECK(persistent_node->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 should_trace) {
   size_t debug_marked_object_size = ProcessHeap::TotalMarkedObjectSize();
   base::debug::Alias(&debug_marked_object_size);
@@ skipping 22 matching lines @@
         debug_marked_object_size = ProcessHeap::TotalMarkedObjectSize();
       }
     }
     if (free_count == PersistentNodeSlots::kSlotCount) {
       PersistentNodeSlots* dead_slots = slots;
       *prev_next = slots->next_;
       slots = slots->next_;
       delete dead_slots;
     } else {
       if (free_list_last) {
-        ASSERT(free_list_next);
-        ASSERT(!free_list_last->FreeListNext());
+        DCHECK(free_list_next);
+        DCHECK(!free_list_last->FreeListNext());
         free_list_last->SetFreeListNext(free_list_head_);
         free_list_head_ = free_list_next;
       }
       prev_next = &slots->next_;
       slots = slots->next_;
     }
   }
 #if DCHECK_IS_ON()
   DCHECK_EQ(persistent_count, persistent_count_);
 #endif
@@ skipping 26 matching lines @@
   while (slots) {
     for (int i = 0; i < PersistentNodeSlots::kSlotCount; ++i) {
       if (slots->slot_[i].IsUnused())
         continue;
 
       // 'self' is in use, containing the cross-thread persistent wrapper
       // object.
       CrossThreadPersistent<DummyGCBase>* persistent =
           reinterpret_cast<CrossThreadPersistent<DummyGCBase>*>(
               slots->slot_[i].Self());
-      ASSERT(persistent);
+      DCHECK(persistent);
       void* raw_object = persistent->AtomicGet();
       if (!raw_object)
         continue;
       BasePage* page = PageFromObject(raw_object);
-      ASSERT(page);
+      DCHECK(page);
       if (page->Arena()->GetThreadState() == thread_state) {
         persistent->Clear();
-        ASSERT(slots->slot_[i].IsUnused());
+        DCHECK(slots->slot_[i].IsUnused());
       }
     }
     slots = slots->next_;
   }
 }
 
 #if defined(ADDRESS_SANITIZER)
 void CrossThreadPersistentRegion::UnpoisonCrossThreadPersistents() {
   MutexLocker lock(mutex_);
   int persistent_count = 0;
   for (PersistentNodeSlots* slots = persistent_region_->slots_; slots;
        slots = slots->next_) {
     for (int i = 0; i < PersistentNodeSlots::kSlotCount; ++i) {
       const PersistentNode& node = slots->slot_[i];
       if (!node.IsUnused()) {
         ASAN_UNPOISON_MEMORY_REGION(node.Self(),
                                     sizeof(CrossThreadPersistent<void*>));
         ++persistent_count;
       }
     }
   }
 #if DCHECK_IS_ON()
   DCHECK_EQ(persistent_count, persistent_region_->persistent_count_);
 #endif
 }
 #endif
 
 }  // namespace blink