Oilpan: Replace checkHeader() with ASSERT(checkHeader())

Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 166 matching lines @@
     bool isMarked() const;
     void mark();
     void unmark();
     void markDead();
     bool isDead() const;
 
     Address payload();
     size_t payloadSize();
     Address payloadEnd();
 
-    void checkHeader() const;
 #if ENABLE(ASSERT)
+    bool checkHeader() const;
     // Zap magic number with a new magic number that means there was once an
     // object allocated here, but it was freed because nobody marked it during
     // GC.
     void zapMagic();
 #endif
 
     void finalize(Address, size_t);
     static HeapObjectHeader* fromPayload(const void*);
 
     static const uint16_t magic = 0xfff1;
@@ skipping 1038 matching lines @@
 {
     size_t result = m_encoded & headerSizeMask;
     // Large objects should not refer to header->size().
     // The actual size of a large object is stored in
     // LargeObjectPage::m_payloadSize.
     ASSERT(result != largeObjectSizeInHeader);
     ASSERT(!pageFromObject(this)->isLargeObjectPage());
     return result;
 }
 
+#if ENABLE(ASSERT)
 NO_SANITIZE_ADDRESS inline
-void HeapObjectHeader::checkHeader() const
+bool HeapObjectHeader::checkHeader() const
 {
-    ASSERT(!pageFromObject(this)->orphaned());
-    ASSERT(m_magic == magic);
+    return !pageFromObject(this)->orphaned() && m_magic == magic;
 }
+#endif
 
 inline Address HeapObjectHeader::payload()
 {
     return reinterpret_cast<Address>(this) + sizeof(HeapObjectHeader);
 }
 
 inline Address HeapObjectHeader::payloadEnd()
 {
     return reinterpret_cast<Address>(this) + size();
 }
 
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::payloadSize()
 {
     size_t size = m_encoded & headerSizeMask;
     if (UNLIKELY(size == largeObjectSizeInHeader)) {
         ASSERT(pageFromObject(this)->isLargeObjectPage());
         return static_cast<LargeObjectPage*>(pageFromObject(this))->payloadSize();
     }
     ASSERT(!pageFromObject(this)->isLargeObjectPage());
     return size - sizeof(HeapObjectHeader);
 }
 
 inline HeapObjectHeader* HeapObjectHeader::fromPayload(const void* payload)
 {
     Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
     HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(addr - sizeof(HeapObjectHeader));
-    header->checkHeader();
+    ASSERT(header->checkHeader());
     return header;
 }
 
 NO_SANITIZE_ADDRESS inline
 bool HeapObjectHeader::isMarked() const
 {
-    checkHeader();
+    ASSERT(checkHeader());
     return m_encoded & headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::mark()
 {
-    checkHeader();
+    ASSERT(checkHeader());
     ASSERT(!isMarked());
     m_encoded = m_encoded | headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::unmark()
 {
-    checkHeader();
+    ASSERT(checkHeader());
     ASSERT(isMarked());
     m_encoded &= ~headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline
 bool HeapObjectHeader::isDead() const
 {
-    checkHeader();
+    ASSERT(checkHeader());
     return m_encoded & headerDeadBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::markDead()
 {
-    checkHeader();
+    ASSERT(checkHeader());
     ASSERT(!isMarked());
     m_encoded |= headerDeadBitMask;
 }
 
 inline Address NormalPageHeap::allocateObject(size_t allocationSize, size_t gcInfoIndex)
 {
 #if ENABLE(GC_PROFILING)
     m_cumulativeAllocationSize += allocationSize;
     ++m_allocationCount;
 #endif
@@ skipping 72 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h