Oilpan: Correct static_asserts about VectorTraits::canInitializeWithMemset

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 72 matching lines @@
         static void clear(T*, T*) { }
 #if ENABLE(ASSERT)
         static void checkCleared(const T*, const T*) { }
 #endif
     };
 
     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));
         }
 
 #if ENABLE(ASSERT)
         static void checkCleared(const T* begin, const T* end)
         {
             const unsigned char* unusedArea = reinterpret_cast<const unsigned char*>(begin);
             const unsigned char* endAddress = reinterpret_cast<const unsigned char*>(end);
             ASSERT(endAddress >= unusedArea);
             for (int i = 0; i < endAddress - unusedArea; ++i)
@@ skipping 232 matching lines @@
         {
             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)
         {
+            // If the vector backing is garbage-collected and needs tracing
+            // or finalizing, we clear out the unused slots so that the visitor
+            // or the finalizer does not cause a problem when visiting the
+            // unused slots.
             VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T>>::value), T>::clear(from, to);
         }
 
         void checkUnusedSlots(const T* from, const T* to)
         {
 #if ENABLE(ASSERT) && !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
             VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T>>::value), T>::checkCleared(from, to);
 #endif
         }
 
@@ skipping 271 matching lines @@
     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()
         {
-            // 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.
-            static_assert(!Allocator::isGarbageCollected || !VectorTraits<T>::needsDestruction || VectorTraits<T>::canInitializeWithMemset, "class has problems with finalizers called on cleared memory");
-            static_assert(!WTF::IsPolymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "cannot initialize with memset if there is a vtable");
+            static_assert(!WTF::IsPolymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "Cannot initialize with memset if there is a vtable");
             ANNOTATE_NEW_BUFFER(begin(), capacity(), 0);
             m_size = 0;
         }
 
         explicit Vector(size_t size)
             : Base(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.
-            static_assert(!Allocator::isGarbageCollected || !VectorTraits<T>::needsDestruction || VectorTraits<T>::canInitializeWithMemset, "class has problems with finalizers called on cleared memory");
+            static_assert(!WTF::IsPolymorphic<T>::value || !VectorTraits<T>::canInitializeWithMemset, "Cannot initialize with memset if there is a vtable");
             ANNOTATE_NEW_BUFFER(begin(), capacity(), size);
             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()
@@ skipping 664 matching lines @@
     struct NeedsTracing<Vector<T, N>> {
         static const bool value = false;
     };
 #endif
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h