Possible fix for a Mac performance regression.

Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 258 matching lines @@
         void reallocateBuffer(size_t newCapacity)
         {
             ASSERT(shouldReallocateBuffer(newCapacity));
             // Using "unsigned" is not a limitation because Chromium's max malloc() is 2GB even on 64-bit.
             RELEASE_ASSERT(newCapacity <= std::numeric_limits<unsigned>::max() / sizeof(T));
             size_t sizeToAllocate = fastMallocGoodSize(newCapacity * sizeof(T));
             m_capacity = sizeToAllocate / sizeof(T);
             m_buffer = static_cast<T*>(fastRealloc(m_buffer, sizeToAllocate));
         }
 
-        T* buffer() { return m_buffer; }
-        const T* buffer() const { return m_buffer; }
-        size_t capacity() const { return m_capacity; }
+        ALWAYS_INLINE T* buffer() { return m_buffer; }
+        ALWAYS_INLINE const T* buffer() const { return m_buffer; }
+        ALWAYS_INLINE size_t capacity() const { return m_capacity; }
 
     protected:
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
+            , m_size(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
+            , m_size(0)
         {
         }
 
         ~VectorBufferBase()
         {
-            m_buffer = 0;
-            m_size = 0;
         }
 
         T* m_buffer;
         unsigned m_capacity;
         unsigned m_size;
     };
 
     template<typename T, size_t inlineCapacity>
     class VectorBuffer;
 
     template<typename T>
     class VectorBuffer<T, 0> : private VectorBufferBase<T> {
     private:
         typedef VectorBufferBase<T> Base;
     public:
         VectorBuffer()
         {
         }
 
         VectorBuffer(size_t capacity)
         {
             // Calling malloc(0) might take a lock and may actually do an
             // allocation on some systems.
             if (capacity)
                 allocateBuffer(capacity);
         }
 
+        ~VectorBuffer()
+        {
+        }
+
         void deallocateBuffer(T* bufferToDeallocate)
         {
             fastFree(bufferToDeallocate);
         }
 
         void clearBufferPointer()
         {
             m_buffer = 0;
             m_capacity = 0;
         }
 
-        ~VectorBuffer()
+        void destruct()
         {
-            deallocateBuffer(buffer());
+            deallocateBuffer(m_buffer);
+            m_buffer = 0;
         }
 
         void swap(VectorBuffer<T, 0>& other)
         {
             std::swap(m_buffer, other.m_buffer);
             std::swap(m_capacity, other.m_capacity);
         }
 
         void restoreInlineBufferIfNeeded() { }
 
@@ skipping 23 matching lines @@
         {
         }
 
         VectorBuffer(size_t capacity)
             : Base(inlineBuffer(), inlineCapacity)
         {
             if (capacity > inlineCapacity)
                 Base::allocateBuffer(capacity);
         }
 
+        ~VectorBuffer()
+        {
+        }
+
         void deallocateBuffer(T* bufferToDeallocate)
         {
             if (UNLIKELY(bufferToDeallocate != inlineBuffer()))
                 fastFree(bufferToDeallocate);
         }
 
+        void destruct()
+        {
+            deallocateBuffer(m_buffer);
+            m_buffer = 0;
+        }
+
         void clearBufferPointer()
         {
             m_buffer = 0;
             m_capacity = 0;
         }
 
-        ~VectorBuffer()
-        {
-            deallocateBuffer(buffer());
-        }
-
         void allocateBuffer(size_t newCapacity)
         {
             // FIXME: This should ASSERT(!m_buffer) to catch misuse/leaks.
             if (newCapacity > inlineCapacity)
                 Base::allocateBuffer(newCapacity);
             else {
                 m_buffer = inlineBuffer();
                 m_capacity = inlineCapacity;
             }
         }
@@ skipping 43 matching lines @@
         using Base::capacity;
 
     protected:
         using Base::m_size;
 
     private:
         using Base::m_buffer;
         using Base::m_capacity;
 
         static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
-        T* inlineBuffer() { return reinterpret_cast_ptr<T*>(m_inlineBuffer.buffer); }
-        const T* inlineBuffer() const { return reinterpret_cast_ptr<const T*>(m_inlineBuffer.buffer); }
+        ALWAYS_INLINE T* inlineBuffer() { return reinterpret_cast_ptr<T*>(m_inlineBuffer.buffer); }
+        ALWAYS_INLINE const T* inlineBuffer() const { return reinterpret_cast_ptr<const T*>(m_inlineBuffer.buffer); }
 
         AlignedBuffer<m_inlineBufferSize, WTF_ALIGN_OF(T)> m_inlineBuffer;
     };
 
     template<typename T, size_t inlineCapacity = 0>
     class Vector : private VectorBuffer<T, inlineCapacity> {
         WTF_MAKE_FAST_ALLOCATED;
     private:
         typedef VectorBuffer<T, inlineCapacity> Base;
         typedef VectorTypeOperations<T> TypeOperations;
 
     public:
         typedef T ValueType;
 
         typedef T* iterator;
         typedef const T* const_iterator;
         typedef std::reverse_iterator<iterator> reverse_iterator;
         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
         Vector()
         {
-            m_size = 0;
+            // Initialization occurs on the base classes.
         }
 
         explicit Vector(size_t size)
             : Base(size)
         {
             m_size = size;
             TypeOperations::initialize(begin(), end());
         }
 
         ~Vector()
         {
-            shrink(0);
+            if (!inlineCapacity) {
+                if (LIKELY(!Base::buffer()))
+                    return;
+                shrink(0);
+            } else {
+                if (UNLIKELY(m_size))
+                    shrink(0);
+            }
+            Base::destruct();
         }
 
         Vector(const Vector&);
         template<size_t otherCapacity>
         Vector(const Vector<T, otherCapacity>&);
 
         Vector& operator=(const Vector&);
         template<size_t otherCapacity>
         Vector& operator=(const Vector<T, otherCapacity>&);
 
 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         Vector(Vector&&);
         Vector& operator=(Vector&&);
 #endif
 
-        size_t size() const { return m_size; }
-        size_t capacity() const { return Base::capacity(); }
-        bool isEmpty() const { return !size(); }
+        ALWAYS_INLINE size_t size() const { return m_size; }
+        ALWAYS_INLINE size_t capacity() const { return Base::capacity(); }
+        ALWAYS_INLINE bool isEmpty() const { return !size(); }
 
         T& at(size_t i)
         {
             RELEASE_ASSERT(i < size());
             return Base::buffer()[i];
         }
         const T& at(size_t i) const
         {
             RELEASE_ASSERT(i < size());
             return Base::buffer()[i];
@@ skipping 535 matching lines @@
     inline bool operator!=(const Vector<T, inlineCapacity>& a, const Vector<T, inlineCapacity>& b)
     {
         return !(a == b);
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h