Oilpan: Vector::reserveCapacity shouldn't reallocate backing storage always

Source/platform/heap/Heap.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 845 matching lines @@
 #endif
     int index = bucketIndexForSize(size);
     entry->link(&m_freeLists[index]);
     if (!m_lastFreeListEntries[index])
         m_lastFreeListEntries[index] = entry;
     if (index > m_biggestFreeListIndex)
         m_biggestFreeListIndex = index;
 }
 
 template<typename Header>
+bool ThreadHeap<Header>::expandObject(Header* header, size_t newSize)
+{
+    ASSERT(header->payloadSize() < newSize);
+    size_t allocationSize = allocationSizeFromSize(newSize);
+    ASSERT(allocationSize > header->size());
+    size_t expandSize = allocationSize - header->size();
+    if (header->payloadEnd() == m_currentAllocationPoint && expandSize <= m_remainingAllocationSize) {
+        m_currentAllocationPoint += expandSize;
+        m_remainingAllocationSize -= expandSize;
+
+        // Unpoison the memory used for the object (payload).
+        ASAN_UNPOISON_MEMORY_REGION(header->payloadEnd(), expandSize);
+#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+        memset(header->payloadEnd(), 0, expandSize);
+#endif
+        header->setSize(allocationSize);
+        ASSERT(heapPageFromAddress(header->payloadEnd() - 1));
+        return true;
+    }
+    return false;
+}
+
+template<typename Header>
 void ThreadHeap<Header>::promptlyFreeObject(Header* header)
 {
     ASSERT(!m_threadState->isSweepInProgress());
     header->checkHeader();
     Address address = reinterpret_cast<Address>(header);
     Address payload = header->payload();
     size_t size = header->size();
     size_t payloadSize = header->payloadSize();
     BaseHeapPage* page = pageHeaderFromObject(address);
     ASSERT(size > 0);
@@ skipping 1983 matching lines @@
 
     HeaderType* header = HeaderType::fromPayload(address);
     header->checkHeader();
 
     const GCInfo* gcInfo = header->gcInfo();
     int heapIndex = HeapTraits::index(gcInfo->hasFinalizer(), header->payloadSize());
     HeapType* heap = static_cast<HeapType*>(state->heap(heapIndex));
     heap->promptlyFreeObject(header);
 }
 
+bool HeapAllocator::backingExpand(void* address, size_t newSize)
+{
+    if (!address || ThreadState::isAnyThreadInGC())
+        return false;
+
+    ThreadState* state = ThreadState::current();
+    if (state->isSweepInProgress())
+        return false;
+    ASSERT(state->isAllocationAllowed());
+
+    BaseHeapPage* page = pageHeaderFromObject(address);
+    if (page->isLargeObject() || page->threadState() != state)
+        return false;
+
+    typedef HeapIndexTrait<CollectionBackingHeap> HeapTraits;
+    typedef HeapTraits::HeapType HeapType;
+    typedef HeapTraits::HeaderType HeaderType;
+
+    HeaderType* header = HeaderType::fromPayload(address);
+    header->checkHeader();
+
+    const GCInfo* gcInfo = header->gcInfo();
+    int heapIndex = HeapTraits::index(gcInfo->hasFinalizer(), header->payloadSize());
+    HeapType* heap = static_cast<HeapType*>(state->heap(heapIndex));
+    return heap->expandObject(header, newSize);
+}
+
 BaseHeapPage* Heap::lookup(Address address)
 {
     ASSERT(ThreadState::isAnyThreadInGC());
     if (!s_regionTree)
         return 0;
     if (PageMemoryRegion* region = s_regionTree->lookup(address))
         return region->pageFromAddress(address);
     return 0;
 }
 
@@ skipping 89 matching lines @@
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = 0;
 
 } // namespace blink