Oilpan: always shrink tail-allocated backing storage (reland.)

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

 // 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.
 
 #include "config.h"
 #include "platform/heap/HeapAllocator.h"
 
 namespace blink {
 
 void HeapAllocator::backingFree(void* address)
@@ skipping 70 matching lines @@
     return backingExpand(address, newSize);
 }
 
 bool HeapAllocator::expandHashTableBacking(void* address, size_t newSize)
 {
     return backingExpand(address, newSize);
 }
 
 bool HeapAllocator::backingShrink(void* address, size_t quantizedCurrentSize, size_t quantizedShrunkSize)
 {
-    // We shrink the object only if the shrinking will make a non-small
-    // prompt-free block.
-    // FIXME: Optimize the threshold size.
-    if (quantizedCurrentSize <= quantizedShrunkSize + sizeof(HeapObjectHeader) + sizeof(void*) * 32)
+    if (!address || quantizedShrunkSize == quantizedCurrentSize)
         return true;
 
-    if (!address)
-        return true;
+    ASSERT(quantizedShrunkSize < quantizedCurrentSize);
 
     ThreadState* state = ThreadState::current();
     if (state->sweepForbidden())
         return false;
     ASSERT(!state->isInGC());
     ASSERT(state->isAllocationAllowed());
 
     // FIXME: Support shrink for large objects.
     // Don't shrink backings allocated on other threads.
     BasePage* page = pageFromObject(address);
     if (page->isLargeObjectPage() || page->heap()->threadState() != state)
         return false;
 
     HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
     ASSERT(header->checkHeader());
     NormalPageHeap* heap = static_cast<NormalPage*>(page)->heapForNormalPage();
+    // We shrink the object only if the shrinking will make a non-small
+    // prompt-free block.
+    // FIXME: Optimize the threshold size.
+    if (quantizedCurrentSize <= quantizedShrunkSize + sizeof(HeapObjectHeader) + sizeof(void*) * 32 && !heap->isObjectAllocatedAtAllocationPoint(header))
+        return true;
+
     bool succeededAtAllocationPoint = heap->shrinkObject(header, quantizedShrunkSize);
     if (succeededAtAllocationPoint)
         state->allocationPointAdjusted(heap->heapIndex());
     return true;
 }
 
 bool HeapAllocator::shrinkVectorBacking(void* address, size_t quantizedCurrentSize, size_t quantizedShrunkSize)
 {
     return backingShrink(address, quantizedCurrentSize, quantizedShrunkSize);
 }
 
 bool HeapAllocator::shrinkInlineVectorBacking(void* address, size_t quantizedCurrentSize, size_t quantizedShrunkSize)
 {
     return backingShrink(address, quantizedCurrentSize, quantizedShrunkSize);
 }
 
 } // namespace blink