Fix Deque.swap for deques with inline capacity

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 293 matching lines @@
         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), T>::clear(from, to);
         }
 
     protected:
+        static const size_t sizeFieldSize = sizeof(unsigned) * 2 > sizeof(double) ? sizeof(unsigned) * 2 : sizeof(double);

[Mads Ager (chromium), 2014/07/18 11:03:14]

I can't find any usages of this?

[Erik Corry, 2014/07/22 15:49:26]

Removed.

+
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
         {
         }
 
+        // Ends are exclusive and if they point at the same element as their
+        // start then the range is empty. The end can point one above the last
+        // element in the capacity (this only happens for Vector, not for
+        // Deque).
+        struct Range {
+            Range(unsigned s = 0, unsigned e = 0)
+                : start(s)
+                , end(e)
+            {
+            }
+
+            bool IsEmpty() { return start == end; }
+
+            unsigned start;
+            unsigned end;
+        };
+
+        // Takes a range, which may wrap around at capacity and
+        // decomposes it into 0, 1, or 2 ranges, returning a pointer to the
+        // element past the last one.
+        Range* findRanges(Range* buffer, const Range in, unsigned capacity)
+        {
+            if (in.end > in.start) {
+                *buffer++ = in;
+            } else if (in.end < in.start) {
+                if (in.end)
+                    *buffer++ = Range(0, in.end);
+                ASSERT(in.start != capacity);
+                *buffer++ = Range(in.start, capacity);
+            }
+            return buffer;
+        }
+
         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> : protected VectorBufferBase<T, Allocator> {
     private:
         typedef VectorBufferBase<T, Allocator> Base;
+
+    protected:
+        typedef typename Base::Range Range;
+
     public:
         VectorBuffer()
         {
         }
 
         VectorBuffer(size_t capacity)
         {
             // Calling malloc(0) might take a lock and may actually do an
             // allocation on some systems.
             if (capacity)
@@ skipping 10 matching lines @@
         {
             Allocator::backingFree(bufferToDeallocate);
         }
 
         void resetBufferPointer()
         {
             m_buffer = 0;
             m_capacity = 0;
         }
 
-        void swapVectorBuffer(VectorBuffer<T, 0, Allocator>& other)
+        void swapVectorBuffer(VectorBuffer<T, 0, Allocator>& other, Range, Range)
         {
             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;
+        using Base::findRanges;
 
         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 : protected VectorBufferBase<T, Allocator> {
         WTF_MAKE_NONCOPYABLE(VectorBuffer);
     private:
         typedef VectorBufferBase<T, Allocator> Base;
+
+    protected:
+        typedef typename Base::Range Range;
+
     public:
         VectorBuffer()
             : Base(inlineBuffer(), inlineCapacity)
         {
         }
 
         VectorBuffer(size_t capacity)
             : Base(inlineBuffer(), inlineCapacity)
         {
             if (capacity > inlineCapacity)
@@ skipping 32 matching lines @@
                 resetBufferPointer();
         }
 
         size_t allocationSize(size_t capacity) const
         {
             if (capacity <= inlineCapacity)
                 return m_inlineBufferSize;
             return Base::allocationSize(capacity);
         }
 
-        void swapVectorBuffer(VectorBuffer<T, inlineCapacity, Allocator>& other)
+        void swapVectorBuffer(VectorBuffer<T, inlineCapacity, Allocator>& other, Range thisRange, Range otherRange)

[Ken Russell (switch to Gerrit), 2014/07/21 20:44:09]

What are the invariants of this method? What does it mean if thisRange and
otherRange specify differing numbers of elements?

[Erik Corry, 2014/07/22 15:49:26]

There's no problem with the ranges having a different number of elements.  If
the other vector buffer has more elements than this vector buffer then after the
swap, things will be reversed, and this vector buffer will have more elements
than the other vector buffer.

I added a comment to explain this.

         {
             typedef VectorTypeOperations<T> TypeOperations;
 
-            if (buffer() == inlineBuffer() && other.buffer() == other.inlineBuffer()) {
-                ASSERT(m_capacity == other.m_capacity);
-                if (m_size > other.m_size) {
-                    TypeOperations::swap(inlineBuffer(), inlineBuffer() + other.m_size, other.inlineBuffer());
-                    TypeOperations::move(inlineBuffer() + other.m_size, inlineBuffer() + m_size, other.inlineBuffer() + other.m_size);
+            Range thisRanges[2];
+            Range otherRanges[2];
+            Range* thisRangePtr = thisRanges;
+            Range* otherRangePtr = otherRanges;
+
+            std::swap(m_capacity, other.m_capacity);
+            if (buffer() != inlineBuffer() && other.buffer() != other.inlineBuffer()) {
+                std::swap(m_buffer, other.m_buffer);
+            } else {

[Ken Russell (switch to Gerrit), 2014/07/21 20:44:09]

I can't in good faith review this method. It isn't apparent to me from reading
the code that the algorithm is correct nor that the tests cover all of the code
paths. Is there any way to rewrite this to be simpler? Perhaps having a couple
of common fast paths, and then a more general but slow loop that actually
allocates temporary storage using TypeOperations and does moves in order to
visibly get a correct answer?

[Erik Corry, 2014/07/22 15:49:26]

I managed to simplify this function quite a bit, without having to allocate and
deallocate storage for a swap operation, or use three moves, where a swap would
do. Hope it is more understandable now.

+                T* otherBuffer = other.m_buffer;
+                if (buffer() == inlineBuffer()) {
+                    thisRangePtr = findRanges(thisRanges, thisRange, inlineCapacity);
                 } else {
-                    TypeOperations::swap(inlineBuffer(), inlineBuffer() + m_size, other.inlineBuffer());
-                    TypeOperations::move(other.inlineBuffer() + m_size, other.inlineBuffer() + other.m_size, inlineBuffer() + m_size);
+                    other.m_buffer = m_buffer;
+                    m_buffer = inlineBuffer();
                 }
-            } else if (buffer() == inlineBuffer()) {
-                m_buffer = other.m_buffer;
-                other.m_buffer = other.inlineBuffer();
-                TypeOperations::move(inlineBuffer(), inlineBuffer() + m_size, other.inlineBuffer());
-                std::swap(m_capacity, other.m_capacity);
-            } else if (other.buffer() == other.inlineBuffer()) {
-                other.m_buffer = m_buffer;
-                m_buffer = inlineBuffer();
-                TypeOperations::move(other.inlineBuffer(), other.inlineBuffer() + other.m_size, inlineBuffer());
-                std::swap(m_capacity, other.m_capacity);
-            } else {
-                std::swap(m_buffer, other.m_buffer);
-                std::swap(m_capacity, other.m_capacity);
+                if (otherBuffer == other.inlineBuffer()) {
+                    otherRangePtr = findRanges(otherRanges, otherRange, inlineCapacity);
+                } else {
+                    m_buffer = otherBuffer;
+                    other.m_buffer = other.inlineBuffer();
+                }
+            }
+
+            while (thisRangePtr != thisRanges || otherRangePtr != otherRanges) {
+                if (thisRangePtr == thisRanges) {
+                    // Ran out of ranges in this: process a range in the other.
+                    Range otherRange = *--otherRangePtr;
+                    TypeOperations::move(other.inlineBuffer() + otherRange.start, other.inlineBuffer() + otherRange.end, inlineBuffer() + otherRange.start);
+                    continue;
+                }
+                if (otherRangePtr == otherRanges) {
+                    // Ran out of ranges in the other: process a range in this.
+                    Range thisRange = *--thisRangePtr;
+                    TypeOperations::move(inlineBuffer() + thisRange.start, inlineBuffer() + thisRange.end, other.inlineBuffer() + thisRange.start);
+                    continue;
+                }
+                // We have a rightmost range in both. Find out which extends furthest to the right.
+                Range otherRange = *--otherRangePtr;
+                Range thisRange = *--thisRangePtr;
+                if (otherRange.end == thisRange.end) {
+                    // They end together: Find the start of the overlap.
+                    unsigned startOfOverlap = std::max(thisRange.start, otherRange.start);
+                    TypeOperations::swap(inlineBuffer() + startOfOverlap, inlineBuffer() + thisRange.end, other.inlineBuffer() + startOfOverlap);
+                    if (otherRange.start == thisRange.start)
+                        continue; // Common left edge - we are done with these entries.
+                    if (otherRange.start < thisRange.start) {
+                        // The other extends further to the left, make a new range.
+                        *otherRangePtr++ = Range(otherRange.start, thisRange.start);

[Ken Russell (switch to Gerrit), 2014/07/21 20:44:09]

Where is the guarantee that the new range being pushed back for processing has
the correct relationship to the last range in thisRanges so that the correct
elements will be swapped? Same question regarding the additions to otherRanges
and thisRanges below.

[Erik Corry, 2014/07/22 15:49:26]

There's no restriction on the ranges pushed on the two different stacks relative
to each other, it's enough that each stack is internally ordered with the left
range at the low index and the right range at the high index, which is
definitely the case. Hopefully this is clearer in the new version.

+                        continue;
+                    }
+                    // This extends further to the left, make a new range.
+                    *thisRangePtr++ = Range(thisRange.start, otherRange.start);
+                    continue;
+                }
+                if (otherRange.end > thisRange.end) {
+                    // Other one hangs over the edge.
+                    unsigned startOfOverhang = std::max(otherRange.start, thisRange.end);
+                    TypeOperations::move(other.inlineBuffer() + startOfOverhang, other.inlineBuffer() + otherRange.end, inlineBuffer() + startOfOverhang);
+                    if (otherRange.start != startOfOverhang)
+                        *otherRangePtr++ = Range(otherRange.start, startOfOverhang);
+                    *thisRangePtr++ = thisRange;
+                    continue;
+                }
+                ASSERT(thisRange.end > otherRange.end);
+                // This one hangs over the edge.
+                unsigned startOfOverhang = std::max(thisRange.start, otherRange.end);
+                TypeOperations::move(inlineBuffer() + startOfOverhang, inlineBuffer() + thisRange.end, other.inlineBuffer() + startOfOverhang);
+                if (thisRange.start != startOfOverhang)
+                    *thisRangePtr++ = Range(thisRange.start, startOfOverhang);
+                *otherRangePtr++ = otherRange;
             }
         }
 
         using Base::buffer;
         using Base::capacity;
+        using Base::findRanges;
 
         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 U, size_t inlineBuffer, typename V>
@@ skipping 40 matching lines @@
 
     template<typename Derived, typename Elements>
     class VectorDestructorBase<Derived, Elements, true, true> : public HeapVectorWithInlineCapacityDestructorBase<Derived, VectorTraits<Elements>::needsDestruction> { };
 
     template<typename T, size_t inlineCapacity = 0, typename Allocator = DefaultAllocator>
     class Vector : private VectorBuffer<T, inlineCapacity, Allocator>, public VectorDestructorBase<Vector<T, inlineCapacity, Allocator>, T, (inlineCapacity > 0), Allocator::isGarbageCollected> {
         WTF_USE_ALLOCATOR(Vector, Allocator);
     private:
         typedef VectorBuffer<T, inlineCapacity, Allocator> Base;
         typedef VectorTypeOperations<T> TypeOperations;
+        typedef typename Base::Range Range;
 
     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)
         {
             // Unused slots are initialized to zero so that the visitor and the
             // finalizer can visit them safely. canInitializeWithMemset tells us
             // that the class does not expect matching constructor and
             // destructor calls as long as the memory is zeroed.
             COMPILE_ASSERT(!Allocator::isGarbageCollected || !VectorTraits<T>::needsDestruction || VectorTraits<T>::canInitializeWithMemset, ClassHasProblemsWithFinalizersCalledOnClearedMemory);
             COMPILE_ASSERT(!WTF::IsPolymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, CantInitializeWithMemsetIfThereIsAVtable);
-            m_size = 0;
         }
 
         explicit Vector(size_t size)
             : Base(size)
         {
+            setSize(size);
             // Unused slots are initialized to zero so that the visitor and the
             // finalizer can visit them safely. canInitializeWithMemset tells us
             // that the class does not expect matching constructor and
             // destructor calls as long as the memory is zeroed.
             COMPILE_ASSERT(!Allocator::isGarbageCollected || !VectorTraits<T>::needsDestruction || VectorTraits<T>::canInitializeWithMemset, ClassHasProblemsWithFinalizersCalledOnClearedMemory);
-            m_size = size;
             TypeOperations::initialize(begin(), end());
         }
 
         // Off-GC-heap vectors: Destructor should be called.
         // On-GC-heap vectors: Destructor should be called for inline buffers
         // (if any) but destructor shouldn't be called for vector backing since
         // it is managed by the traced GC heap.
         void finalize()
         {
             if (!inlineCapacity) {
                 if (LIKELY(!Base::buffer()))
                     return;
             }
-            if (LIKELY(m_size) && !(Allocator::isGarbageCollected && this->hasOutOfLineBuffer())) {
+            if (LIKELY(size()) && !(Allocator::isGarbageCollected && this->hasOutOfLineBuffer())) {
                 TypeOperations::destruct(begin(), end());
-                m_size = 0; // Partial protection against use-after-free.
+                setSize(0); // Partial protection against use-after-free.
             }
 
             Base::destruct();
         }
 
         void finalizeGarbageCollectedObject()
         {
             finalize();
         }
 
         Vector(const Vector&);
-        template<size_t otherCapacity>
-        explicit Vector(const Vector<T, otherCapacity, Allocator>&);
+        template<size_t otherInlineCapacity>
+        explicit Vector(const Vector<T, otherInlineCapacity, Allocator>&);
 
         Vector& operator=(const Vector&);
-        template<size_t otherCapacity>
-        Vector& operator=(const Vector<T, otherCapacity, Allocator>&);
+        template<size_t otherInlineCapacity>
+        Vector& operator=(const Vector<T, otherInlineCapacity, Allocator>&);
 
 #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(); }
 
         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];
         }
 
         T& operator[](size_t i) { return at(i); }
         const T& operator[](size_t i) const { return at(i); }
 
         T* data() { return Base::buffer(); }
         const T* data() const { return Base::buffer(); }
 
         iterator begin() { return data(); }
-        iterator end() { return begin() + m_size; }
+        iterator end() { return begin() + size(); }
         const_iterator begin() const { return data(); }
-        const_iterator end() const { return begin() + m_size; }
+        const_iterator end() const { return begin() + size(); }
 
         reverse_iterator rbegin() { return reverse_iterator(end()); }
         reverse_iterator rend() { return reverse_iterator(begin()); }
         const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
         const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 
         T& first() { return at(0); }
         const T& first() const { return at(0); }
         T& last() { return at(size() - 1); }
         const T& last() const { return at(size() - 1); }
@@ skipping 12 matching lines @@
         {
             if (size() * 2 < capacity())
                 shrinkCapacity(size() + size() / 4 + 1);
         }
 
         void clear() { shrinkCapacity(0); }
 
         template<typename U> void append(const U*, size_t);
         template<typename U> void append(const U&);
         template<typename U> void uncheckedAppend(const U& val);
-        template<typename U, size_t otherCapacity, typename V> void appendVector(const Vector<U, otherCapacity, V>&);
+        template<typename U, size_t otherInlineCapacity, typename V> void appendVector(const Vector<U, otherInlineCapacity, V>&);
 
         template<typename U> void insert(size_t position, const U*, size_t);
         template<typename U> void insert(size_t position, const U&);
         template<typename U, size_t c, typename V> void insert(size_t position, const Vector<U, c, V>&);
 
         template<typename U> void prepend(const U*, size_t);
         template<typename U> void prepend(const U&);
         template<typename U, size_t c, typename V> void prepend(const Vector<U, c, V>&);
 
         void remove(size_t position);
         void remove(size_t position, size_t length);
 
         void removeLast()
         {
             ASSERT(!isEmpty());
             shrink(size() - 1);
         }
 
         Vector(size_t size, const T& val)
             : Base(size)
         {
-            m_size = size;
+            setSize(size);
             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);
 
-        void swap(Vector& other)
-        {
-            Base::swapVectorBuffer(other);
-            std::swap(m_size, other.m_size);
-        }
+        void swap(Vector& other);
 
         void reverse();
 
         void trace(typename Allocator::Visitor*);
 
+        size_t size() const { return m_size; }
     private:
         void expandCapacity(size_t newMinCapacity);
         const T* expandCapacity(size_t newMinCapacity, const T*);
         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;
+        void setSize(unsigned size)
+        {
+            m_size = size;
+        }
+
+        unsigned m_size;
+
         using Base::buffer;
         using Base::capacity;
-        using Base::swapVectorBuffer;
         using Base::allocateBuffer;
         using Base::allocationSize;
         using Base::clearUnusedSlots;
+        using Base::hasOutOfLineBuffer;
+
+        friend class VectorBuffer<T, inlineCapacity, Allocator>;

[Mads Ager (chromium), 2014/07/18 11:03:14]

Do you need this friend declaration?

[Erik Corry, 2014/07/22 15:49:26]

Removed.

     };
 
     template<typename T, size_t inlineCapacity, typename Allocator>
+    void Vector<T, inlineCapacity, Allocator>::swap(Vector<T, inlineCapacity, Allocator>& other)
+    {
+        Base::swapVectorBuffer(other, Range(0, m_size), Range(0, other.m_size));
+        std::swap(m_size, other.m_size);
+    }
+
+    template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>::Vector(const Vector& other)
         : Base(other.capacity())
     {
-        m_size = other.size();
+        setSize(other.size());
         TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
-    template<size_t otherCapacity>
-    Vector<T, inlineCapacity, Allocator>::Vector(const Vector<T, otherCapacity, Allocator>& other)
+    template<size_t otherInlineCapacity>
+    Vector<T, inlineCapacity, Allocator>::Vector(const Vector<T, otherInlineCapacity, Allocator>& other)
         : Base(other.capacity())
     {
-        m_size = other.size();
+        setSize(other.size());
         TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::operator=(const Vector<T, inlineCapacity, Allocator>& other)
     {
         if (UNLIKELY(&other == this))
             return *this;
 
         if (size() > other.size())
             shrink(other.size());
         else if (other.size() > capacity()) {
             clear();
             reserveCapacity(other.size());
             ASSERT(begin());
         }
 
 // Works around an assert in VS2010. See https://connect.microsoft.com/VisualStudio/feedback/details/558044/std-copy-should-not-check-dest-when-first-last
 #if COMPILER(MSVC) && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL
         if (!begin())
             return *this;
 #endif
 
         std::copy(other.begin(), other.begin() + size(), begin());
         TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
-        m_size = other.size();
+        setSize(other.size());
 
         return *this;
     }
 
     inline bool typelessPointersAreEqual(const void* a, const void* b) { return a == b; }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
-    template<size_t otherCapacity>
-    Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::operator=(const Vector<T, otherCapacity, Allocator>& other)
+    template<size_t otherInlineCapacity>
+    Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::operator=(const Vector<T, otherInlineCapacity, Allocator>& other)
     {
         // If the inline capacities match, we should call the more specific
         // template.  If the inline capacities don't match, the two objects
         // shouldn't be allocated the same address.
         ASSERT(!typelessPointersAreEqual(&other, this));
 
         if (size() > other.size())
             shrink(other.size());
         else if (other.size() > capacity()) {
             clear();
             reserveCapacity(other.size());
             ASSERT(begin());
         }
 
 // Works around an assert in VS2010. See https://connect.microsoft.com/VisualStudio/feedback/details/558044/std-copy-should-not-check-dest-when-first-last
 #if COMPILER(MSVC) && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL
         if (!begin())
             return *this;
 #endif
 
         std::copy(other.begin(), other.begin() + size(), begin());
         TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
-        m_size = other.size();
+        setSize(other.size());
 
         return *this;
     }
 
 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>::Vector(Vector<T, inlineCapacity, Allocator>&& other)
     {
-        m_size = 0;
+        setSize(0);
         // It's a little weird to implement a move constructor using swap but this way we
         // don't have to add a move constructor to VectorBuffer.
         swap(other);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::operator=(Vector<T, inlineCapacity, Allocator>&& other)
     {
         swap(other);
         return *this;
@@ skipping 40 matching lines @@
         if (size() > newSize)
             shrink(newSize);
         else if (newSize > capacity()) {
             clear();
             reserveCapacity(newSize);
             ASSERT(begin());
         }
 
         std::fill(begin(), end(), val);
         TypeOperations::uninitializedFill(end(), begin() + newSize, val);
-        m_size = newSize;
+        setSize(newSize);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     template<typename Iterator>
     void Vector<T, inlineCapacity, Allocator>::appendRange(Iterator start, Iterator end)
     {
         for (Iterator it = start; it != end; ++it)
             append(*it);
     }
 
@@ skipping 32 matching lines @@
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     inline U* Vector<T, inlineCapacity, Allocator>::expandCapacity(size_t newMinCapacity, U* ptr)
     {
         expandCapacity(newMinCapacity);
         return ptr;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
-    inline void Vector<T, inlineCapacity, Allocator>::resize(size_t size)
+    inline void Vector<T, inlineCapacity, Allocator>::resize(size_t sizeArg)
     {
-        if (size <= m_size)
-            TypeOperations::destruct(begin() + size, end());
+        if (sizeArg <= size())
+            TypeOperations::destruct(begin() + sizeArg, end());
         else {
-            if (size > capacity())
-                expandCapacity(size);
-            TypeOperations::initialize(end(), begin() + size);
+            if (sizeArg > capacity())
+                expandCapacity(sizeArg);
+            TypeOperations::initialize(end(), begin() + sizeArg);
         }
 
-        m_size = size;
+        setSize(sizeArg);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
-    void Vector<T, inlineCapacity, Allocator>::shrink(size_t size)
+    void Vector<T, inlineCapacity, Allocator>::shrink(size_t sizeArg)
     {
-        ASSERT(size <= m_size);
-        TypeOperations::destruct(begin() + size, end());
-        clearUnusedSlots(begin() + size, end());
-        m_size = size;
+        ASSERT(sizeArg <= size());
+        TypeOperations::destruct(begin() + sizeArg, end());
+        clearUnusedSlots(begin() + sizeArg, end());
+        setSize(sizeArg);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
-    void Vector<T, inlineCapacity, Allocator>::grow(size_t size)
+    void Vector<T, inlineCapacity, Allocator>::grow(size_t sizeArg)
     {
-        ASSERT(size >= m_size);
-        if (size > capacity())
-            expandCapacity(size);
-        TypeOperations::initialize(end(), begin() + size);
-        m_size = size;
+        ASSERT(sizeArg >= size());
+        if (sizeArg > capacity())
+            expandCapacity(sizeArg);
+        TypeOperations::initialize(end(), begin() + sizeArg);
+        setSize(sizeArg);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     void Vector<T, inlineCapacity, Allocator>::reserveCapacity(size_t newCapacity)
     {
         if (UNLIKELY(newCapacity <= capacity()))
             return;
         T* oldBuffer = begin();
         T* oldEnd = end();
         Base::allocateBuffer(newCapacity);
         TypeOperations::move(oldBuffer, oldEnd, begin());
         Base::deallocateBuffer(oldBuffer);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     inline void Vector<T, inlineCapacity, Allocator>::reserveInitialCapacity(size_t initialCapacity)
     {
-        ASSERT(!m_size);
+        ASSERT(!size());
         ASSERT(capacity() == inlineCapacity);
         if (initialCapacity > inlineCapacity)
             Base::allocateBuffer(initialCapacity);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     void Vector<T, inlineCapacity, Allocator>::shrinkCapacity(size_t newCapacity)
     {
         if (newCapacity >= capacity())
             return;
@@ skipping 18 matching lines @@
         Base::deallocateBuffer(oldBuffer);
     }
 
     // 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.
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     void Vector<T, inlineCapacity, Allocator>::append(const U* data, size_t dataSize)
     {
-        size_t newSize = m_size + dataSize;
+        size_t newSize = size() + dataSize;
         if (newSize > capacity()) {
             data = expandCapacity(newSize, data);
             ASSERT(begin());
         }
-        RELEASE_ASSERT(newSize >= m_size);
+        RELEASE_ASSERT(newSize >= size());
         T* dest = end();
         VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(data, &data[dataSize], dest);
-        m_size = newSize;
+        setSize(newSize);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::append(const U& val)
     {
         if (LIKELY(size() != capacity())) {
             new (NotNull, end()) T(val);
-            ++m_size;
+            setSize(size() + 1);
             return;
         }
 
         appendSlowCase(val);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     NEVER_INLINE void Vector<T, inlineCapacity, Allocator>::appendSlowCase(const U& val)
     {
         ASSERT(size() == capacity());
 
         const U* ptr = &val;
         ptr = expandCapacity(size() + 1, ptr);
         ASSERT(begin());
 
         new (NotNull, end()) T(*ptr);
-        ++m_size;
+        setSize(size() + 1);
     }
 
     // This version of append saves a branch in the case where you know that the
     // vector's capacity is large enough for the append to succeed.
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::uncheckedAppend(const U& val)
     {
         ASSERT(size() < capacity());
         const U* ptr = &val;
         new (NotNull, end()) T(*ptr);
-        ++m_size;
+        setSize(size() + 1);
     }
 
-    template<typename T, size_t inlineCapacity, typename Allocator> template<typename U, size_t otherCapacity, typename OtherAllocator>
-    inline void Vector<T, inlineCapacity, Allocator>::appendVector(const Vector<U, otherCapacity, OtherAllocator>& val)
+    template<typename T, size_t inlineCapacity, typename Allocator> template<typename U, size_t otherInlineCapacity, typename OtherAllocator>
+    inline void Vector<T, inlineCapacity, Allocator>::appendVector(const Vector<U, otherInlineCapacity, OtherAllocator>& val)
     {
         append(val.begin(), val.size());
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     void Vector<T, inlineCapacity, Allocator>::insert(size_t position, const U* data, size_t dataSize)
     {
         RELEASE_ASSERT(position <= size());
-        size_t newSize = m_size + dataSize;
+        size_t newSize = size() + dataSize;
         if (newSize > capacity()) {
             data = expandCapacity(newSize, data);
             ASSERT(begin());
         }
-        RELEASE_ASSERT(newSize >= m_size);
+        RELEASE_ASSERT(newSize >= size());
         T* spot = begin() + position;
         TypeOperations::moveOverlapping(spot, end(), spot + dataSize);
         VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(data, &data[dataSize], spot);
-        m_size = newSize;
+        setSize(newSize);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position, const U& val)
     {
         RELEASE_ASSERT(position <= size());
         const U* data = &val;
         if (size() == capacity()) {
             data = expandCapacity(size() + 1, data);
             ASSERT(begin());
         }
         T* spot = begin() + position;
         TypeOperations::moveOverlapping(spot, end(), spot + 1);
         new (NotNull, spot) T(*data);
-        ++m_size;
+        setSize(size() + 1);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U, size_t c, typename OtherAllocator>
     inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position, const Vector<U, c, OtherAllocator>& val)
     {
         insert(position, val.begin(), val.size());
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     void Vector<T, inlineCapacity, Allocator>::prepend(const U* data, size_t dataSize)
@@ skipping 14 matching lines @@
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     inline void Vector<T, inlineCapacity, Allocator>::remove(size_t position)
     {
         RELEASE_ASSERT(position < size());
         T* spot = begin() + position;
         spot->~T();
         TypeOperations::moveOverlapping(spot + 1, end(), spot);
         clearUnusedSlots(end() - 1, end());
-        --m_size;
+        setSize(size() - 1);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     inline void Vector<T, inlineCapacity, Allocator>::remove(size_t position, size_t length)
     {
         ASSERT_WITH_SECURITY_IMPLICATION(position <= size());
         RELEASE_ASSERT(position + length <= size());
         T* beginSpot = begin() + position;
         T* endSpot = beginSpot + length;
         TypeOperations::destruct(beginSpot, endSpot);
         TypeOperations::moveOverlapping(endSpot, end(), beginSpot);
         clearUnusedSlots(end() - length, end());
-        m_size -= length;
+        setSize(size() - length);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     inline void Vector<T, inlineCapacity, Allocator>::reverse()
     {
-        for (size_t i = 0; i < m_size / 2; ++i)
-            std::swap(at(i), at(m_size - 1 - i));
+        for (size_t i = 0; i < size() / 2; ++i)
+            std::swap(at(i), at(size() - 1 - i));
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     void deleteAllValues(const Vector<T, inlineCapacity, Allocator>& collection)
     {
         typedef typename Vector<T, inlineCapacity, Allocator>::const_iterator iterator;
         iterator end = collection.end();
         for (iterator it = collection.begin(); it != end; ++it)
             delete *it;
     }
@@ skipping 40 matching lines @@
     struct NeedsTracing<Vector<T, N> > {
         static const bool value = false;
     };
 #endif
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h