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);
+
         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/16 07:38:42]

Are the changes to this method tested sufficiently? I see no changes to any
Vector-related tests. All code paths should be exercised for a CL as involved as
this one.

[Erik Corry, 2014/07/17 14:44:33]

More tests added

         {
             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 {
+                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);
+                        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>;
     };
 
     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