cc: Switch ListContainer to use composition instead of inheritance.

cc/base/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/base/list_container.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/base/scoped_ptr_vector.h"
 
 namespace {
 const size_t kDefaultNumElementTypesToReserve = 32;
 }  // namespace
 
 namespace cc {
 
 // ListContainerCharAllocator
 ////////////////////////////////////////////////////
 // This class deals only with char* and void*. It does allocation and passing
 // out raw pointers, as well as memory deallocation when being destroyed.
-class ListContainerBase::ListContainerCharAllocator {
+class ListContainerHelper::ListContainerCharAllocator {
  public:
   // ListContainerCharAllocator::InnerList
   /////////////////////////////////////////////
   // This class holds the raw memory chunk, as well as information about its
   // size and availability.
   struct InnerList {
     scoped_ptr<char[]> data;
     // The number of elements in total the memory can hold. The difference
     // between capacity and size is the how many more elements this list can
     // hold.
@@ skipping 145 matching lines @@
     InnerList* list = storage_[position->vector_index];
     char* item_iterator = position->item_iterator;
     if (item_iterator == list->LastElement())
       position->Increment();
 
     list->Erase(item_iterator);
     // TODO(weiliangc): Free the InnerList if it is empty.
     --size_;
   }
 
-  void InsertBefore(ListContainerBase::Iterator* position, size_t count) {
+  void InsertBefore(ListContainerHelper::Iterator* position, size_t count) {
     if (!count)
       return;
 
     // If |position| is End(), then append |count| elements at the end. This
     // will happen to not invalidate any iterators or memory.
     if (!position->item_iterator) {
       // Set |position| to be the first inserted element.
       Allocate();
       position->vector_index = storage_.size() - 1;
       position->item_iterator = storage_[position->vector_index]->LastElement();
@@ skipping 57 matching lines @@
   size_t last_list_index_;
 
   // This is equivalent to |storage_[last_list_index_]|.
   InnerList* last_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ListContainerCharAllocator);
 };
 
 // PositionInListContainerCharAllocator
 //////////////////////////////////////////////////////
-ListContainerBase::PositionInListContainerCharAllocator::
+ListContainerHelper::PositionInListContainerCharAllocator::
     PositionInListContainerCharAllocator(
-        const ListContainerBase::PositionInListContainerCharAllocator& other)
+        const ListContainerHelper::PositionInListContainerCharAllocator& other)
     : ptr_to_container(other.ptr_to_container),
       vector_index(other.vector_index),
-      item_iterator(other.item_iterator) {
-}
+      item_iterator(other.item_iterator) {}
 
-ListContainerBase::PositionInListContainerCharAllocator::
+ListContainerHelper::PositionInListContainerCharAllocator::
     PositionInListContainerCharAllocator(
-        ListContainerBase::ListContainerCharAllocator* container,
+        ListContainerHelper::ListContainerCharAllocator* container,
         size_t vector_ind,
         char* item_iter)
     : ptr_to_container(container),
       vector_index(vector_ind),
-      item_iterator(item_iter) {
-}
+      item_iterator(item_iter) {}
 
-bool ListContainerBase::PositionInListContainerCharAllocator::operator==(
-    const ListContainerBase::PositionInListContainerCharAllocator& other)
+bool ListContainerHelper::PositionInListContainerCharAllocator::operator==(
+    const ListContainerHelper::PositionInListContainerCharAllocator& other)
     const {
   DCHECK_EQ(ptr_to_container, other.ptr_to_container);
   return vector_index == other.vector_index &&
          item_iterator == other.item_iterator;
 }
 
-bool ListContainerBase::PositionInListContainerCharAllocator::operator!=(
-    const ListContainerBase::PositionInListContainerCharAllocator& other)
+bool ListContainerHelper::PositionInListContainerCharAllocator::operator!=(
+    const ListContainerHelper::PositionInListContainerCharAllocator& other)
     const {
   return !(*this == other);
 }
 
-ListContainerBase::PositionInListContainerCharAllocator
-ListContainerBase::PositionInListContainerCharAllocator::Increment() {
+ListContainerHelper::PositionInListContainerCharAllocator
+ListContainerHelper::PositionInListContainerCharAllocator::Increment() {
   ListContainerCharAllocator::InnerList* list =
       ptr_to_container->InnerListById(vector_index);
   if (item_iterator == list->LastElement()) {
     ++vector_index;
     while (vector_index < ptr_to_container->list_count()) {
       if (ptr_to_container->InnerListById(vector_index)->size != 0)
         break;
       ++vector_index;
     }
     if (vector_index < ptr_to_container->list_count())
       item_iterator = ptr_to_container->InnerListById(vector_index)->Begin();
     else
       item_iterator = NULL;
   } else {
     item_iterator += list->step;
   }
   return *this;
 }
 
-ListContainerBase::PositionInListContainerCharAllocator
-ListContainerBase::PositionInListContainerCharAllocator::ReverseIncrement() {
+ListContainerHelper::PositionInListContainerCharAllocator
+ListContainerHelper::PositionInListContainerCharAllocator::ReverseIncrement() {
   ListContainerCharAllocator::InnerList* list =
       ptr_to_container->InnerListById(vector_index);
   if (item_iterator == list->Begin()) {
     --vector_index;
     // Since |vector_index| is unsigned, we compare < list_count() instead of
     // comparing >= 0, as the variable will wrap around when it goes out of
     // range (below 0).
     while (vector_index < ptr_to_container->list_count()) {
       if (ptr_to_container->InnerListById(vector_index)->size != 0)
         break;
       --vector_index;
     }
     if (vector_index < ptr_to_container->list_count()) {
       item_iterator =
           ptr_to_container->InnerListById(vector_index)->LastElement();
     } else {
       item_iterator = NULL;
     }
   } else {
     item_iterator -= list->step;
   }
   return *this;
 }
 
-// ListContainerBase
+// ListContainerHelper
 ////////////////////////////////////////////
-ListContainerBase::ListContainerBase(size_t max_size_for_derived_class)
-    : data_(new ListContainerCharAllocator(max_size_for_derived_class)) {
-}
+ListContainerHelper::ListContainerHelper(size_t max_size_for_derived_class)
+    : data_(new ListContainerCharAllocator(max_size_for_derived_class)) {}
 
-ListContainerBase::ListContainerBase(size_t max_size_for_derived_class,
-                                     size_t num_of_elements_to_reserve_for)
+ListContainerHelper::ListContainerHelper(size_t max_size_for_derived_class,
+                                         size_t num_of_elements_to_reserve_for)
     : data_(new ListContainerCharAllocator(max_size_for_derived_class,
-                                           num_of_elements_to_reserve_for)) {
-}
+                                           num_of_elements_to_reserve_for)) {}
 
-ListContainerBase::~ListContainerBase() {
-}
+ListContainerHelper::~ListContainerHelper() {}
 
-void ListContainerBase::RemoveLast() {
+void ListContainerHelper::RemoveLast() {
   data_->RemoveLast();
 }
 
-void ListContainerBase::EraseAndInvalidateAllPointers(
-    ListContainerBase::Iterator* position) {
+void ListContainerHelper::EraseAndInvalidateAllPointers(
+    ListContainerHelper::Iterator* position) {
   data_->Erase(position);
 }
 
-void ListContainerBase::InsertBeforeAndInvalidateAllPointers(
-    ListContainerBase::Iterator* position,
+void ListContainerHelper::InsertBeforeAndInvalidateAllPointers(
+    ListContainerHelper::Iterator* position,
     size_t count) {
   data_->InsertBefore(position, count);
 }
 
-ListContainerBase::ConstReverseIterator ListContainerBase::crbegin() const {
+ListContainerHelper::ConstReverseIterator ListContainerHelper::crbegin() const {
   if (data_->IsEmpty())
     return crend();
 
   size_t id = data_->LastInnerListId();
   return ConstReverseIterator(data_.get(), id,
                               data_->InnerListById(id)->LastElement(), 0);
 }
 
-ListContainerBase::ConstReverseIterator ListContainerBase::crend() const {
+ListContainerHelper::ConstReverseIterator ListContainerHelper::crend() const {
   return ConstReverseIterator(data_.get(), static_cast<size_t>(-1), NULL,
                               size());
 }
 
-ListContainerBase::ReverseIterator ListContainerBase::rbegin() {
+ListContainerHelper::ReverseIterator ListContainerHelper::rbegin() {
   if (data_->IsEmpty())
     return rend();
 
   size_t id = data_->LastInnerListId();
   return ReverseIterator(data_.get(), id,
                          data_->InnerListById(id)->LastElement(), 0);
 }
 
-ListContainerBase::ReverseIterator ListContainerBase::rend() {
+ListContainerHelper::ReverseIterator ListContainerHelper::rend() {
   return ReverseIterator(data_.get(), static_cast<size_t>(-1), NULL, size());
 }
 
-ListContainerBase::ConstIterator ListContainerBase::cbegin() const {
+ListContainerHelper::ConstIterator ListContainerHelper::cbegin() const {
   if (data_->IsEmpty())
     return cend();
 
   size_t id = data_->FirstInnerListId();
   return ConstIterator(data_.get(), id, data_->InnerListById(id)->Begin(), 0);
 }
 
-ListContainerBase::ConstIterator ListContainerBase::cend() const {
+ListContainerHelper::ConstIterator ListContainerHelper::cend() const {
   if (data_->IsEmpty())
     return ConstIterator(data_.get(), 0, NULL, size());
 
   size_t id = data_->list_count();
   return ConstIterator(data_.get(), id, NULL, size());
 }
 
-ListContainerBase::Iterator ListContainerBase::begin() {
+ListContainerHelper::Iterator ListContainerHelper::begin() {
   if (data_->IsEmpty())
     return end();
 
   size_t id = data_->FirstInnerListId();
   return Iterator(data_.get(), id, data_->InnerListById(id)->Begin(), 0);
 }
 
-ListContainerBase::Iterator ListContainerBase::end() {
+ListContainerHelper::Iterator ListContainerHelper::end() {
   if (data_->IsEmpty())
     return Iterator(data_.get(), 0, NULL, size());
 
   size_t id = data_->list_count();
   return Iterator(data_.get(), id, NULL, size());
 }
 
-ListContainerBase::ConstIterator ListContainerBase::IteratorAt(
+ListContainerHelper::ConstIterator ListContainerHelper::IteratorAt(
     size_t index) const {
   DCHECK_LT(index, size());
   size_t original_index = index;
   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),
                        original_index);
 }
 
-ListContainerBase::Iterator ListContainerBase::IteratorAt(size_t index) {
+ListContainerHelper::Iterator ListContainerHelper::IteratorAt(size_t index) {
   DCHECK_LT(index, size());
   size_t original_index = index;
   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),
                   original_index);
 }
 
-void* ListContainerBase::Allocate(size_t size_of_actual_element_in_bytes) {
+void* ListContainerHelper::Allocate(size_t size_of_actual_element_in_bytes) {
   DCHECK_LE(size_of_actual_element_in_bytes, data_->element_size());
   return data_->Allocate();
 }
 
-size_t ListContainerBase::size() const {
+size_t ListContainerHelper::size() const {
   return data_->size();
 }
 
-bool ListContainerBase::empty() const {
+bool ListContainerHelper::empty() const {
   return data_->IsEmpty();
 }
 
-size_t ListContainerBase::MaxSizeForDerivedClass() const {
+size_t ListContainerHelper::MaxSizeForDerivedClass() const {
   return data_->element_size();
 }
 
-size_t ListContainerBase::GetCapacityInBytes() const {
+size_t ListContainerHelper::GetCapacityInBytes() const {
   return data_->Capacity() * data_->element_size();
 }
 
-void ListContainerBase::clear() {
+void ListContainerHelper::clear() {
   data_->Clear();
 }
 
-size_t ListContainerBase::AvailableSizeWithoutAnotherAllocationForTesting()
+size_t ListContainerHelper::AvailableSizeWithoutAnotherAllocationForTesting()
     const {
   return data_->NumAvailableElementsInLastList();
 }
 
-// ListContainerBase::Iterator
+// ListContainerHelper::Iterator
 /////////////////////////////////////////////////
-ListContainerBase::Iterator::Iterator(ListContainerCharAllocator* container,
-                                      size_t vector_ind,
-                                      char* item_iter,
-                                      size_t index)
+ListContainerHelper::Iterator::Iterator(ListContainerCharAllocator* container,
+                                        size_t vector_ind,
+                                        char* item_iter,
+                                        size_t index)
     : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
-      index_(index) {
-}
+      index_(index) {}
 
-ListContainerBase::Iterator::~Iterator() {
-}
+ListContainerHelper::Iterator::~Iterator() {}
 
-size_t ListContainerBase::Iterator::index() const {
+size_t ListContainerHelper::Iterator::index() const {
   return index_;
 }
 
-// ListContainerBase::ConstIterator
+// ListContainerHelper::ConstIterator
 /////////////////////////////////////////////////
-ListContainerBase::ConstIterator::ConstIterator(
-    const ListContainerBase::Iterator& other)
-    : PositionInListContainerCharAllocator(other), index_(other.index()) {
-}
+ListContainerHelper::ConstIterator::ConstIterator(
+    const ListContainerHelper::Iterator& other)
+    : PositionInListContainerCharAllocator(other), index_(other.index()) {}
 
-ListContainerBase::ConstIterator::ConstIterator(
+ListContainerHelper::ConstIterator::ConstIterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
     char* item_iter,
     size_t index)
     : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
-      index_(index) {
-}
+      index_(index) {}
 
-ListContainerBase::ConstIterator::~ConstIterator() {
-}
+ListContainerHelper::ConstIterator::~ConstIterator() {}
 
-size_t ListContainerBase::ConstIterator::index() const {
+size_t ListContainerHelper::ConstIterator::index() const {
   return index_;
 }
 
-// ListContainerBase::ReverseIterator
+// ListContainerHelper::ReverseIterator
 /////////////////////////////////////////////////
-ListContainerBase::ReverseIterator::ReverseIterator(
+ListContainerHelper::ReverseIterator::ReverseIterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
     char* item_iter,
     size_t index)
     : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
-      index_(index) {
-}
+      index_(index) {}
 
-ListContainerBase::ReverseIterator::~ReverseIterator() {
-}
+ListContainerHelper::ReverseIterator::~ReverseIterator() {}
 
-size_t ListContainerBase::ReverseIterator::index() const {
+size_t ListContainerHelper::ReverseIterator::index() const {
   return index_;
 }
 
-// ListContainerBase::ConstReverseIterator
+// ListContainerHelper::ConstReverseIterator
 /////////////////////////////////////////////////
-ListContainerBase::ConstReverseIterator::ConstReverseIterator(
-    const ListContainerBase::ReverseIterator& other)
-    : PositionInListContainerCharAllocator(other), index_(other.index()) {
-}
+ListContainerHelper::ConstReverseIterator::ConstReverseIterator(
+    const ListContainerHelper::ReverseIterator& other)
+    : PositionInListContainerCharAllocator(other), index_(other.index()) {}
 
-ListContainerBase::ConstReverseIterator::ConstReverseIterator(
+ListContainerHelper::ConstReverseIterator::ConstReverseIterator(
     ListContainerCharAllocator* container,
     size_t vector_ind,
     char* item_iter,
     size_t index)
     : PositionInListContainerCharAllocator(container, vector_ind, item_iter),
-      index_(index) {
-}
+      index_(index) {}
 
-ListContainerBase::ConstReverseIterator::~ConstReverseIterator() {
-}
+ListContainerHelper::ConstReverseIterator::~ConstReverseIterator() {}
 
-size_t ListContainerBase::ConstReverseIterator::index() const {
+size_t ListContainerHelper::ConstReverseIterator::index() const {
   return index_;
 }
 
 }  // namespace cc