Mark shouldMarkObject(), arenaForNormalPage() accessors as const.

third_party/WebKit/Source/platform/heap/HeapPage.cpp

 /*
  * 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 974 matching lines @@
     }
     entry = new (NotNull, address) FreeListEntry(size);
 
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     // The following logic delays reusing free lists for (at least) one GC
     // cycle or coalescing. This is helpful to detect use-after-free errors
     // that could be caused by lazy sweeping etc.
     size_t allowedCount = 0;
     size_t forbiddenCount = 0;
     for (size_t i = sizeof(FreeListEntry); i < size; i++) {
-        if (address[i] == reuseAllowedZapValue) {
+        if (address[i] == reuseAllowedZapValue)
             allowedCount++;
-        } else if (address[i] == reuseForbiddenZapValue) {
+        else if (address[i] == reuseForbiddenZapValue)
             forbiddenCount++;
-        } else {
+        else
             ASSERT_NOT_REACHED();
-        }
     }
     size_t entryCount = size - sizeof(FreeListEntry);
     if (forbiddenCount == entryCount) {
         // If all values in the memory region are reuseForbiddenZapValue,
         // we flip them to reuseAllowedZapValue. This allows the next
         // addToFreeList() to add the memory region to the free list
         // (unless someone concatenates the memory region with another memory
         // region that contains reuseForbiddenZapValue.)
         for (size_t i = sizeof(FreeListEntry); i < size; i++)
             address[i] = reuseAllowedZapValue;
@@ skipping 164 matching lines @@
         if (header->isFree()) {
             // Zero the memory in the free list header to maintain the
             // invariant that memory on the free list is zero filled.
             // The rest of the memory is already on the free list and is
             // therefore already zero filled.
             SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
             CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
             headerAddress += size;
             continue;
         }
-        ASSERT(header->checkHeader());
-
         if (!header->isMarked()) {
             // This is a fast version of header->payloadSize().
             size_t payloadSize = size - sizeof(HeapObjectHeader);
             Address payload = header->payload();
             // For ASan, unpoison the object before calling the finalizer. The
             // finalized object will be zero-filled and poison'ed afterwards.
             // Given all other unmarked objects are poisoned, ASan will detect
             // an error if the finalizer touches any other on-heap object that
             // die at the same GC cycle.
             ASAN_UNPOISON_MEMORY_REGION(payload, payloadSize);
@@ skipping 35 matching lines @@
     size_t markedObjectSize = 0;
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         ASSERT(header->size() < blinkPagePayloadSize());
         // Check if a free list entry first since we cannot call
         // isMarked on a free list entry.
         if (header->isFree()) {
             headerAddress += header->size();
             continue;
         }
-        ASSERT(header->checkHeader());
         if (header->isMarked()) {
             header->unmark();
             markedObjectSize += header->size();
         } else {
             header->markDead();
         }
         headerAddress += header->size();
     }
     if (markedObjectSize)
         arenaForNormalPage()->getThreadState()->increaseMarkedObjectSize(markedObjectSize);
 }
 
 void NormalPage::makeConsistentForMutator()
 {
     Address startOfGap = payload();
+    NormalPageArena* normalArena = arenaForNormalPage();
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         size_t size = header->size();
         ASSERT(size < blinkPagePayloadSize());
         if (header->isPromptlyFreed())
             arenaForNormalPage()->decreasePromptlyFreedSize(size);
         if (header->isFree()) {
             // Zero the memory in the free list header to maintain the
             // invariant that memory on the free list is zero filled.
             // The rest of the memory is already on the free list and is
             // therefore already zero filled.
             SET_MEMORY_INACCESSIBLE(headerAddress, size < sizeof(FreeListEntry) ? size : sizeof(FreeListEntry));
             CHECK_MEMORY_INACCESSIBLE(headerAddress, size);
             headerAddress += size;
             continue;
         }
-        ASSERT(header->checkHeader());
-
         if (startOfGap != headerAddress)
-            arenaForNormalPage()->addToFreeList(startOfGap, headerAddress - startOfGap);
+            normalArena->addToFreeList(startOfGap, headerAddress - startOfGap);
         if (header->isMarked())
             header->unmark();
         headerAddress += size;
         startOfGap = headerAddress;
         ASSERT(headerAddress <= payloadEnd());
     }
     if (startOfGap != payloadEnd())
-        arenaForNormalPage()->addToFreeList(startOfGap, payloadEnd() - startOfGap);
+        normalArena->addToFreeList(startOfGap, payloadEnd() - startOfGap);
 }
 
 #if defined(ADDRESS_SANITIZER)
 void NormalPage::poisonUnmarkedObjects()
 {
     for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
         HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(headerAddress);
         ASSERT(header->size() < blinkPagePayloadSize());
         // Check if a free list entry first since we cannot call
         // isMarked on a free list entry.
         if (header->isFree()) {
             headerAddress += header->size();
             continue;
         }
-        ASSERT(header->checkHeader());
         if (!header->isMarked())
             ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
         headerAddress += header->size();
     }
 }
 #endif
 
 void NormalPage::populateObjectStartBitMap()
 {
     memset(&m_objectStartBitMap, 0, objectStartBitMapSize);
@@ skipping 158 matching lines @@
 
 #if ENABLE(ASSERT)
 bool NormalPage::contains(Address addr)
 {
     Address blinkPageStart = roundToBlinkPageStart(getAddress());
     ASSERT(blinkPageStart == getAddress() - blinkGuardPageSize); // Page is at aligned address plus guard page size.
     return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
 }
 #endif
 
-NormalPageArena* NormalPage::arenaForNormalPage()
-{
-    return static_cast<NormalPageArena*>(arena());
-}
-
 LargeObjectPage::LargeObjectPage(PageMemory* storage, BaseArena* arena, size_t payloadSize)
     : BasePage(storage, arena)
     , m_payloadSize(payloadSize)
 #if ENABLE(ASAN_CONTAINER_ANNOTATIONS)
     , m_isVectorBackingPage(false)
 #endif
 {
 }
 
 size_t LargeObjectPage::objectPayloadSizeForTesting()
@@ skipping 133 matching lines @@
 
     m_hasEntries = true;
     size_t index = hash(address);
     ASSERT(!(index & 1));
     Address cachePage = roundToBlinkPageStart(address);
     m_entries[index + 1] = m_entries[index];
     m_entries[index] = cachePage;
 }
 
 } // namespace blink