Replace ASSERTs in platform/heap/ with DCHECKs

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 35 matching lines @@
 // allocated.  However see also HeapListHashSetAllocator.
 class PLATFORM_EXPORT HeapAllocator {
   STATIC_ONLY(HeapAllocator);
 
  public:
   using Visitor = blink::Visitor;
   static const bool isGarbageCollected = true;
 
   template <typename T>
   static size_t quantizedSize(size_t count) {
-    RELEASE_ASSERT(count <= maxHeapObjectSize / sizeof(T));
+    CHECK(count <= maxHeapObjectSize / sizeof(T));
     return ThreadHeap::allocationSizeFromSize(count * sizeof(T)) -
            sizeof(HeapObjectHeader);
   }
   template <typename T>
   static T* allocateVectorBacking(size_t size) {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
-    ASSERT(state->isAllocationAllowed());
+    DCHECK(state->isAllocationAllowed());
     size_t gcInfoIndex = GCInfoTrait<HeapVectorBacking<T>>::index();
     NormalPageArena* arena =
         static_cast<NormalPageArena*>(state->vectorBackingArena(gcInfoIndex));
     return reinterpret_cast<T*>(arena->allocateObject(
         ThreadHeap::allocationSizeFromSize(size), gcInfoIndex));
   }
   template <typename T>
   static T* allocateExpandedVectorBacking(size_t size) {
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
-    ASSERT(state->isAllocationAllowed());
+    DCHECK(state->isAllocationAllowed());
     size_t gcInfoIndex = GCInfoTrait<HeapVectorBacking<T>>::index();
     NormalPageArena* arena = static_cast<NormalPageArena*>(
         state->expandedVectorBackingArena(gcInfoIndex));
     return reinterpret_cast<T*>(arena->allocateObject(
         ThreadHeap::allocationSizeFromSize(size), gcInfoIndex));
   }
   static void freeVectorBacking(void*);
   static bool expandVectorBacking(void*, size_t);
   static bool shrinkVectorBacking(void* address,
                                   size_t quantizedCurrentSize,
@@ skipping 39 matching lines @@
   // provide a version that asserts and fails at run-time if
   // used.
   // Elsewhere we expect compilation to fail if 'delete' is
   // attempted used and instantiated with a HeapAllocator-based
   // object, as HeapAllocator::free is not provided.
   static void free(void*) { NOTREACHED(); }
 #endif
 
   template <typename T>
   static void* newArray(size_t bytes) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return 0;
   }
 
-  static void deleteArray(void* ptr) { ASSERT_NOT_REACHED(); }
+  static void deleteArray(void* ptr) { NOTREACHED(); }
 
   static bool isAllocationAllowed() {
     return ThreadState::current()->isAllocationAllowed();
   }
 
   template <typename T>
   static bool isHeapObjectAlive(T* object) {
     return ThreadHeap::isHeapObjectAlive(object);
   }
 
@@ skipping 25 matching lines @@
 
   template <typename VisitorDispatcher>
   static void registerWeakTable(VisitorDispatcher visitor,
                                 const void* closure,
                                 EphemeronCallback iterationCallback,
                                 EphemeronCallback iterationDoneCallback) {
     visitor->registerWeakTable(closure, iterationCallback,
                                iterationDoneCallback);
   }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   template <typename VisitorDispatcher>
   static bool weakTableRegistered(VisitorDispatcher visitor,
                                   const void* closure) {
     return visitor->weakTableRegistered(closure);
   }
 #endif
 
   template <typename T, typename VisitorDispatcher>
   static void registerBackingStoreReference(VisitorDispatcher visitor,
                                             T** slot) {
@@ skipping 106 matching lines @@
 void HeapVectorBacking<T, Traits>::finalize(void* pointer) {
   static_assert(Traits::needsDestruction,
                 "Only vector buffers with items requiring destruction should "
                 "be finalized");
   // See the comment in HeapVectorBacking::trace.
   static_assert(
       Traits::canClearUnusedSlotsWithMemset || 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);
-  ASSERT(header->checkHeader());
+  DCHECK(header->checkHeader());
   // 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);
-  ASSERT(header->checkHeader());
+  DCHECK(header->checkHeader());
   // 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 480 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