Ensure that Vector destruction always clears the buffer pointer.

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));
         }
 
-        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; }
 
-        T* releaseBuffer()
-        {
-            T* buffer = m_buffer;
-            m_buffer = 0;
-            m_capacity = 0;
-            return buffer;
-        }
-
     protected:
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
         {
         }
 
         ~VectorBufferBase()
         {
-            // FIXME: It would be nice to find a way to ASSERT that m_buffer hasn't leaked here.
+            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);
         }
 
+        void deallocateBuffer(T* bufferToDeallocate)
+        {
+            fastFree(bufferToDeallocate);
+        }
+
+        void clearBufferPointer()
+        {
+            m_buffer = 0;
+            m_capacity = 0;
+        }
+
         ~VectorBuffer()
         {
             deallocateBuffer(buffer());
         }
 
         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;
 
-        using Base::releaseBuffer;
-
     protected:
         using Base::m_size;
 
     private:
         using Base::m_buffer;
         using Base::m_capacity;
     };
 
     template<typename T, size_t inlineCapacity>
     class VectorBuffer : private VectorBufferBase<T> {
         WTF_MAKE_NONCOPYABLE(VectorBuffer);
     private:
         typedef VectorBufferBase<T> Base;
     public:
         VectorBuffer()
             : Base(inlineBuffer(), inlineCapacity)
         {
         }
 
         VectorBuffer(size_t capacity)
             : Base(inlineBuffer(), inlineCapacity)
         {
             if (capacity > inlineCapacity)
                 Base::allocateBuffer(capacity);
         }
 
+        void deallocateBuffer(T* bufferToDeallocate)
+        {
+            if (UNLIKELY(bufferToDeallocate != inlineBuffer()))
+                fastFree(bufferToDeallocate);
+        }
+
+        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;
             }
         }
 
-        void deallocateBuffer(T* bufferToDeallocate)
-        {
-            if (bufferToDeallocate == inlineBuffer())
-                return;
-            Base::deallocateBuffer(bufferToDeallocate);
-        }
-
         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)
         {
             ASSERT(shouldReallocateBuffer(newCapacity));
             Base::reallocateBuffer(newCapacity);
@@ skipping 24 matching lines @@
         {
             if (m_buffer)
                 return;
             m_buffer = inlineBuffer();
             m_capacity = inlineCapacity;
         }
 
         using Base::buffer;
         using Base::capacity;
 
-        T* releaseBuffer()
-        {
-            if (buffer() == inlineBuffer())
-                return 0;
-            return Base::releaseBuffer();
-        }
-
     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); }
@@ skipping 18 matching lines @@
 
         Vector()
         {
             m_size = 0;
         }
 
         explicit Vector(size_t size)
             : Base(size)
         {
             m_size = size;
-            if (begin())
-                TypeOperations::initialize(begin(), end());
+            TypeOperations::initialize(begin(), end());
         }
 
         ~Vector()
         {
-            if (m_size)
-                shrink(0);
+            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 72 matching lines @@
         void removeLast()
         {
             ASSERT(!isEmpty());
             shrink(size() - 1);
         }
 
         Vector(size_t size, const T& val)
             : Base(size)
         {
             m_size = size;
-            if (begin())
-                TypeOperations::uninitializedFill(begin(), end(), val);
+            TypeOperations::uninitializedFill(begin(), end(), val);
         }
 
         void fill(const T&, size_t);
         void fill(const T& val) { fill(val, size()); }
 
         template<typename Iterator> void appendRange(Iterator start, Iterator end);
 
-        T* releaseBuffer();
-
         void swap(Vector<T, inlineCapacity>& other)
         {
             std::swap(m_size, other.m_size);
             Base::swap(other);
         }
 
         void reverse();
 
     private:
         void expandCapacity(size_t newMinCapacity);
         const T* expandCapacity(size_t newMinCapacity, const T*);
         template<typename U> U* expandCapacity(size_t newMinCapacity, U*);
         template<typename U> void appendSlowCase(const U&);
 
         using Base::m_size;
         using Base::buffer;
         using Base::capacity;
         using Base::swap;
         using Base::allocateBuffer;
-        using Base::deallocateBuffer;
         using Base::shouldReallocateBuffer;
         using Base::reallocateBuffer;
         using Base::restoreInlineBufferIfNeeded;
-        using Base::releaseBuffer;
     };
 
     template<typename T, size_t inlineCapacity>
     Vector<T, inlineCapacity>::Vector(const Vector& other)
         : Base(other.capacity())
     {
         m_size = other.size();
-        if (begin())
-            TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
+        TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
     template<typename T, size_t inlineCapacity>
     template<size_t otherCapacity>
     Vector<T, inlineCapacity>::Vector(const Vector<T, otherCapacity>& other)
         : Base(other.capacity())
     {
         m_size = other.size();
-        if (begin())
-            TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
+        TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
     template<typename T, size_t inlineCapacity>
     Vector<T, inlineCapacity>& Vector<T, inlineCapacity>::operator=(const Vector<T, inlineCapacity>& other)
     {
-        if (&other == this)
+        if (UNLIKELY(&other == this))
             return *this;
 
         if (size() > other.size())
             shrink(other.size());
         else if (other.size() > capacity()) {
             clear();
             reserveCapacity(other.size());
             ASSERT(begin());
         }
 
@@ skipping 144 matching lines @@
     }
 
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::resize(size_t size)
     {
         if (size <= m_size)
             TypeOperations::destruct(begin() + size, end());
         else {
             if (size > capacity())
                 expandCapacity(size);
-            if (begin())
-                TypeOperations::initialize(end(), begin() + size);
+            TypeOperations::initialize(end(), begin() + size);
         }
 
         m_size = size;
     }
 
     template<typename T, size_t inlineCapacity>
     void Vector<T, inlineCapacity>::shrink(size_t size)
     {
         ASSERT(size <= m_size);
         TypeOperations::destruct(begin() + size, end());
         m_size = size;
     }
 
     template<typename T, size_t inlineCapacity>
     void Vector<T, inlineCapacity>::grow(size_t size)
     {
         ASSERT(size >= m_size);
         if (size > capacity())
             expandCapacity(size);
-        if (begin())
-            TypeOperations::initialize(end(), begin() + size);
+        TypeOperations::initialize(end(), begin() + size);
         m_size = size;
     }
 
     template<typename T, size_t inlineCapacity>
     void Vector<T, inlineCapacity>::reserveCapacity(size_t newCapacity)
     {
-        if (newCapacity <= capacity())
+        if (UNLIKELY(newCapacity <= capacity()))
             return;
         T* oldBuffer = begin();
         T* oldEnd = end();
         Base::allocateBuffer(newCapacity);
-        if (begin())
-            TypeOperations::move(oldBuffer, oldEnd, begin());
+        TypeOperations::move(oldBuffer, oldEnd, begin());
         Base::deallocateBuffer(oldBuffer);
     }
 
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::reserveInitialCapacity(size_t initialCapacity)
     {
         ASSERT(!m_size);
         ASSERT(capacity() == inlineCapacity);
         if (initialCapacity > inlineCapacity)
             Base::allocateBuffer(initialCapacity);
@@ skipping 12 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 143 matching lines @@
     }
 
     template<typename T, size_t inlineCapacity>
     inline void Vector<T, inlineCapacity>::reverse()
     {
         for (size_t i = 0; i < m_size / 2; ++i)
             std::swap(at(i), at(m_size - 1 - i));
     }
 
     template<typename T, size_t inlineCapacity>
-    inline T* Vector<T, inlineCapacity>::releaseBuffer()
-    {
-        T* buffer = Base::releaseBuffer();
-        if (inlineCapacity && !buffer && m_size) {
-            // If the vector had some data, but no buffer to release,
-            // that means it was using the inline buffer. In that case,
-            // we create a brand new buffer so the caller always gets one.
-            size_t bytes = m_size * sizeof(T);
-            buffer = static_cast<T*>(fastMalloc(bytes));
-            memcpy(buffer, data(), bytes);
-        }
-        m_size = 0;
-        return buffer;
-    }
-
-    template<typename T, size_t inlineCapacity>
     void deleteAllValues(const Vector<T, inlineCapacity>& collection)
     {
         typedef typename Vector<T, inlineCapacity>::const_iterator iterator;
         iterator end = collection.end();
         for (iterator it = collection.begin(); it != end; ++it)
             delete *it;
     }
 
     template<typename T, size_t inlineCapacity>
     inline void swap(Vector<T, inlineCapacity>& a, Vector<T, inlineCapacity>& b)
@@ skipping 14 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