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

Side by Side Diff: cc/quads/list_container.h

Issue 551013002: Use Custome ListContainer to Allocate SharedQuadState (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@DQAllo
Patch Set: use C++ range based loop Created 6 years, 2 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 unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #ifndef CC_QUADS_LIST_CONTAINER_H_ 5 #ifndef CC_QUADS_LIST_CONTAINER_H_
6 #define CC_QUADS_LIST_CONTAINER_H_ 6 #define CC_QUADS_LIST_CONTAINER_H_
7 7
8 #include "base/macros.h" 8 #include "base/macros.h"
9 #include "base/memory/scoped_ptr.h" 9 #include "base/memory/scoped_ptr.h"
10 #include "cc/base/cc_export.h" 10 #include "cc/base/cc_export.h"
(...skipping 15 matching lines...) Expand all
26 public: 26 public:
27 // BaseElementType is the type of raw pointers this class hands out; however, 27 // BaseElementType is the type of raw pointers this class hands out; however,
28 // its derived classes might require different memory sizes. 28 // its derived classes might require different memory sizes.
29 // max_size_for_derived_class the largest memory size required for all the 29 // max_size_for_derived_class the largest memory size required for all the
30 // derived classes to use for allocation. 30 // derived classes to use for allocation.
31 explicit ListContainer(size_t max_size_for_derived_class); 31 explicit ListContainer(size_t max_size_for_derived_class);
32 // This constructor omits input variable for max_size_for_derived_class. This 32 // This constructor omits input variable for max_size_for_derived_class. This
33 // is used when there is no derived classes from BaseElementType we need to 33 // is used when there is no derived classes from BaseElementType we need to
34 // worry about, and allocation size is just sizeof(BaseElementType). 34 // worry about, and allocation size is just sizeof(BaseElementType).
35 ListContainer(); 35 ListContainer();
36 // This constructor reserves the requested memory up front so only a single 36 // This constructor reserves the requested memory up front so only single
37 // allocation is needed. 37 // allocation is needed. When num_of_elements_to_reserve_for is zero, use the
38 // default size.
38 ListContainer(size_t max_size_for_derived_class, 39 ListContainer(size_t max_size_for_derived_class,
39 size_t num_of_elements_to_reserve_for); 40 size_t num_of_elements_to_reserve_for);
40 41
41 ~ListContainer(); 42 ~ListContainer();
42 43
43 // This class deals only with char* and void*. It does allocation and passing 44 // This class deals only with char* and void*. It does allocation and passing
44 // out raw pointers, as well as memory deallocation when being destroyed. 45 // out raw pointers, as well as memory deallocation when being destroyed.
45 class CC_EXPORT ListContainerCharAllocator; 46 class CC_EXPORT ListContainerCharAllocator;
46 47
47 // This class points to a certain position inside memory of 48 // This class points to a certain position inside memory of
(...skipping 18 matching lines...) Expand all
66 }; 67 };
67 68
68 // Iterator classes that can be used to access data. 69 // Iterator classes that can be used to access data.
69 ///////////////////////////////////////////////////////////////// 70 /////////////////////////////////////////////////////////////////
70 class CC_EXPORT Iterator : public PositionInListContainerCharAllocator { 71 class CC_EXPORT Iterator : public PositionInListContainerCharAllocator {
71 // This class is only defined to forward iterate through 72 // This class is only defined to forward iterate through
72 // ListContainerCharAllocator. 73 // ListContainerCharAllocator.
73 public: 74 public:
74 Iterator(ListContainerCharAllocator* container, 75 Iterator(ListContainerCharAllocator* container,
75 size_t vector_ind, 76 size_t vector_ind,
76 char* item_iter); 77 char* item_iter,
78 size_t index);
77 ~Iterator(); 79 ~Iterator();
78 BaseElementType* operator->() const; 80 BaseElementType* operator->() const;
79 BaseElementType& operator*() const; 81 BaseElementType& operator*() const;
80 Iterator operator++(int unused_post_increment); 82 Iterator operator++(int unused_post_increment);
81 Iterator operator++(); 83 Iterator operator++();
84
85 size_t index() const;
86
87 private:
88 // This is used to track how many increment has happened since begin(). It
89 // is
danakj 2014/10/02 15:32:48 fix formatting
weiliangc 2014/10/02 22:01:39 Done.
90 // used to avoid doulble increment at places an index reference is needed.
91 // For iterator this means begin() corresponds to index 0 and end()
92 // corresponds to index |size|.
93 size_t index_;
82 }; 94 };
83 95
84 class CC_EXPORT ConstIterator : public PositionInListContainerCharAllocator { 96 class CC_EXPORT ConstIterator : public PositionInListContainerCharAllocator {
85 // This class is only defined to forward iterate through 97 // This class is only defined to forward iterate through
86 // ListContainerCharAllocator. 98 // ListContainerCharAllocator.
87 public: 99 public:
88 ConstIterator(ListContainerCharAllocator* container, 100 ConstIterator(ListContainerCharAllocator* container,
89 size_t vector_ind, 101 size_t vector_ind,
90 char* item_iter); 102 char* item_iter,
103 size_t index);
91 ConstIterator(const Iterator& other); // NOLINT 104 ConstIterator(const Iterator& other); // NOLINT
92 ~ConstIterator(); 105 ~ConstIterator();
93 const BaseElementType* operator->() const; 106 const BaseElementType* operator->() const;
94 const BaseElementType& operator*() const; 107 const BaseElementType& operator*() const;
95 ConstIterator operator++(int unused_post_increment); 108 ConstIterator operator++(int unused_post_increment);
96 ConstIterator operator++(); 109 ConstIterator operator++();
110
111 size_t index() const;
112
113 private:
114 // This is used to track how many increment has happened since begin(). It
115 // is
danakj 2014/10/02 15:32:48 formatting
weiliangc 2014/10/02 22:01:40 Done.
116 // used to avoid doulble increment at places an index reference is needed.
117 // For iterator this means begin() corresponds to index 0 and end()
118 // corresponds to index |size|.
119 size_t index_;
97 }; 120 };
98 121
99 class CC_EXPORT ReverseIterator 122 class CC_EXPORT ReverseIterator
100 : public PositionInListContainerCharAllocator { 123 : public PositionInListContainerCharAllocator {
101 // This class is only defined to reverse iterate through 124 // This class is only defined to reverse iterate through
102 // ListContainerCharAllocator. 125 // ListContainerCharAllocator.
103 public: 126 public:
104 ReverseIterator(ListContainerCharAllocator* container, 127 ReverseIterator(ListContainerCharAllocator* container,
105 size_t vector_ind, 128 size_t vector_ind,
106 char* item_iter); 129 char* item_iter,
130 size_t index);
107 ~ReverseIterator(); 131 ~ReverseIterator();
108 BaseElementType* operator->() const; 132 BaseElementType* operator->() const;
109 BaseElementType& operator*() const; 133 BaseElementType& operator*() const;
110 ReverseIterator operator++(int unused_post_increment); 134 ReverseIterator operator++(int unused_post_increment);
111 ReverseIterator operator++(); 135 ReverseIterator operator++();
136
137 size_t index() const;
138
139 private:
140 // This is used to track how many increment has happened since rbegin(). It
141 // is used to avoid doulble increment at places an index reference is
142 // needed.
143 // For reverse iterator this means rbegin() corresponds to index 0 and
144 // rend()
danakj 2014/10/02 15:32:48 formatting
weiliangc 2014/10/02 22:01:39 Done.
145 // corresponds to index |size|.
146 size_t index_;
112 }; 147 };
113 148
114 class CC_EXPORT ConstReverseIterator 149 class CC_EXPORT ConstReverseIterator
115 : public PositionInListContainerCharAllocator { 150 : public PositionInListContainerCharAllocator {
116 // This class is only defined to reverse iterate through 151 // This class is only defined to reverse iterate through
117 // ListContainerCharAllocator. 152 // ListContainerCharAllocator.
118 public: 153 public:
119 ConstReverseIterator(ListContainerCharAllocator* container, 154 ConstReverseIterator(ListContainerCharAllocator* container,
120 size_t vector_ind, 155 size_t vector_ind,
121 char* item_iter); 156 char* item_iter,
157 size_t index);
122 ConstReverseIterator(const ReverseIterator& other); // NOLINT 158 ConstReverseIterator(const ReverseIterator& other); // NOLINT
123 ~ConstReverseIterator(); 159 ~ConstReverseIterator();
124 const BaseElementType* operator->() const; 160 const BaseElementType* operator->() const;
125 const BaseElementType& operator*() const; 161 const BaseElementType& operator*() const;
126 ConstReverseIterator operator++(int unused_post_increment); 162 ConstReverseIterator operator++(int unused_post_increment);
127 ConstReverseIterator operator++(); 163 ConstReverseIterator operator++();
164
165 size_t index() const;
166
167 private:
168 // This is used to track how many increment has happened since rbegin(). It
169 // is used to avoid doulble increment at places an index reference is
170 // needed.
171 // For reverse iterator this means rbegin() corresponds to index 0 and
172 // rend()
danakj 2014/10/02 15:32:48 formattting
weiliangc 2014/10/02 22:01:40 Done.
173 // corresponds to index |size|.
174 size_t index_;
128 }; 175 };
129 176
130 // When called, all raw pointers that have been handed out are no longer 177 // When called, all raw pointers that have been handed out are no longer
131 // valid. Use with caution. 178 // valid. Use with caution.
132 // This function does not deallocate memory. 179 // This function does not deallocate memory.
133 void EraseAndInvalidateAllPointers(Iterator position); 180 void EraseAndInvalidateAllPointers(Iterator position);
134 181
135 ConstReverseIterator rbegin() const; 182 ConstReverseIterator rbegin() const;
136 ConstReverseIterator rend() const; 183 ConstReverseIterator rend() const;
137 ReverseIterator rbegin(); 184 ReverseIterator rbegin();
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
178 DISALLOW_COPY_AND_ASSIGN(ListContainer); 225 DISALLOW_COPY_AND_ASSIGN(ListContainer);
179 }; 226 };
180 227
181 #if !defined(COMPILER_MSVC) 228 #if !defined(COMPILER_MSVC)
182 extern template class ListContainer<SharedQuadState>; 229 extern template class ListContainer<SharedQuadState>;
183 extern template class ListContainer<DrawQuad>; 230 extern template class ListContainer<DrawQuad>;
184 #endif 231 #endif
185 } // namespace cc 232 } // namespace cc
186 233
187 #endif // CC_QUADS_LIST_CONTAINER_H_ 234 #endif // CC_QUADS_LIST_CONTAINER_H_
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698