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

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 286 matching lines @@
 
     NO_SANITIZE_ADDRESS
     bool isPromptlyFreed() { return (m_size & promptlyFreedMask) == promptlyFreedMask; }
 
     NO_SANITIZE_ADDRESS
     void markPromptlyFreed() { m_size |= promptlyFreedMask; }
 
     NO_SANITIZE_ADDRESS
     size_t size() const { return m_size & sizeMask; }
 
+    NO_SANITIZE_ADDRESS
+    void setSize(size_t size) { m_size = (size | (m_size & ~sizeMask)); }
+
 #if ENABLE(GC_PROFILE_HEAP)
     NO_SANITIZE_ADDRESS
     size_t encodedSize() const { return m_size; }
 
     NO_SANITIZE_ADDRESS
     size_t age() const { return m_size >> maxHeapObjectSizeLog2; }
 
     NO_SANITIZE_ADDRESS
     void incAge()
     {
@@ skipping 489 matching lines @@
     virtual void prepareHeapForTermination() override;
 
     virtual int normalPageCount() override { return m_numberOfNormalPages; }
 
     virtual PassOwnPtr<BaseHeap> split(int numberOfNormalPages) override;
     virtual void merge(PassOwnPtr<BaseHeap> splitOffBase) override;
 
     void removePageFromHeap(HeapPage<Header>*);
 
     PLATFORM_EXPORT void promptlyFreeObject(Header*);
+    PLATFORM_EXPORT bool expandObject(Header*, size_t);
 
 private:
     void addPageToHeap(const GCInfo*);
     PLATFORM_EXPORT Address outOfLineAllocate(size_t, const GCInfo*);
     static size_t allocationSizeFromSize(size_t);
     PLATFORM_EXPORT Address allocateLargeObject(size_t, const GCInfo*);
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     bool ownsNonEmptyAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     void setAllocationPoint(Address point, size_t size)
@@ skipping 658 matching lines @@
     static Return zeroedBackingMalloc(size_t size)
     {
         return backingMalloc<Return, Metadata>(size);
     }
     template <typename Return, typename Metadata>
     static Return malloc(size_t size)
     {
         return reinterpret_cast<Return>(Heap::allocate<Metadata>(size));
     }
     PLATFORM_EXPORT static void backingFree(void* address);
+    PLATFORM_EXPORT static bool backingExpand(void*, size_t);
 
     static void free(void* address) { }
     template<typename T>
     static void* newArray(size_t bytes)
     {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     static void deleteArray(void* ptr)
@@ skipping 914 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 } // namespace blink
 
 #endif // Heap_h