Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/HeapAllocator.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/HeapAllocator.h"
 
 namespace blink {
 
 void HeapAllocator::BackingFree(void* address) {
   if (!address)
     return;
 
   ThreadState* state = ThreadState::Current();
   if (state->SweepForbidden())
     return;
-  ASSERT(!state->IsInGC());
+  DCHECK(!state->IsInGC());
 
   // Don't promptly free large objects because their page is never reused.
   // Don't free backings allocated on other threads.
   BasePage* page = PageFromObject(address);
   if (page->IsLargeObjectPage() || page->Arena()->GetThreadState() != state)
     return;
 
   HeapObjectHeader* header = HeapObjectHeader::FromPayload(address);
   NormalPageArena* arena = static_cast<NormalPage*>(page)->ArenaForNormalPage();
   state->PromptlyFreed(header->GcInfoIndex());
@@ skipping 12 matching lines @@
   BackingFree(address);
 }
 
 bool HeapAllocator::BackingExpand(void* address, size_t new_size) {
   if (!address)
     return false;
 
   ThreadState* state = ThreadState::Current();
   if (state->SweepForbidden())
     return false;
-  ASSERT(!state->IsInGC());
-  ASSERT(state->IsAllocationAllowed());
+  DCHECK(!state->IsInGC());
+  DCHECK(state->IsAllocationAllowed());
   DCHECK_EQ(&state->Heap(), &ThreadState::FromObject(address)->Heap());
 
   // FIXME: Support expand for large objects.
   // Don't expand backings allocated on other threads.
   BasePage* page = PageFromObject(address);
   if (page->IsLargeObjectPage() || page->Arena()->GetThreadState() != state)
     return false;
 
   HeapObjectHeader* header = HeapObjectHeader::FromPayload(address);
   NormalPageArena* arena = static_cast<NormalPage*>(page)->ArenaForNormalPage();
@@ skipping 14 matching lines @@
 bool HeapAllocator::ExpandHashTableBacking(void* address, size_t new_size) {
   return BackingExpand(address, new_size);
 }
 
 bool HeapAllocator::BackingShrink(void* address,
                                   size_t quantized_current_size,
                                   size_t quantized_shrunk_size) {
   if (!address || quantized_shrunk_size == quantized_current_size)
     return true;
 
-  ASSERT(quantized_shrunk_size < quantized_current_size);
+  DCHECK_LT(quantized_shrunk_size, quantized_current_size);
 
   ThreadState* state = ThreadState::Current();
   if (state->SweepForbidden())
     return false;
-  ASSERT(!state->IsInGC());
-  ASSERT(state->IsAllocationAllowed());
+  DCHECK(!state->IsInGC());
+  DCHECK(state->IsAllocationAllowed());
   DCHECK_EQ(&state->Heap(), &ThreadState::FromObject(address)->Heap());
 
   // FIXME: Support shrink for large objects.
   // Don't shrink backings allocated on other threads.
   BasePage* page = PageFromObject(address);
   if (page->IsLargeObjectPage() || page->Arena()->GetThreadState() != state)
     return false;
 
   HeapObjectHeader* header = HeapObjectHeader::FromPayload(address);
   NormalPageArena* arena = static_cast<NormalPage*>(page)->ArenaForNormalPage();
@@ skipping 19 matching lines @@
   return BackingShrink(address, quantized_current_size, quantized_shrunk_size);
 }
 
 bool HeapAllocator::ShrinkInlineVectorBacking(void* address,
                                               size_t quantized_current_size,
                                               size_t quantized_shrunk_size) {
   return BackingShrink(address, quantized_current_size, quantized_shrunk_size);
 }
 
 }  // namespace blink