Oilpan: Correct static_asserts about VectorTraits::canInitializeWithMemset

Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1904 matching lines @@
         return Traits::traceInCollection(visitor, t, strongify);
     }
 };
 
 // Vector backing that needs marking. We don't support weak members in vectors.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::HeapVectorBacking<T, Traits>, void> {
     template<typename VisitorDispatcher>
     static bool trace(VisitorDispatcher visitor, void* self)
     {
-        // The allocator can oversize the allocation a little, according to
-        // the allocation granularity.  The extra size is included in the
-        // payloadSize call below, since there is nowhere to store the
-        // originally allocated memory.  This assert ensures that visiting the
-        // last bit of memory can't cause trouble.
-        static_assert(!ShouldBeTraced<Traits>::value || sizeof(T) > blink::allocationGranularity || Traits::canInitializeWithMemset, "heap overallocation can cause spurious visits");

[haraken, 2015/04/22 16:13:22]

Do you know why we need to check 'sizeof(T) > allocationGranularity'? The above
comment is not clear enough to convince me that the condition is necessary to
safely trace the zeroed-out memory.

+        static_assert(!ShouldBeTraced<Traits>::value || Traits::canInitializeWithMemset, "HeapVector doesn't support objects that cannot be initialized with memset.");
 
         T* array = reinterpret_cast<T*>(self);
         blink::HeapObjectHeader* header = blink::HeapObjectHeader::fromPayload(self);
         // Use the payload size as recorded by the heap to determine how many
         // elements to mark.
         size_t length = header->payloadSize() / sizeof(T);
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
         // Have no option but to mark the whole container as accessible, but
         // this trace() is only used for backing stores that are identified
         // as roots independent from a vector.
@@ skipping 270 matching lines @@
     {
 #if ENABLE(ASSERT)
         assertObjectHasGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::index());
 #endif
     }
 };
 
 template<typename T, typename Traits>
 void HeapVectorBacking<T, Traits>::finalize(void* pointer)
 {
+    static_assert(Traits::needsDestruction, "HeapVectors that don't require destructors should not reach here.");
+    static_assert(Traits::canInitializeWithMemset, "HeapVector doesn't support objects that cannot be initialized with memset.");
+
     ASSERT(!WTF::IsTriviallyDestructible<T>::value);
     HeapObjectHeader* header = HeapObjectHeader::fromPayload(pointer);
     // Use the payload size as recorded by the heap to determine how many
     // elements to finalize.
     size_t length = header->payloadSize() / sizeof(T);
     T* array = reinterpret_cast<T*>(pointer);
     for (unsigned i = 0; i < length; ++i) {
         array[i].~T();
     }
 }
@@ skipping 10 matching lines @@
     Value* table = reinterpret_cast<Value*>(pointer);
     for (unsigned i = 0; i < length; ++i) {
         if (!Table::isEmptyOrDeletedBucket(table[i]))
             table[i].~Value();
     }
 }
 
 } // namespace blink
 
 #endif // Heap_h