Blink-side contiguous allocation of display items.

Source/platform/graphics/paint/DisplayItems.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 DisplayItems_h
 #define DisplayItems_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
+#include "wtf/Alignment.h"
 #include "wtf/Forward.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/OwnPtr.h"
+#include "wtf/StdLibExtras.h"
+#include "wtf/TypeTraits.h"
+#include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 #include <iterator>
 
 class GraphicsContext;
 class SkPicture;
 
 namespace blink {
 
 // Encapsulates logic for dealing with a simple list of display items, as
@@ skipping 52 matching lines @@
         ItemHandle() : m_ptr(nullptr) { }
         explicit ItemHandle(DisplayItem* ptr) : m_ptr(ptr) { }
 
         DisplayItem* m_ptr;
         friend class DisplayItems;
     };
 
     // Input iterators over the display items.
     class Iterator : public std::iterator<std::input_iterator_tag, const ItemHandle> {
     public:
-        const ItemHandle& operator*() const { m_handle = ItemHandle(m_iterator->get()); return m_handle; }
+        const ItemHandle& operator*() const { m_handle = ItemHandle(*m_iterator); return m_handle; }
         const ItemHandle* operator->() const { return &operator*(); }
         Iterator& operator++() { ++m_iterator; return *this; }
         Iterator operator++(int) { Iterator tmp(*this); operator++(); return tmp; }
         bool operator==(const Iterator& other) const { return m_iterator == other.m_iterator; }
         bool operator!=(const Iterator& other) const { return !(*this == other); }
     private:
-        using InternalIterator = Vector<OwnPtr<DisplayItem>>::iterator;
+        using InternalIterator = Vector<DisplayItem*>::iterator;
         Iterator(const InternalIterator& it) : m_iterator(it) { }
         InternalIterator m_iterator;
         mutable ItemHandle m_handle;
         friend class DisplayItems;
         friend class ConstIterator;
     };
     class ConstIterator : public std::iterator<std::input_iterator_tag, const ItemHandle> {
     public:
         ConstIterator(const Iterator& it) : m_iterator(it.m_iterator) { }
-        const ItemHandle& operator*() const { m_handle = ItemHandle(m_iterator->get()); return m_handle; }
+        const ItemHandle& operator*() const { m_handle = ItemHandle(*m_iterator); return m_handle; }
         const ItemHandle* operator->() const { return &operator*(); }
         ConstIterator& operator++() { ++m_iterator; return *this; }
         ConstIterator operator++(int) { ConstIterator tmp(*this); operator++(); return tmp; }
         bool operator==(const ConstIterator& other) const { return m_iterator == other.m_iterator; }
         bool operator!=(const ConstIterator& other) const { return !(*this == other); }
     private:
-        using InternalIterator = Vector<OwnPtr<DisplayItem>>::const_iterator;
+        using InternalIterator = Vector<DisplayItem*>::const_iterator;
         ConstIterator(const InternalIterator& it) : m_iterator(it) { }
         InternalIterator m_iterator;
         mutable ItemHandle m_handle;
         friend class DisplayItems;
     };
 
     DisplayItems();
     ~DisplayItems();
 
     bool isEmpty() const { return m_items.isEmpty(); }
     size_t size() const { return m_items.size(); }
 
     // Random access may not remain O(1) in the future.
-    ItemHandle operator[](size_t index) const { return ItemHandle(m_items[index].get()); }
+    ItemHandle operator[](size_t index) const { return ItemHandle(m_items[index]); }
     Iterator iteratorAt(size_t index) { return Iterator(m_items.begin() + index); }
     ConstIterator iteratorAt(size_t index) const { return ConstIterator(m_items.begin() + index); }
     size_t indexForIterator(const Iterator& it) const { return it.m_iterator - m_items.begin(); }
     size_t indexForIterator(const ConstIterator& it) const { return it.m_iterator - m_items.begin(); }
 
     // Input iteration, however, should remain cheap.
     Iterator begin() { return Iterator(m_items.begin()); }
     Iterator end() { return Iterator(m_items.end()); }
     ConstIterator begin() const { return ConstIterator(m_items.begin()); }
     ConstIterator end() const { return ConstIterator(m_items.end()); }
 
     // Access to the end of the list should also be fast.
-    ItemHandle last() const { return ItemHandle(m_items.last().get()); }
-
-    // TODO(jbroman): Replace this with something that doesn't first require
-    // heap allocation.
-    void append(PassOwnPtr<DisplayItem>);
+    ItemHandle last() const { return ItemHandle(m_items.last()); }
 
     // Appends by moving from another list. The item in the list it's being
     // removed from will become "gone" in this process, but can still be safely
     // destroyed.
     void appendByMoving(const Iterator&);
 
+    template <typename DisplayItemClass, typename... Args>
+    DisplayItemClass& emplaceBack(Args&&... args)
+    {
+        static_assert(WTF::IsSubclass<DisplayItemClass, DisplayItem>::value,
+            "Can only emplace subclasses of DisplayItem.");
+        static_assert(sizeof(DisplayItemClass) <= maxSize,
+            "DisplayItem subclass is larger than storage buffer.");
+        static_assert(maxAlign % WTF_ALIGN_OF(DisplayItemClass) == 0,
+            "DisplayItem subclass isn't aligned in storage buffer.");
+        DisplayItemClass* displayItem =
+            static_cast<DisplayItemClass*>(appendStorageBuffer().asDisplayItem());
+        new (displayItem) DisplayItemClass(WTF::forward<Args>(args)...);
+        m_items.append(displayItem);
+        return *displayItem;
+    }
+
     void removeLast();
     void clear();
 
     // TODO(jbroman): Is swap the right primitive?
     void swap(DisplayItems&);
 
     // TODO(jbroman): This abstraction is odd and it would be nice to explain it
     // more clearly.
     void setGone(const Iterator&);
 
 private:
-    Vector<OwnPtr<DisplayItem>> m_items;
+    // TODO(jbroman): These need to be kept up to date.
+    // There are compile-time checks to make sure they aren't invalid, at least.
+    // Currently Transform3DDisplayItem is the most constraining.
+    static const size_t maxSize = 64 + sizeof(double) * 16 + sizeof(float) * 4;
+    static const size_t maxAlign = 16;
+
+    // A DisplayItem must be constructed into asDisplayItem() immediately after
+    // construction (at a minimum, before destruction).
+    class StorageBuffer {
+        WTF_MAKE_NONCOPYABLE(StorageBuffer);
+    public:
+        StorageBuffer() { }
+        ~StorageBuffer() { asDisplayItem()->~DisplayItem(); }
+        DisplayItem* asDisplayItem() { return reinterpret_cast_ptr<DisplayItem*>(&m_buffer); }
+    private:
+        WTF::AlignedBuffer<maxSize, maxAlign> m_buffer;
+    };
+
+    using InnerVector = Vector<StorageBuffer>;
+    using OuterVector = Vector<OwnPtr<InnerVector>, 8>;
+
+    StorageBuffer& appendStorageBuffer();
+
+    OuterVector m_buffers;
+
+    // Non-owning pointers into m_buffers.
+    Vector<DisplayItem*> m_items;
 };
 
 } // namespace blink
 
 #endif // DisplayItems_h