Reorder the destruction sequence of Vector() to do less work.

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 261 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));
         }
 
-        void deallocateBuffer(T* bufferToDeallocate)
-        {
-            if (!bufferToDeallocate)
-                return;
-
-            if (m_buffer == bufferToDeallocate) {
-                m_buffer = 0;
-                m_capacity = 0;
-            }
-
-            fastFree(bufferToDeallocate);
-        }
-
         T* buffer() { return m_buffer; }
         const T* buffer() const { return m_buffer; }
         size_t capacity() const { return m_capacity; }
 
     protected:
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
         {
         }
@@ skipping 30 matching lines @@
         {
             // Calling malloc(0) might take a lock and may actually do an
             // allocation on some systems.
             if (capacity)
                 allocateBuffer(capacity);
         }
 
         ~VectorBuffer()
         {
             deallocateBuffer(buffer());
+            m_buffer = 0;
+        }
+
+        void deallocateBuffer(T* bufferToDeallocate)
+        {
+            if (LIKELY(!bufferToDeallocate))
+                return;
+
+            fastFree(bufferToDeallocate);
+        }
+
+        void clearBufferPointer()
+        {
+            m_buffer = 0;
+            m_capacity = 0;
         }
 
         void swap(VectorBuffer<T, 0>& other)
         {
             std::swap(m_buffer, other.m_buffer);
             std::swap(m_capacity, other.m_capacity);
         }
 
         void restoreInlineBufferIfNeeded() { }
 
         using Base::allocateBuffer;
         using Base::shouldReallocateBuffer;
         using Base::reallocateBuffer;
-        using Base::deallocateBuffer;
 
         using Base::buffer;
         using Base::capacity;
 
     protected:
         using Base::m_size;
 
     private:
         using Base::m_buffer;
         using Base::m_capacity;
@@ skipping 31 matching lines @@
             else {
                 m_buffer = inlineBuffer();
                 m_capacity = inlineCapacity;
             }
         }
 
         void deallocateBuffer(T* bufferToDeallocate)
         {
             if (LIKELY(bufferToDeallocate == inlineBuffer()))
                 return;
-            Base::deallocateBuffer(bufferToDeallocate);
+
+            fastFree(bufferToDeallocate);
+        }
+
+        void clearBufferPointer()
+        {
+            m_buffer = 0;
+            m_capacity = 0;
         }
 
         bool shouldReallocateBuffer(size_t newCapacity) const
         {
             // We cannot reallocate the inline buffer.
             return Base::shouldReallocateBuffer(newCapacity) && std::min(static_cast<size_t>(m_capacity), newCapacity) > inlineCapacity;
         }
 
         void reallocateBuffer(size_t newCapacity)
         {
@@ skipping 69 matching lines @@
 
         explicit Vector(size_t size)
             : Base(size)
         {
             m_size = size;
             TypeOperations::initialize(begin(), end());
         }
 
         ~Vector()
         {
-            if (m_size)
+            if (UNLIKELY(m_size))
                 shrink(0);
         }
 
         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>&);
@@ skipping 356 matching lines @@
         if (newCapacity > 0) {
             if (Base::shouldReallocateBuffer(newCapacity)) {
                 Base::reallocateBuffer(newCapacity);
                 return;
             }
 
             T* oldEnd = end();
             Base::allocateBuffer(newCapacity);
             if (begin() != oldBuffer)
                 TypeOperations::move(oldBuffer, oldEnd, begin());
+        } else {
+            Base::clearBufferPointer();
         }
 
         Base::deallocateBuffer(oldBuffer);
         Base::restoreInlineBufferIfNeeded();
     }
 
     // Templatizing these is better than just letting the conversion happen implicitly,
     // because for instance it allows a PassRefPtr to be appended to a RefPtr vector
     // without refcount thrash.
 
@@ skipping 177 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