WIP for display item list backed by ListContainer

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/ListContainer.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
+#include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "wtf/Forward.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/Vector.h"
 
 #include <iterator>
 
 class GraphicsContext;
 class SkPicture;
 
 namespace blink {
 
+static const size_t kMaximumDisplayItemSize = sizeof(BeginTransform3DDisplayItem);
+
 // Encapsulates logic for dealing with a simple list of display items, as
 // opposed to DisplayItemList, which also manages the logic required for caching
 // and updating them.
 //
 // This is presently implemented on top of a vector of pointers, but the
 // implementation is intended to change in the future.
 class PLATFORM_EXPORT DisplayItems {
     WTF_MAKE_NONCOPYABLE(DisplayItems);
 public:
     // Holds a handle to an individual item, and provides restricted access to
@@ skipping 43 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;
-        Iterator(const InternalIterator& it) : m_iterator(it) { }
+        using InternalIterator = Vector<DisplayItem*>::iterator;
+        Iterator(const InternalIterator& it, DisplayItems* owningList) : m_iterator(it), m_owningList(owningList) { }
         InternalIterator m_iterator;
+        DisplayItems* m_owningList;
         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; }
+        ConstIterator(const Iterator& it, const DisplayItems* owningList) : m_iterator(it.m_iterator), m_owningList(owningList) { }
+        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;
-        ConstIterator(const InternalIterator& it) : m_iterator(it) { }
+        using InternalIterator = Vector<DisplayItem*>::const_iterator;
+        ConstIterator(const InternalIterator& it, const DisplayItems* owningList) : m_iterator(it), m_owningList(owningList) { }
         InternalIterator m_iterator;
+        const DisplayItems* m_owningList;
         mutable ItemHandle m_handle;
         friend class DisplayItems;
     };
 
-    DisplayItems();
+    DisplayItems(size_t reserveCapacity)
+        : m_ptrs()
+        , m_items(reserveCapacity, kMaximumDisplayItemSize)
+    {
+        m_ptrs.reserveCapacity(reserveCapacity);
+    }
+
     ~DisplayItems();
 
-    bool isEmpty() const { return m_items.isEmpty(); }
-    size_t size() const { return m_items.size(); }
+    bool isEmpty() const { return m_ptrs.isEmpty(); }
+    size_t size() const { return m_ptrs.size(); }
 
     // Random access may not remain O(1) in the future.
-    ItemHandle operator[](size_t index) const { return ItemHandle(m_items[index].get()); }
-    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(); }
+    ItemHandle operator[](size_t index) const { return ItemHandle(m_ptrs[index]); }
+    Iterator iteratorAt(size_t index) { return Iterator(m_ptrs.begin() + index, this); }
+    ConstIterator iteratorAt(size_t index) const { return ConstIterator(m_ptrs.begin() + index, this); }
+    size_t indexForIterator(const Iterator& it) const { return it.m_iterator - m_ptrs.begin(); }
+    size_t indexForIterator(const ConstIterator& it) const { return it.m_iterator - m_ptrs.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()); }
+    Iterator begin() { return Iterator(m_ptrs.begin(), this); }
+    Iterator end() { return Iterator(m_ptrs.end(), this); }
+    ConstIterator begin() const { return ConstIterator(m_ptrs.begin(), this); }
+    ConstIterator end() const { return ConstIterator(m_ptrs.end(), this); }
 
     // Access to the end of the list should also be fast.
-    ItemHandle last() const { return ItemHandle(m_items.last().get()); }
+    ItemHandle last() const { return ItemHandle(m_ptrs.last()); }
 
-    // TODO(jbroman): Replace this with something that doesn't first require
-    // heap allocation.
-    void append(PassOwnPtr<DisplayItem>);
+    template<typename DisplayItemClass>
+    DisplayItemClass& createAndAppend()
+    {
+        static_assert(WTF::IsSubclass<DisplayItemClass, DisplayItem>::value,
+            "Can only emplace subclasses of DisplayItem.");
+        static_assert(sizeof(DisplayItemClass) <= kMaximumDisplayItemSize,
+            "DisplayItem subclass is larger than storage buffer.");
+
+        DisplayItemClass& item = *m_items.allocateAndConstruct<DisplayItemClass>();
+        m_ptrs.append(&item);
+        return item;
+    }
 
     // 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&);
 
     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;
+    // Non-owning list of pointers into m_items to support both fast iteration and
+    // the {set,is}Gone concept.
+    // TODO(pdr): Remove or clairify {set,is}Gone.
+    Vector<DisplayItem*> m_ptrs;
+    ListContainer<DisplayItem> m_items;
 };
 
 } // namespace blink
 
 #endif // DisplayItems_h