Use Custome ListContainer to Allocate SharedQuadState

cc/quads/list_container.cc

 // 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.
 
 #include "cc/quads/list_container.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/base/scoped_ptr_vector.h"
@@ skipping 69 matching lines @@
         list_count_(0),
         last_list_(NULL) {
     AllocateNewList(kDefaultNumElementTypesToReserve);
   }
 
   ListContainerCharAllocator(size_t element_size, size_t element_count)
       : element_size_(element_size),
         size_(0),
         list_count_(0),
         last_list_(NULL) {
-    DCHECK_NE(0u, element_count);
-    AllocateNewList(element_count);
+    AllocateNewList(element_count > 0 ? element_count
+                                      : kDefaultNumElementTypesToReserve);
   }
 
   ~ListContainerCharAllocator() {}
 
   void* Allocate() {
     if (last_list_->IsFull())
       AllocateNewList(last_list_->capacity * 2);
 
     ++size_;
     return last_list_->AddElement();
@@ skipping 172 matching lines @@
     typename ListContainer<BaseElementType>::Iterator position) {
   BaseElementType* item = &*position;
   item->~BaseElementType();
   data_->Erase(position);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstReverseIterator
 ListContainer<BaseElementType>::rbegin() const {
   if (data_->IsEmpty())
-    return ConstReverseIterator(data_.get(), 0, NULL);
+    return ConstReverseIterator(data_.get(), 0, NULL, 0);
 
   size_t last_id = data_->list_count() - 1;
   return ConstReverseIterator(
-      data_.get(), last_id, data_->InnerListById(last_id)->LastElement());
+      data_.get(), last_id, data_->InnerListById(last_id)->LastElement(), 0);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstReverseIterator
 ListContainer<BaseElementType>::rend() const {
-  return ConstReverseIterator(data_.get(), 0, NULL);
+  return ConstReverseIterator(data_.get(), 0, NULL, size());
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ReverseIterator
 ListContainer<BaseElementType>::rbegin() {
   if (data_->IsEmpty())
-    return ReverseIterator(data_.get(), 0, NULL);
+    return ReverseIterator(data_.get(), 0, NULL, 0);
 
   size_t last_id = data_->list_count() - 1;
   return ReverseIterator(
-      data_.get(), last_id, data_->InnerListById(last_id)->LastElement());
+      data_.get(), last_id, data_->InnerListById(last_id)->LastElement(), 0);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ReverseIterator
 ListContainer<BaseElementType>::rend() {
-  return ReverseIterator(data_.get(), 0, NULL);
+  return ReverseIterator(data_.get(), 0, NULL, size());
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstIterator
 ListContainer<BaseElementType>::begin() const {
   if (data_->IsEmpty())
-    return ConstIterator(data_.get(), 0, NULL);
+    return ConstIterator(data_.get(), 0, NULL, 0);
 
-  return ConstIterator(data_.get(), 0, data_->InnerListById(0)->Begin());
+  return ConstIterator(data_.get(), 0, data_->InnerListById(0)->Begin(), 0);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstIterator
 ListContainer<BaseElementType>::end() const {
   if (data_->IsEmpty())
-    return ConstIterator(data_.get(), 0, NULL);
+    return ConstIterator(data_.get(), 0, NULL, size());
 
   size_t last_id = data_->list_count() - 1;
-  return ConstIterator(data_.get(), last_id, NULL);
+  return ConstIterator(data_.get(), last_id, NULL, size());
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::Iterator
 ListContainer<BaseElementType>::begin() {
   if (data_->IsEmpty())
-    return Iterator(data_.get(), 0, NULL);
+    return Iterator(data_.get(), 0, NULL, 0);
 
-  return Iterator(data_.get(), 0, data_->InnerListById(0)->Begin());
+  return Iterator(data_.get(), 0, data_->InnerListById(0)->Begin(), 0);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::Iterator
 ListContainer<BaseElementType>::end() {
   if (data_->IsEmpty())
-    return Iterator(data_.get(), 0, NULL);
+    return Iterator(data_.get(), 0, NULL, size());
 
   size_t last_id = data_->list_count() - 1;
-  return Iterator(data_.get(), last_id, NULL);
+  return Iterator(data_.get(), last_id, NULL, size());
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::front() {
   Iterator iter = begin();
   return &*iter;
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::back() {
@@ skipping 10 matching lines @@
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::back() const {
   ConstReverseIterator iter = rbegin();
   return &*iter;
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::ElementAt(
     size_t index) const {
   DCHECK_LT(index, size());
+  size_t cache_index = index;

[danakj, 2014/10/02 15:32:47]

s/cache/original/

[weiliangc, 2014/10/02 22:01:39]

Done.

   size_t list_index;
   for (list_index = 0; list_index < data_->list_count(); ++list_index) {
     size_t current_size = data_->InnerListById(list_index)->size;
     if (index < current_size)
       break;
     index -= current_size;
   }
   return &*ConstIterator(data_.get(),
                          list_index,
-                         data_->InnerListById(list_index)->ElementAt(index));
+                         data_->InnerListById(list_index)->ElementAt(index),
+                         cache_index);
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::ElementAt(size_t index) {
   DCHECK_LT(index, size());
+  size_t cache_index = index;

[danakj, 2014/10/02 15:32:47]

same

[weiliangc, 2014/10/02 22:01:39]

Done.

   size_t list_index;
   for (list_index = 0; list_index < data_->list_count(); ++list_index) {
     size_t current_size = data_->InnerListById(list_index)->size;
     if (index < current_size)
       break;
     index -= current_size;
   }
   return &*Iterator(data_.get(),
                     list_index,
-                    data_->InnerListById(list_index)->ElementAt(index));
+                    data_->InnerListById(list_index)->ElementAt(index),
+                    cache_index);
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::Allocate(
     size_t size_of_actual_element_in_bytes) {
   DCHECK_LE(size_of_actual_element_in_bytes, data_->element_size());
   void* result = data_->Allocate();
   return static_cast<BaseElementType*>(result);
 }
 
@@ skipping 20 matching lines @@
     BaseElementType>::AvailableSizeWithoutAnotherAllocationForTesting() const {
   return data_->NumAvailableElementsInLastList();
 }
 
 // ListContainer::Iterator
 /////////////////////////////////////////////////
 template <typename BaseElementType>
 ListContainer<BaseElementType>::Iterator::Iterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
-    char* item_iter)
-    : PositionInListContainerCharAllocator(container, vector_ind, item_iter) {
+    char* item_iter,
+    size_t index)
+    : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
+      index_(index) {
 }
 
 template <typename BaseElementType>
 ListContainer<BaseElementType>::Iterator::~Iterator() {
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::Iterator::operator->() const {
   return reinterpret_cast<BaseElementType*>(this->item_iterator);
 }
@@ skipping 10 matching lines @@
   Iterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::Iterator
 ListContainer<BaseElementType>::Iterator::
 operator++() {
   this->Increment();
+  ++index_;
   return *this;
 }
 
+template <typename BaseElementType>
+size_t ListContainer<BaseElementType>::Iterator::index() const {
+  return index_;
+}
+
 // ListContainer::ConstIterator
 /////////////////////////////////////////////////
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ConstIterator::ConstIterator(
     const typename ListContainer<BaseElementType>::Iterator& other)
-    : PositionInListContainerCharAllocator(other) {
+    : PositionInListContainerCharAllocator(other), index_(other.index()) {
 }
 
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ConstIterator::ConstIterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
-    char* item_iter)
-    : PositionInListContainerCharAllocator(container, vector_ind, item_iter) {
+    char* item_iter,
+    size_t index)
+    : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
+      index_(index) {
 }
 
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ConstIterator::~ConstIterator() {
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::ConstIterator::
 operator->() const {
   return reinterpret_cast<const BaseElementType*>(this->item_iterator);
@@ skipping 12 matching lines @@
   ConstIterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstIterator
 ListContainer<BaseElementType>::ConstIterator::
 operator++() {
   this->Increment();
+  ++index_;
   return *this;
 }
 
+template <typename BaseElementType>
+size_t ListContainer<BaseElementType>::ConstIterator::index() const {
+  return index_;
+}
+
 // ListContainer::ReverseIterator
 /////////////////////////////////////////////////
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ReverseIterator::ReverseIterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
-    char* item_iter)
-    : PositionInListContainerCharAllocator(container, vector_ind, item_iter) {
+    char* item_iter,
+    size_t index)
+    : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
+      index_(index) {
 }
 
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ReverseIterator::~ReverseIterator() {
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::ReverseIterator::operator->()
     const {
   return reinterpret_cast<BaseElementType*>(this->item_iterator);
@@ skipping 12 matching lines @@
   ReverseIterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ReverseIterator
 ListContainer<BaseElementType>::ReverseIterator::
 operator++() {
   this->ReverseIncrement();
+  ++index_;
   return *this;
 }
 
+template <typename BaseElementType>
+size_t ListContainer<BaseElementType>::ReverseIterator::index() const {
+  return index_;
+}
+
 // ListContainer::ConstReverseIterator
 /////////////////////////////////////////////////
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ConstReverseIterator::ConstReverseIterator(
     const typename ListContainer<BaseElementType>::ReverseIterator& other)
-    : PositionInListContainerCharAllocator(other) {
+    : PositionInListContainerCharAllocator(other), index_(other.index()) {
 }
 
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ConstReverseIterator::ConstReverseIterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
-    char* item_iter)
-    : PositionInListContainerCharAllocator(container, vector_ind, item_iter) {
+    char* item_iter,
+    size_t index)
+    : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
+      index_(index) {
 }
 
 template <typename BaseElementType>
 ListContainer<BaseElementType>::ConstReverseIterator::~ConstReverseIterator() {
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::ConstReverseIterator::
 operator->() const {
   return reinterpret_cast<const BaseElementType*>(this->item_iterator);
@@ skipping 12 matching lines @@
   ConstReverseIterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstReverseIterator
 ListContainer<BaseElementType>::ConstReverseIterator::
 operator++() {
   this->ReverseIncrement();
+  ++index_;
   return *this;
 }
 
+template <typename BaseElementType>
+size_t ListContainer<BaseElementType>::ConstReverseIterator::index() const {
+  return index_;
+}
+
 template class ListContainer<SharedQuadState>;
 template class ListContainer<DrawQuad>;
 
 }  // namespace cc