Zero-initialize persistent heap vector inline backing buffers.

third_party/WebKit/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 133 matching lines @@
         } else {
             T* dstEnd = dst + (srcEnd - src);
             while (src != srcEnd) {
                 --srcEnd;
                 --dstEnd;
                 new (NotNull, dstEnd) T(*srcEnd);
                 srcEnd->~T();
             }
         }
     }
-    static void swap(T* src, T* srcEnd, T* dst) 
+    static void swap(T* src, T* srcEnd, T* dst)
     {
         std::swap_ranges(src, srcEnd, dst);
     }
 };
 
 template <typename T>
 struct VectorMover<true, T> {
     static void move(const T* src, const T* srcEnd, T* dst)
     {
         if (LIKELY(dst && src))
@@ skipping 115 matching lines @@
 
     static void swap(T* src, T* srcEnd, T* dst)
     {
         VectorMover<VectorTraits<T>::canMoveWithMemcpy, T>::swap(src, srcEnd, dst);
     }
 
     static void uninitializedCopy(const T* src, const T* srcEnd, T* dst)
     {
         VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(src, srcEnd, dst);
     }
-    
+
     static void uninitializedFill(T* dst, T* dstEnd, const T& val)
     {
         VectorFiller<VectorTraits<T>::canFillWithMemset, T>::uninitializedFill(dst, dstEnd, val);
     }
 
     static bool compare(const T* a, const T* b, size_t size)
     {
         return VectorComparer<VectorTraits<T>::canCompareWithMemcmp, T>::compare(a, b, size);
     }
 };
@@ skipping 478 matching lines @@
     void swap(Vector& other)
     {
         Base::swapVectorBuffer(other);
         std::swap(m_size, other.m_size);
     }
 
     void reverse();
 
     template <typename VisitorDispatcher> void trace(VisitorDispatcher);
 
+protected:
+    using Base::checkUnusedSlots;
+    using Base::clearUnusedSlots;
+
 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;
-    using Base::checkUnusedSlots;
 };
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 Vector<T, inlineCapacity, Allocator>::Vector(const Vector& other)
     : Base(other.capacity())
 {
     ANNOTATE_NEW_BUFFER(begin(), capacity(), other.size());
     m_size = other.size();
     TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
 }
@@ skipping 528 matching lines @@
 struct NeedsTracing<Vector<T, N>> {
     static const bool value = false;
 };
 #endif
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h