Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/HeapAllocator.h

 // 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.
 
 #ifndef HeapAllocator_h
 #define HeapAllocator_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/Persistent.h"
 #include "platform/heap/TraceTraits.h"
@@ skipping 48 matching lines @@
   template <typename T>
   static size_t QuantizedSize(size_t count) {
     CHECK(count <= MaxElementCountInBackingStore<T>());
     return ThreadHeap::AllocationSizeFromSize(count * sizeof(T)) -
            sizeof(HeapObjectHeader);
   }
   template <typename T>
   static T* AllocateVectorBacking(size_t size) {
     ThreadState* state =
         ThreadStateFor<ThreadingTrait<T>::kAffinity>::GetState();
-    ASSERT(state->IsAllocationAllowed());
+    DCHECK(state->IsAllocationAllowed());
     size_t gc_info_index = GCInfoTrait<HeapVectorBacking<T>>::Index();
     NormalPageArena* arena =
         static_cast<NormalPageArena*>(state->VectorBackingArena(gc_info_index));
     return reinterpret_cast<T*>(arena->AllocateObject(
         ThreadHeap::AllocationSizeFromSize(size), gc_info_index));
   }
   template <typename T>
   static T* AllocateExpandedVectorBacking(size_t size) {
     ThreadState* state =
         ThreadStateFor<ThreadingTrait<T>::kAffinity>::GetState();
-    ASSERT(state->IsAllocationAllowed());
+    DCHECK(state->IsAllocationAllowed());
     size_t gc_info_index = GCInfoTrait<HeapVectorBacking<T>>::Index();
     NormalPageArena* arena = static_cast<NormalPageArena*>(
         state->ExpandedVectorBackingArena(gc_info_index));
     return reinterpret_cast<T*>(arena->AllocateObject(
         ThreadHeap::AllocationSizeFromSize(size), gc_info_index));
   }
   static void FreeVectorBacking(void*);
   static bool ExpandVectorBacking(void*, size_t);
   static bool ShrinkVectorBacking(void* address,
                                   size_t quantized_current_size,
@@ skipping 225 matching lines @@
 void HeapVectorBacking<T, Traits>::Finalize(void* pointer) {
   static_assert(Traits::kNeedsDestruction,
                 "Only vector buffers with items requiring destruction should "
                 "be finalized");
   // See the comment in HeapVectorBacking::trace.
   static_assert(
       Traits::kCanClearUnusedSlotsWithMemset || std::is_polymorphic<T>::value,
       "HeapVectorBacking doesn't support objects that cannot be cleared as "
       "unused with memset or don't have a vtable");
 
-  ASSERT(!WTF::IsTriviallyDestructible<T>::value);
+  DCHECK(!WTF::IsTriviallyDestructible<T>::value);
   HeapObjectHeader* header = HeapObjectHeader::FromPayload(pointer);
   // Use the payload size as recorded by the heap to determine how many
   // elements to finalize.
   size_t length = header->PayloadSize() / sizeof(T);
   T* buffer = reinterpret_cast<T*>(pointer);
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
   // As commented above, HeapVectorBacking calls finalizers for unused slots
   // (which are already zeroed out).
   ANNOTATE_CHANGE_SIZE(buffer, length, 0, length);
 #endif
   if (std::is_polymorphic<T>::value) {
     char* pointer = reinterpret_cast<char*>(buffer);
     for (unsigned i = 0; i < length; ++i) {
       char* element = pointer + i * sizeof(T);
       if (blink::VTableInitialized(element))
         reinterpret_cast<T*>(element)->~T();
     }
   } else {
     for (unsigned i = 0; i < length; ++i) {
       buffer[i].~T();
     }
   }
 }
 
 template <typename Table>
 void HeapHashTableBacking<Table>::Finalize(void* pointer) {
   using Value = typename Table::ValueType;
-  ASSERT(!WTF::IsTriviallyDestructible<Value>::value);
+  DCHECK(!WTF::IsTriviallyDestructible<Value>::value);
   HeapObjectHeader* header = HeapObjectHeader::FromPayload(pointer);
   // Use the payload size as recorded by the heap to determine how many
   // elements to finalize.
   size_t length = header->PayloadSize() / sizeof(Value);
   Value* table = reinterpret_cast<Value*>(pointer);
   for (unsigned i = 0; i < length; ++i) {
     if (!Table::IsEmptyOrDeletedBucket(table[i]))
       table[i].~Value();
   }
 }
@@ skipping 481 matching lines @@
     const blink::HeapHashCountedSet<Value, HashFunctions, Traits>& set,
     VectorType& vector) {
   CopyToVector(static_cast<const HashCountedSet<Value, HashFunctions, Traits,
                                                 blink::HeapAllocator>&>(set),
                vector);
 }
 
 }  // namespace WTF
 
 #endif