Call HeapObjectHeader::checkHeader solely for its side-effect.

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 295 matching lines @@
                 "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);
   HeapObjectHeader* header = HeapObjectHeader::fromPayload(pointer);
-  ASSERT(header->checkHeader());
+  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);
   HeapObjectHeader* header = HeapObjectHeader::fromPayload(pointer);
-  ASSERT(header->checkHeader());
+  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