Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(695)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/base/list_container.cc

Issue 1336763006: cc: Switch ListContainer to use composition instead of inheritance. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« cc/base/list_container.h ('K') | « cc/base/list_container.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/base/list_container.cc
diff --git a/cc/base/list_container.cc b/cc/base/list_container.cc
index 48d2bf58ce63c78796216a26b9143dd90ab85fe0..fee9852ed03849e70f2b6adea3ec849de78bcc2f 100644
--- a/cc/base/list_container.cc
+++ b/cc/base/list_container.cc
@@ -19,7 +19,7 @@ namespace cc {
////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////
@@ -185,7 +185,7 @@ class ListContainerBase::ListContainerCharAllocator {
--size_;
}
- void InsertBefore(ListContainerBase::Iterator* position, size_t count) {
+ void InsertBefore(ListContainerHelper::Iterator* position, size_t count) {
if (!count)
return;
@@ -263,40 +263,38 @@ class ListContainerBase::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()) {
@@ -316,8 +314,8 @@ ListContainerBase::PositionInListContainerCharAllocator::Increment() {
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()) {
@@ -342,37 +340,34 @@ ListContainerBase::PositionInListContainerCharAllocator::ReverseIncrement() {
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();
@@ -381,12 +376,12 @@ ListContainerBase::ConstReverseIterator ListContainerBase::crbegin() const {
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();
@@ -395,11 +390,11 @@ ListContainerBase::ReverseIterator ListContainerBase::rbegin() {
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();
@@ -407,7 +402,7 @@ ListContainerBase::ConstIterator ListContainerBase::cbegin() const {
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());
@@ -415,7 +410,7 @@ ListContainerBase::ConstIterator ListContainerBase::cend() const {
return ConstIterator(data_.get(), id, NULL, size());
}
-ListContainerBase::Iterator ListContainerBase::begin() {
+ListContainerHelper::Iterator ListContainerHelper::begin() {
if (data_->IsEmpty())
return end();
@@ -423,7 +418,7 @@ ListContainerBase::Iterator ListContainerBase::begin() {
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());
@@ -431,7 +426,7 @@ ListContainerBase::Iterator ListContainerBase::end() {
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;
@@ -447,7 +442,7 @@ ListContainerBase::ConstIterator ListContainerBase::IteratorAt(
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;
@@ -462,114 +457,104 @@ ListContainerBase::Iterator ListContainerBase::IteratorAt(size_t 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_;
}
« cc/base/list_container.h ('K') | « cc/base/list_container.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698