Initialize the memory allocated by Vector<IsPod<T>>

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 62 matching lines @@
     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 needsInitialization, bool canInitializeWithMemset, typename T>
+    template <bool canInitializeWithMemset, typename T>
     struct VectorInitializer;
 
-    template<bool ignore, typename T>
-    struct VectorInitializer<false, ignore, T>
-    {
-        static void initialize(T*, T*) {}
-    };
-
     template<typename T>
-    struct VectorInitializer<true, false, T>
+    struct VectorInitializer<false, T>
     {
         static void initialize(T* begin, T* end)
         {
             for (T* cur = begin; cur != end; ++cur)
                 new (NotNull, cur) T;
         }
     };
 
     template<typename T>
-    struct VectorInitializer<true, true, T>
+    struct VectorInitializer<true, T>
     {
         static void initialize(T* begin, T* end)
         {
             memset(begin, 0, reinterpret_cast<char*>(end) - reinterpret_cast<char*>(begin));
         }
     };
 
     template <bool canMoveWithMemcpy, typename T>
     struct VectorMover;
 
@@ skipping 129 matching lines @@
     template<typename T>
     struct VectorTypeOperations
     {
         static void destruct(T* begin, T* end)
         {
             VectorDestructor<VectorTraits<T>::needsDestruction, T>::destruct(begin, end);
         }
 
         static void initialize(T* begin, T* end)
         {
-            VectorInitializer<VectorTraits<T>::needsInitialization, VectorTraits<T>::canInitializeWithMemset, T>::initialize(begin, end);
+            VectorInitializer<VectorTraits<T>::canInitializeWithMemset, T>::initialize(begin, end);
         }
 
         static void move(const T* src, const T* srcEnd, T* dst)
         {
             VectorMover<VectorTraits<T>::canMoveWithMemcpy, T>::move(src, srcEnd, dst);
         }
 
         static void moveOverlapping(const T* src, const T* srcEnd, T* dst)
         {
             VectorMover<VectorTraits<T>::canMoveWithMemcpy, T>::moveOverlapping(src, srcEnd, dst);
@@ skipping 930 matching lines @@
         }
         if (this->hasOutOfLineBuffer())
             Allocator::markNoTracing(visitor, buffer());
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h