Add ListContainer::AppendByMoving

cc/base/list_container.h

 // Copyright 2014 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 CC_BASE_LIST_CONTAINER_H_
 #define CC_BASE_LIST_CONTAINER_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 143 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 size_of_actual_element_in_bytes);
 
   scoped_ptr<ListContainerCharAllocator> data_;
@@ skipping 102 matching lines @@
   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();
   }
+  // Appends a new item without copying. The original item will not be

[danakj, 2015/06/23 20:01:12]

nit: add whitespace above this

[pdr., 2015/06/23 21:42:42]

Done. I also added spaces to the 3 others above (ReplaceExistingElement,
AllocateAndCopyFrom, AllocateAndConstruct) for consistency.

+  // destructed and will be replaced with a new DerivedElementType.

[danakj, 2015/06/23 20:01:12]

Can you also mention that the DerivedElementType does not have to match the type
of the original item, since we will copy the full allocated block of bytes?

[pdr., 2015/06/23 21:42:41]

Done.

Comment now reads:
// 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* other_item) {
+    size_t max_size_for_derived_class = MaxSizeForDerivedClass();
+    void* new_item = Allocate(max_size_for_derived_class);
+    memcpy(new_item, (void*)other_item, max_size_for_derived_class);

[danakj, 2015/06/23 20:01:12]

why do you have to (void*)? and if so, use static_cast.

[pdr., 2015/06/23 21:42:41]

The c-style cats have been replaced with static_cats.

+    new (other_item) DerivedElementType;

[danakj, 2015/06/23 20:01:12]

can you leave a comment explaining this is overwriting the old memory with a new
DerivedElementType?

[pdr., 2015/06/23 21:42:42]

Done. The comment now reads:
// Construct a new element in-pace so it can be destructed safely.

+  }
 
   using ListContainerBase::size;
   using ListContainerBase::empty;
 
   void clear() {
     for (Iterator i = begin(); i != end(); ++i) {
       i->~BaseElementType();
     }
     ListContainerBase::clear();
   }
@@ skipping 151 matching lines @@
         ListContainerBase::ConstReverseIterator base_iterator)
         : ListContainerBase::ConstReverseIterator(base_iterator) {}
     friend ConstReverseIterator ListContainer<BaseElementType>::crbegin() const;
     friend ConstReverseIterator ListContainer<BaseElementType>::crend() const;
   };
 };
 
 }  // namespace cc
 
 #endif  // CC_BASE_LIST_CONTAINER_H_