Fix alignment issue of ContiguousContainer

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

 // 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.
 
 #include "platform/graphics/ContiguousContainer.h"
 
 #include "wtf/Allocator.h"
 #include "wtf/ContainerAnnotations.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/allocator/PartitionAlloc.h"
 #include "wtf/allocator/Partitions.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 // Default number of max-sized elements to allocate space for, if there is no
 // initial buffer.
 static const unsigned kDefaultInitialBufferSize = 32;
 
+static inline char* alignAddress(char* address, size_t alignment)
+{
+    char* aligned = reinterpret_cast<char*>(alignment * ((reinterpret_cast<size_t>(address) + alignment - 1) / alignment));
+    DCHECK_EQ(0u, reinterpret_cast<size_t>(aligned) % alignment);
+    DCHECK(aligned >= address);
+    DCHECK(aligned < address + alignment);
+    return aligned;
+}
+
 class ContiguousContainerBase::Buffer {
     WTF_MAKE_NONCOPYABLE(Buffer);
     USING_FAST_MALLOC(Buffer);
 public:
     Buffer(size_t bufferSize, const char* typeName)
     {
         m_capacity = WTF::Partitions::bufferActualSize(bufferSize);
         m_begin = m_end = static_cast<char*>(
             WTF::Partitions::bufferMalloc(m_capacity, typeName));
         ANNOTATE_NEW_BUFFER(m_begin, m_capacity, 0);
     }
 
     ~Buffer()
     {
         ANNOTATE_DELETE_BUFFER(m_begin, m_capacity, usedCapacity());
         WTF::Partitions::bufferFree(m_begin);
     }
 
     size_t capacity() const { return m_capacity; }
     size_t usedCapacity() const { return m_end - m_begin; }
-    size_t unusedCapacity() const { return capacity() - usedCapacity(); }
     bool isEmpty() const { return usedCapacity() == 0; }
 
-    void* allocate(size_t objectSize)
+    void* allocate(size_t objectSize, size_t alignment)
     {
-        ASSERT(unusedCapacity() >= objectSize);
+        char* alignedAddress = alignAddress(m_end, alignment);
+        if (alignedAddress - m_begin + objectSize > m_capacity)
+            return nullptr;
         ANNOTATE_CHANGE_SIZE(
-            m_begin, m_capacity, usedCapacity(), usedCapacity() + objectSize);
-        void* result = m_end;
-        m_end += objectSize;
-        return result;
+            m_begin, m_capacity, usedCapacity(), usedCapacity() + (alignedAddress - m_end) + objectSize);
+        if (isEmpty())
+            m_firstObject = alignedAddress;
+        m_end = alignedAddress + objectSize;
+        return alignedAddress;
     }
 
     void deallocateLastObject(void* object)
     {
         RELEASE_ASSERT(m_begin <= object && object < m_end);
         ANNOTATE_CHANGE_SIZE(
             m_begin, m_capacity, usedCapacity(), static_cast<char*>(object) - m_begin);
         m_end = static_cast<char*>(object);
+        if (m_end == m_firstObject) {
+            // We have deallocated the first object in this buffer. Reset m_end so that
+            // isEmpty() can return correct value.
+            m_end = m_begin;
+        }
+        // Otherwise we may leave a gap between the end of the previous object (which we
+        // don't know) and m_end because of alignment of the deallocated object.
     }
 
 private:
-    // m_begin <= m_end <= m_begin + m_capacity
+    // m_begin <= m_firstObject <= m_end <= m_begin + m_capacity
     char* m_begin;
+    // Because of alignment, the first object may be allocated after m_begin.
+    char* m_firstObject;
     char* m_end;
     size_t m_capacity;
 };
 
 ContiguousContainerBase::ContiguousContainerBase(size_t maxObjectSize)
     : m_endIndex(0)
     , m_maxObjectSize(maxObjectSize)
 {
 }
 
@@ skipping 33 matching lines @@
 {
     return sizeof(*this) + capacityInBytes()
         + m_elements.capacity() * sizeof(m_elements[0]);
 }
 
 void ContiguousContainerBase::reserveInitialCapacity(size_t bufferSize, const char* typeName)
 {
     allocateNewBufferForNextAllocation(bufferSize, typeName);
 }
 
-void* ContiguousContainerBase::allocate(size_t objectSize, const char* typeName)
+void* ContiguousContainerBase::allocate(size_t objectSize, size_t alignment, const char* typeName)
 {
-    ASSERT(objectSize <= m_maxObjectSize);
+    DCHECK(objectSize <= m_maxObjectSize);
 
-    Buffer* bufferForAlloc = nullptr;
-    if (!m_buffers.isEmpty()) {
-        Buffer* endBuffer = m_buffers[m_endIndex].get();
-        if (endBuffer->unusedCapacity() >= objectSize)
-            bufferForAlloc = endBuffer;
-        else if (m_endIndex + 1 < m_buffers.size())
+    void* element = m_buffers.isEmpty() ? nullptr : m_buffers[m_endIndex]->allocate(objectSize, alignment);
+    if (!element) {
+        Buffer* bufferForAlloc;
+        if (m_endIndex + 1 < m_buffers.size()) {
             bufferForAlloc = m_buffers[++m_endIndex].get();
+        } else {
+            size_t newBufferSize = m_buffers.isEmpty()
+                ? kDefaultInitialBufferSize * m_maxObjectSize
+                : 2 * m_buffers.last()->capacity();
+            bufferForAlloc = allocateNewBufferForNextAllocation(newBufferSize, typeName);
+        }
+        element = bufferForAlloc->allocate(objectSize, alignment);
+        DCHECK(element);
     }
-
-    if (!bufferForAlloc) {
-        size_t newBufferSize = m_buffers.isEmpty()
-            ? kDefaultInitialBufferSize * m_maxObjectSize
-            : 2 * m_buffers.last()->capacity();
-        bufferForAlloc = allocateNewBufferForNextAllocation(newBufferSize, typeName);
-    }
-
-    void* element = bufferForAlloc->allocate(objectSize);
     m_elements.append(element);
     return element;
 }
 
 void ContiguousContainerBase::removeLast()
 {
     void* object = m_elements.last();
     m_elements.removeLast();
 
     Buffer* endBuffer = m_buffers[m_endIndex].get();
@@ skipping 27 matching lines @@
 {
     ASSERT(m_buffers.isEmpty() || m_endIndex == m_buffers.size() - 1);
     std::unique_ptr<Buffer> newBuffer = wrapUnique(new Buffer(bufferSize, typeName));
     Buffer* bufferToReturn = newBuffer.get();
     m_buffers.append(std::move(newBuffer));
     m_endIndex = m_buffers.size() - 1;
     return bufferToReturn;
 }
 
 } // namespace blink