Blink-side contiguous allocation of display items.

Source/platform/graphics/ListContainer.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 ListContainer_h
 #define ListContainer_h
 
 #include "platform/PlatformExport.h"
 #include "wtf/Forward.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/OwnPtr.h"
+#include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 #include <iterator>
 
 namespace blink {
 
 // ListContainer is a copy of cc/base/list_container.h and is only here
 // temporarily pending the Blink merge.
 //
 // Use of this class is discouraged.
@@ skipping 205 matching lines @@
 
     // TODO(weiliangc): front(), back() and elementAt() function should return
     // reference, consistent with container-of-object.
     BaseElementType* front() { return *begin(); }
     BaseElementType* back() { return *rbegin(); }
     const BaseElementType* front() const { return *begin(); }
     const BaseElementType* back() const { return *rbegin(); }
 
     BaseElementType* elementAt(size_t index)
     {
-        return *Iterator(iteratorAt(index));
+        return *iteratorAt(index);
     }
+
     const BaseElementType* elementAt(size_t index) const
     {
-        return *ConstIterator(iteratorAt(index));
+        return *iteratorAt(index);
+    }
+
+    Iterator iteratorAt(size_t index)
+    {
+        return Iterator(ListContainerBase::iteratorAt(index));
+    }
+
+    ConstIterator iteratorAt(size_t index) const
+    {
+        return ConstIterator(ListContainerBase::iteratorAt(index));
     }
 
     // Take in derived element type and construct it at location generated by Allocate().
-    template <typename DerivedElementType>
-    DerivedElementType* allocateAndConstruct()
+    template <typename DerivedElementType, typename... Args>
+    DerivedElementType* allocateAndConstruct(Args&&... args)
     {
-        return new (allocate(sizeof(DerivedElementType))) DerivedElementType;
+        return new (allocate(sizeof(DerivedElementType))) DerivedElementType(WTF::forward<Args>(args)...);

[danakj, 2015/06/30 18:49:01]

Can you add a unit test with non-0 number of arguments? Maybe something moveonly
like OwnPtr?

[pdr., 2015/06/30 22:16:06]

Done, added ListContainerTest::AllocateAndConstructWithArguments which uses an
OwnPtr<SimpleDerivedElement>.

     }
 
     // Take in derived element type and copy construct it at location generated by
     // Allocate().
     template <typename DerivedElementType>
     DerivedElementType* allocateAndCopyFrom(const DerivedElementType* source)
     {
         return new (allocate(sizeof(DerivedElementType))) DerivedElementType(*source);
     }
 
     // Construct a new element on top of an existing one.
     template <typename DerivedElementType>
     DerivedElementType* replaceExistingElement(Iterator at)
     {
         at->~BaseElementType();
         return new (*at) DerivedElementType();
     }
 
     template <typename DerivedElementType>
     void swap(ListContainer<DerivedElementType>& other)
     {
         m_data.swap(other.m_data);
     }
 
     // Appends a new item without copying. The original item will not be
     // destructed and will be replaced with a new DerivedElementType. The
     // DerivedElementType does not have to match the moved type as a full block
-    // of memory will be moved (up to maxSizeForDerivedClass()).
+    // of memory will be moved (up to maxSizeForDerivedClass()). A pointer
+    // to the moved element is returned.
     template <typename DerivedElementType>
-    void appendByMoving(DerivedElementType* item)
+    DerivedElementType* appendByMoving(DerivedElementType* item)
     {
         size_t maxSize = maxSizeForDerivedClass();
         void* newItem = allocate(maxSize);
         memcpy(newItem, static_cast<void*>(item), maxSize);
         // Construct a new element in-place so it can be destructed safely.
         new (item) DerivedElementType;
+        return static_cast<DerivedElementType*>(newItem);
     }
 
     using ListContainerBase::size;
     using ListContainerBase::empty;
 
     void clear()
     {
         for (Iterator i = begin(); i != end(); ++i)
             i->~BaseElementType();
         ListContainerBase::clear();
@@ skipping 24 matching lines @@
             ++m_index;
             return *this;
         }
 
     private:
         explicit Iterator(const ListContainerBase::Iterator& baseIterator)
             : ListContainerBase::Iterator(baseIterator) {}
         friend Iterator ListContainer<BaseElementType>::begin();
         friend Iterator ListContainer<BaseElementType>::end();
         friend BaseElementType* ListContainer<BaseElementType>::elementAt(size_t index);
+        friend Iterator ListContainer<BaseElementType>::iteratorAt(size_t index);
     };
 
     class ConstIterator : public ListContainerBase::ConstIterator {
     // This class is only defined to forward iterate through
     // ListContainerCharAllocator.
     public:
         ConstIterator(ListContainerCharAllocator* container, size_t vectorIndex, char* itemIter, size_t index)
             : ListContainerBase::ConstIterator(container, vectorIndex, itemIter, index) {}
         ConstIterator(const Iterator& other)
             : ListContainerBase::ConstIterator(other) {}
@@ skipping 18 matching lines @@
             ++m_index;
             return *this;
         }
 
     private:
         explicit ConstIterator(const ListContainerBase::ConstIterator& baseIterator)
             : ListContainerBase::ConstIterator(baseIterator) {}
         friend ConstIterator ListContainer<BaseElementType>::cbegin() const;
         friend ConstIterator ListContainer<BaseElementType>::cend() const;
         friend const BaseElementType* ListContainer<BaseElementType>::elementAt(size_t index) const;
+        friend ConstIterator ListContainer<BaseElementType>::iteratorAt(size_t index) const;
     };
 
     class ReverseIterator : public ListContainerBase::ReverseIterator {
     // This class is only defined to reverse iterate through
     // ListContainerCharAllocator.
     public:
         ReverseIterator(ListContainerCharAllocator* container, size_t vectorIndex, char* itemIter, size_t index)
             : ListContainerBase::ReverseIterator(container, vectorIndex, itemIter, index) {}
 
         BaseElementType* operator->() const
@@ skipping 58 matching lines @@
         explicit ConstReverseIterator(ListContainerBase::ConstReverseIterator baseIterator)
             : ListContainerBase::ConstReverseIterator(baseIterator) {}
         friend ConstReverseIterator ListContainer<BaseElementType>::crbegin() const;
         friend ConstReverseIterator ListContainer<BaseElementType>::crend() const;
     };
 };
 
 } // namespace blink
 
 #endif // ListContainer_h