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

third_party/WebKit/Source/platform/heap/HeapPage.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 208 matching lines @@
   void mark();
   void unmark();
 
   Address payload();
   size_t payloadSize();
   Address payloadEnd();
 
   // TODO(633030): Make |checkHeader| and |zapMagic| private. This class should
   // manage its integrity on its own, without requiring outside callers to
   // explicitly check.
-  bool checkHeader() const;
+  void 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();
 
   void finalize(Address, size_t);
   static HeapObjectHeader* fromPayload(const void*);
 
   static const uint32_t zappedMagic = 0xDEAD4321;
 
@@ skipping 588 matching lines @@
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::size() const {
   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;
 }
 
-NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::checkHeader() const {
-  return m_magic == getMagic();
+NO_SANITIZE_ADDRESS inline void HeapObjectHeader::checkHeader() const {
+  ASSERT(m_magic == getMagic());

[sof, 2017/02/16 18:50:04]

ASSERT => DCHECK

[jbroman, 2017/02/16 19:08:09]

DCHECK_EQ?

 }
 
 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));
-  ASSERT(header->checkHeader());
+  header->checkHeader();
   return header;
 }
 
 inline uint32_t HeapObjectHeader::getMagic() const {
   const uintptr_t random1 =
       ~(reinterpret_cast<uintptr_t>(
             base::trace_event::MemoryAllocatorDump::kNameSize) >>
         16);
 
 #if OS(WIN)
@@ skipping 15 matching lines @@
   const uint32_t random = (random1 & 0x0FFFFUL) | (random2 & 0xFFFF0000UL);
 #else
 #error architecture not supported
 #endif
 
   return random;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isWrapperHeaderMarked()
     const {
-  ASSERT(checkHeader());
+  checkHeader();
   return m_encoded & headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::markWrapperHeader() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(!isWrapperHeaderMarked());
   m_encoded |= headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::unmarkWrapperHeader() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(isWrapperHeaderMarked());
   m_encoded &= ~headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isMarked() const {
-  ASSERT(checkHeader());
+  checkHeader();
   return m_encoded & headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::mark() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(!isMarked());
   m_encoded = m_encoded | headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::unmark() {
-  ASSERT(checkHeader());
+  checkHeader();
   ASSERT(isMarked());
   m_encoded &= ~headerMarkBitMask;
 }
 
 inline Address NormalPageArena::allocateObject(size_t allocationSize,
                                                size_t gcInfoIndex) {
   if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
     Address headerAddress = m_currentAllocationPoint;
     m_currentAllocationPoint += allocationSize;
     m_remainingAllocationSize -= allocationSize;
     ASSERT(gcInfoIndex > 0);
     new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
     Address result = headerAddress + sizeof(HeapObjectHeader);
     ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
     SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
     ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
     return result;
   }
   return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 inline NormalPageArena* NormalPage::arenaForNormalPage() const {
   return static_cast<NormalPageArena*>(arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h