Add ListContainer::appendByMoving

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"
@@ skipping 131 matching lines @@
     ConstIterator cend() const;
     Iterator begin();
     Iterator end();
 
     Iterator iteratorAt(size_t index);
     ConstIterator iteratorAt(size_t index) const;
 
     size_t size() const;
     bool empty() const;
 
+    size_t maxSizeForDerivedClass() const;
+
     // Unlike the ListContainer method, this one does not invoke element destructors.
     void clear();
 
     size_t availableSizeWithoutAnotherAllocationForTesting() const;
 
     // Hands out memory location for an element at the end of data structure.
     void* allocate(size_t sizeOfActualElementInBytes);
 
     OwnPtr<ListContainerCharAllocator> m_data;
 };
@@ skipping 93 matching lines @@
     }
 
     // Construct a new element on top of an existing one.
     template <typename DerivedElementType>
     DerivedElementType* replaceExistingElement(Iterator at)
     {
         at->~BaseElementType();
         return new (*at) DerivedElementType();
     }
 
+    // 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()).
+    template <typename DerivedElementType>
+    void 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;
+    }
+
     using ListContainerBase::size;
     using ListContainerBase::empty;
 
     void clear()
     {
         for (Iterator i = begin(); i != end(); ++i)
             i->~BaseElementType();
         ListContainerBase::clear();
     }
 
@@ skipping 138 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