Implement DrawQuad StructTraits

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 <stddef.h>
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/list_container_helper.h"
 
 namespace cc {
 
 // ListContainer is a container type that handles allocating contiguous memory
 // for new elements and traversing through elements with either iterator or
 // reverse iterator. Since this container hands out raw pointers of its
 // elements, it is very important that this container never reallocate its
 // memory so those raw pointer will continue to be valid.  This class is used to
 // contain SharedQuadState or DrawQuad. Since the size of each DrawQuad varies,
 // to hold DrawQuads, the allocations size of each element in this class is
 // LargestDrawQuadSize while BaseElementType is DrawQuad.
 template <class BaseElementType>
 class ListContainer {
  public:
+  ListContainer(ListContainer<BaseElementType>&& other) {
+    helper_.data_.swap(other.helper_.data_);
+  }
+
   // BaseElementType is the type of raw pointers this class hands out; however,
   // its derived classes might require different memory sizes.
   // max_size_for_derived_class the largest memory size required for all the
   // derived classes to use for allocation.
   explicit ListContainer(size_t max_size_for_derived_class)
       : helper_(max_size_for_derived_class) {}
 
   // This constructor omits input variable for max_size_for_derived_class. This
   // is used when there is no derived classes from BaseElementType we need to
   // worry about, and allocation size is just sizeof(BaseElementType).
@@ skipping 97 matching lines @@
   Iterator InsertBeforeAndInvalidateAllPointers(Iterator at, size_t count) {
     helper_.InsertBeforeAndInvalidateAllPointers(&at, count);
     Iterator result = at;
     for (size_t i = 0; i < count; ++i) {
       new (at.item_iterator) DerivedElementType();
       ++at;
     }
     return result;
   }
 
+  ListContainer<BaseElementType>& operator=(

[dcheng, 2016/06/15 12:27:19]

<BaseElementType> shouldn't be needed here.

[Fady Samuel, 2016/06/15 14:46:25]

Done. Also turns out I don't need the move constructor either. I just need the
move assignment operator.

+      ListContainer<BaseElementType>&& other) {
+    helper_.data_.swap(other.helper_.data_);
+    return *this;
+  }
+
   template <typename DerivedElementType>
   void swap(ListContainer<DerivedElementType>& other) {
     helper_.data_.swap(other.helper_.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()). A pointer to
   // the moved element is returned.
@@ skipping 181 matching lines @@
 
  private:
   ListContainerHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ListContainer);
 };
 
 }  // namespace cc
 
 #endif  // CC_BASE_LIST_CONTAINER_H_