Remove more bits of the Oilpan tracing system

sky/engine/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 47 matching lines @@
     template<typename T>
     struct VectorDestructor<true, T>
     {
         static void destruct(T* begin, T* end)
         {
             for (T* cur = begin; cur != end; ++cur)
                 cur->~T();
         }
     };
 
-    template <bool unusedSlotsMustBeZeroed, typename T>
-    struct VectorUnusedSlotClearer;
-
-    template<typename T>
-    struct VectorUnusedSlotClearer<false, T> {
-        static void clear(T*, T*) { }
-    };
-
-    template<typename T>
-    struct VectorUnusedSlotClearer<true, T> {
-        static void clear(T* begin, T* end)
-        {
-            // We clear out unused slots so that the visitor and the finalizer
-            // do not visit them (or at least it does not matter if they do).
-            memset(begin, 0, sizeof(T) * (end - begin));
-        }
-    };
-
     template <bool canInitializeWithMemset, typename T>
     struct VectorInitializer;
 
     template<typename T>
     struct VectorInitializer<false, T>
     {
         static void initialize(T* begin, T* end)
         {
             for (T* cur = begin; cur != end; ++cur)
                 new (NotNull, cur) T;
@@ skipping 202 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), T>::clear(from, to);
-        }
-
     protected:
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
@@ skipping 47 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;
 
-        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:
@@ skipping 308 matching lines @@
         template<typename Iterator> void appendRange(Iterator start, Iterator end);
 
         void swap(Vector& other)
         {
             Base::swapVectorBuffer(other);
             std::swap(m_size, other.m_size);
         }
 
         void reverse();
 
-        void trace(typename Allocator::Visitor*);
-
     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;
         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 180 matching lines @@
         }
 
         m_size = size;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     void Vector<T, inlineCapacity, Allocator>::shrink(size_t size)
     {
         ASSERT(size <= m_size);
         TypeOperations::destruct(begin() + size, end());
-        clearUnusedSlots(begin() + size, end());
         m_size = size;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     void Vector<T, inlineCapacity, Allocator>::grow(size_t size)
     {
         ASSERT(size >= m_size);
         if (size > capacity())
             expandCapacity(size);
         TypeOperations::initialize(end(), begin() + size);
@@ skipping 167 matching lines @@
         insert(0, val.begin(), val.size());
     }
 
     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;
     }
 
     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;
     }
 
     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));
     }
 
@@ skipping 20 matching lines @@
 
         return VectorTypeOperations<T>::compare(a.data(), b.data(), a.size());
     }
 
     template<typename T, size_t inlineCapacityA, size_t inlineCapacityB, typename Allocator>
     inline bool operator!=(const Vector<T, inlineCapacityA, Allocator>& a, const Vector<T, inlineCapacityB, Allocator>& b)
     {
         return !(a == b);
     }
 
-    // This is only called if the allocator is a HeapAllocator. It is used when
-    // visiting during a tracing GC.
-    template<typename T, size_t inlineCapacity, typename Allocator>
-    void Vector<T, inlineCapacity, Allocator>::trace(typename Allocator::Visitor* visitor)
-    {
-        ASSERT(Allocator::isGarbageCollected); // Garbage collector must be enabled.
-        const T* bufferBegin = buffer();
-        const T* bufferEnd = buffer() + size();
-        if (ShouldBeTraced<VectorTraits<T> >::value) {
-            for (const T* bufferEntry = bufferBegin; bufferEntry != bufferEnd; bufferEntry++)
-                Allocator::template trace<T, VectorTraits<T> >(visitor, *const_cast<T*>(bufferEntry));
-        }
-        if (this->hasOutOfLineBuffer())
-            Allocator::markNoTracing(visitor, buffer());
-    }
-
-#if !ENABLE(OILPAN)
-    template<typename T, size_t N>
-    struct NeedsTracing<Vector<T, N> > {
-        static const bool value = false;
-    };
-#endif
-
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h