Deque: Add HeapDeque and prevent buggy use of swap and operator=

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 291 matching lines @@
 
         size_t allocationSize(size_t capacity) const
         {
             return Allocator::Quantizer::template quantizedSize<T>(capacity);
         }
 
         T* buffer() { return m_buffer; }
         const T* buffer() const { return m_buffer; }
         size_t capacity() const { return m_capacity; }
 
+        void clearUnusedSlots(T* from, T* to)
+        {
+            VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T> >::value || VectorTraits<T>::isWeak), T>::clear(from, to);
+        }
+
     protected:
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
         {
         }
 
         T* m_buffer;
         unsigned m_capacity;
         unsigned m_size;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator = DefaultAllocator>
     class VectorBuffer;
 
     template<typename T, typename Allocator>
-    class VectorBuffer<T, 0, Allocator> : private VectorBufferBase<T, Allocator> {
+    class VectorBuffer<T, 0, Allocator> : protected VectorBufferBase<T, Allocator> {
     private:
         typedef VectorBufferBase<T, Allocator> Base;
     public:
         VectorBuffer()
         {
         }
 
         VectorBuffer(size_t capacity)
         {
             // Calling malloc(0) might take a lock and may actually do an
@@ skipping 24 matching lines @@
             std::swap(m_buffer, other.m_buffer);
             std::swap(m_capacity, other.m_capacity);
         }
 
         using Base::allocateBuffer;
         using Base::allocationSize;
 
         using Base::buffer;
         using Base::capacity;
 
-    protected:
-        using Base::m_size;
+        using Base::clearUnusedSlots;
 
         bool hasOutOfLineBuffer() const
         {
             // When inlineCapacity is 0 we have an out of line buffer if we have a buffer.
             return buffer();
         }
 
+    protected:
+        using Base::m_size;
+
     private:
         using Base::m_buffer;
         using Base::m_capacity;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator>
-    class VectorBuffer : private VectorBufferBase<T, Allocator> {
+    class VectorBuffer : protected VectorBufferBase<T, Allocator> {
         WTF_MAKE_NONCOPYABLE(VectorBuffer);
     private:
         typedef VectorBufferBase<T, Allocator> Base;
     public:
         VectorBuffer()
             : Base(inlineBuffer(), inlineCapacity)
         {
         }
 
         VectorBuffer(size_t capacity)
@@ skipping 67 matching lines @@
                 std::swap(m_capacity, other.m_capacity);
             } else {
                 std::swap(m_buffer, other.m_buffer);
                 std::swap(m_capacity, other.m_capacity);
             }
         }
 
         using Base::buffer;
         using Base::capacity;
 
-    protected:
-        using Base::m_size;
-
         bool hasOutOfLineBuffer() const
         {
             return buffer() && buffer() != inlineBuffer();
         }
 
+    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); }
 
         AlignedBuffer<m_inlineBufferSize, WTF_ALIGN_OF(T)> m_inlineBuffer;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     class Vector;
 
     // VectorDestructorBase defines the destructor of a vector. This base is used in order to
     // completely avoid creating a destructor for a vector that does not need to be destructed.
     // By doing so, the clang compiler will have correct information about whether or not a
     // vector has a trivial destructor and we use that in a compiler plugin to ensure the
     // correctness of non-finalized garbage-collected classes and the use of VectorTraits::needsDestruction.
 
-    // All non-GC managed vectors needs a destructor. This destructor will simply call finalize on the actual vector type.
+    // All non-GC managed vectors need a destructor. This destructor will simply call finalize on the actual vector type.
     template<typename Derived, typename Elements, bool hasInlineCapacity, bool isGarbageCollected>
     class VectorDestructorBase {
     public:
         ~VectorDestructorBase() { static_cast<Derived*>(this)->finalize(); }
     };
 
     // Heap-allocated vectors with no inlineCapacity never need a destructor.
     template<typename Derived, typename Elements>
     class VectorDestructorBase<Derived, Elements, false, true> { };
 
@@ skipping 83 matching lines @@
             }
 
             Base::destruct();
         }
 
         void finalizeGarbageCollectedObject()
         {
             finalize();
         }
 
-        void clearUnusedSlots(T* from, T* to)
-        {
-            VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T> >::value || VectorTraits<T>::isWeak), T>::clear(from, to);
-        }
-
         Vector(const Vector&);
         template<size_t otherCapacity>
         explicit Vector(const Vector<T, otherCapacity, Allocator>&);
 
         Vector& operator=(const Vector&);
         template<size_t otherCapacity>
         Vector& operator=(const Vector<T, otherCapacity, Allocator>&);
 
 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
         Vector(Vector&&);
@@ skipping 99 matching lines @@
         template<typename U> U* expandCapacity(size_t newMinCapacity, U*);
         void shrinkCapacity(size_t newCapacity);
         template<typename U> void appendSlowCase(const U&);
 
         using Base::m_size;
         using Base::buffer;
         using Base::capacity;
         using Base::swapVectorBuffer;
         using Base::allocateBuffer;
         using Base::allocationSize;
+        using Base::clearUnusedSlots;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>::Vector(const Vector& other)
         : Base(other.capacity())
     {
         m_size = other.size();
         TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
@@ skipping 453 matching lines @@
         }
         if (this->hasOutOfLineBuffer())
             Allocator::markNoTracing(visitor, buffer());
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h