Correct alignment in ContiguousContainer::appendByMoving()

third_party/WebKit/Source/platform/graphics/ContiguousContainer.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef ContiguousContainer_h
 #define ContiguousContainer_h
 
 #include "platform/PlatformExport.h"
 #include "wtf/Alignment.h"
 #include "wtf/Allocator.h"
@@ skipping 148 matching lines @@
     BaseElementType& operator[](size_t index) { return *(begin() + index); }
     const BaseElementType& operator[](size_t index) const { return *(begin() + index); }
 
     template <class DerivedElementType, typename... Args>
     DerivedElementType& allocateAndConstruct(Args&&... args)
     {
         static_assert(WTF::IsSubclass<DerivedElementType, BaseElementType>::value,
             "Must use subclass of BaseElementType.");
         static_assert(alignment % WTF_ALIGN_OF(DerivedElementType) == 0,
             "Derived type requires stronger alignment.");
-        size_t allocSize = align(sizeof(DerivedElementType));
-        return *new (allocate(allocSize)) DerivedElementType(std::forward<Args>(args)...);
+        return *new (alignedAllocate(sizeof(DerivedElementType))) DerivedElementType(std::forward<Args>(args)...);
     }
 
     void removeLast()
     {
         ASSERT(!isEmpty());
         last().~BaseElementType();
         ContiguousContainerBase::removeLast();
     }
 
     void clear()
     {
         for (auto& element : *this) {
             (void)element; // MSVC incorrectly reports this variable as unused.
             element.~BaseElementType();
         }
         ContiguousContainerBase::clear();
     }
 
     void swap(ContiguousContainer& other) { ContiguousContainerBase::swap(other); }
 
     // Appends a new element using memcpy, then default-constructs a base
     // element in its place. Use with care.
     BaseElementType& appendByMoving(BaseElementType& item, size_t size)
     {
         ASSERT(size >= sizeof(BaseElementType));
-        void* newItem = allocate(size);
+        void* newItem = alignedAllocate(size);
         memcpy(newItem, static_cast<void*>(&item), size);
         new (&item) BaseElementType;
         return *static_cast<BaseElementType*>(newItem);
     }
 
 private:
-    void* allocate(size_t objectSize)
+    void* alignedAllocate(size_t size)
     {
-        return ContiguousContainerBase::allocate(objectSize, WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType));
+        void* result = ContiguousContainerBase::allocate(align(size), WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType));
+        DCHECK_EQ(reinterpret_cast<intptr_t>(result) & (alignment - 1), 0u);
+        return result;
     }
 
     static size_t align(size_t size)
     {
         size_t alignedSize = alignment * ((size + alignment - 1) / alignment);
-        ASSERT(alignedSize % alignment == 0);
-        ASSERT(alignedSize >= size);
-        ASSERT(alignedSize < size + alignment);
+        DCHECK_EQ(alignedSize % alignment, 0u);
+        DCHECK_GE(alignedSize, size);
+        DCHECK_LT(alignedSize, size + alignment);
         return alignedSize;
     }
 };
 
 } // namespace blink
 
 #endif // ContiguousContainer_h