OLD | NEW |
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_RESOURCES_TILING_SET_EVICTION_QUEUE_H_ | 5 #ifndef CC_RESOURCES_TILING_SET_EVICTION_QUEUE_H_ |
6 #define CC_RESOURCES_TILING_SET_EVICTION_QUEUE_H_ | 6 #define CC_RESOURCES_TILING_SET_EVICTION_QUEUE_H_ |
7 | 7 |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "cc/base/cc_export.h" | 10 #include "cc/base/cc_export.h" |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 // | 57 // |
58 // Additional notes: | 58 // Additional notes: |
59 // Since eventually the tiles are considered to have the priority which is the | 59 // Since eventually the tiles are considered to have the priority which is the |
60 // higher of the two trees, we might visit a tile that should actually be | 60 // higher of the two trees, we might visit a tile that should actually be |
61 // returned by its twin. In those situations, the tiles are not returned. That | 61 // returned by its twin. In those situations, the tiles are not returned. That |
62 // is, since the twin has higher priority, it should return it when it gets to | 62 // is, since the twin has higher priority, it should return it when it gets to |
63 // it. This ensures that we don't block raster because we've returned a tile | 63 // it. This ensures that we don't block raster because we've returned a tile |
64 // with low priority on one tree, but high combined priority. | 64 // with low priority on one tree, but high combined priority. |
65 class CC_EXPORT TilingSetEvictionQueue { | 65 class CC_EXPORT TilingSetEvictionQueue { |
66 public: | 66 public: |
67 TilingSetEvictionQueue(PictureLayerTilingSet* tiling_set, | 67 explicit TilingSetEvictionQueue(PictureLayerTilingSet* tiling_set); |
68 bool skip_shared_out_of_order_tiles); | |
69 ~TilingSetEvictionQueue(); | 68 ~TilingSetEvictionQueue(); |
70 | 69 |
71 Tile* Top(); | 70 Tile* Top(); |
72 const Tile* Top() const; | 71 const Tile* Top() const; |
73 void Pop(); | 72 void Pop(); |
74 bool IsEmpty() const; | 73 bool IsEmpty() const; |
75 | 74 |
76 private: | 75 private: |
77 enum Phase { | 76 enum Phase { |
78 EVENTUALLY_RECT, | 77 EVENTUALLY_RECT, |
79 SOON_BORDER_RECT, | 78 SOON_BORDER_RECT, |
80 SKEWPORT_RECT, | 79 SKEWPORT_RECT, |
81 PENDING_VISIBLE_RECT, | 80 PENDING_VISIBLE_RECT, |
82 PENDING_VISIBLE_RECT_REQUIRED_FOR_ACTIVATION, | 81 PENDING_VISIBLE_RECT_REQUIRED_FOR_ACTIVATION, |
83 VISIBLE_RECT_OCCLUDED, | 82 VISIBLE_RECT_OCCLUDED, |
84 VISIBLE_RECT_UNOCCLUDED, | 83 VISIBLE_RECT_UNOCCLUDED, |
85 VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_OCCLUDED, | 84 VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_OCCLUDED, |
86 VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_UNOCCLUDED | 85 VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_UNOCCLUDED |
87 }; | 86 }; |
88 | 87 |
89 void GenerateTilingOrder(PictureLayerTilingSet* tiling_set); | 88 void GenerateTilingOrder(PictureLayerTilingSet* tiling_set); |
90 | 89 |
91 // Helper base class for individual region iterators. | 90 // Helper base class for individual region iterators. |
92 class EvictionRectIterator { | 91 class EvictionRectIterator { |
93 public: | 92 public: |
94 EvictionRectIterator(); | 93 EvictionRectIterator(); |
95 EvictionRectIterator(std::vector<PictureLayerTiling*>* tilings, | 94 EvictionRectIterator(std::vector<PictureLayerTiling*>* tilings, |
96 WhichTree tree, | 95 WhichTree tree, |
97 bool skip_shared_out_of_order_tiles, | |
98 bool skip_pending_visible_rect); | 96 bool skip_pending_visible_rect); |
99 | 97 |
100 bool done() const { return !tile_; } | 98 bool done() const { return !tile_; } |
101 Tile* operator*() const { return tile_; } | 99 Tile* operator*() const { return tile_; } |
102 | 100 |
103 protected: | 101 protected: |
104 ~EvictionRectIterator() = default; | 102 ~EvictionRectIterator() = default; |
105 | 103 |
106 template <typename TilingIteratorType> | 104 template <typename TilingIteratorType> |
107 bool AdvanceToNextTile(TilingIteratorType* iterator); | 105 bool AdvanceToNextTile(TilingIteratorType* iterator); |
108 template <typename TilingIteratorType> | 106 template <typename TilingIteratorType> |
109 bool GetFirstTileAndCheckIfValid(TilingIteratorType* iterator); | 107 bool GetFirstTileAndCheckIfValid(TilingIteratorType* iterator); |
110 | 108 |
111 Tile* tile_; | 109 Tile* tile_; |
112 std::vector<PictureLayerTiling*>* tilings_; | 110 std::vector<PictureLayerTiling*>* tilings_; |
113 WhichTree tree_; | 111 WhichTree tree_; |
114 bool skip_shared_out_of_order_tiles_; | |
115 bool skip_pending_visible_rect_; | 112 bool skip_pending_visible_rect_; |
116 size_t tiling_index_; | 113 size_t tiling_index_; |
117 }; | 114 }; |
118 | 115 |
119 class PendingVisibleTilingIterator : public EvictionRectIterator { | 116 class PendingVisibleTilingIterator : public EvictionRectIterator { |
120 public: | 117 public: |
121 PendingVisibleTilingIterator() = default; | 118 PendingVisibleTilingIterator() = default; |
122 PendingVisibleTilingIterator(std::vector<PictureLayerTiling*>* tilings, | 119 PendingVisibleTilingIterator(std::vector<PictureLayerTiling*>* tilings, |
123 WhichTree tree, | 120 WhichTree tree, |
124 bool skip_shared_out_of_order_tiles, | |
125 bool return_required_for_activation_tiles); | 121 bool return_required_for_activation_tiles); |
126 | 122 |
127 PendingVisibleTilingIterator& operator++(); | 123 PendingVisibleTilingIterator& operator++(); |
128 | 124 |
129 private: | 125 private: |
130 bool TileMatchesRequiredFlags(const Tile* tile) const; | 126 bool TileMatchesRequiredFlags(const Tile* tile) const; |
131 | 127 |
132 TilingData::DifferenceIterator iterator_; | 128 TilingData::DifferenceIterator iterator_; |
133 bool return_required_for_activation_tiles_; | 129 bool return_required_for_activation_tiles_; |
134 }; | 130 }; |
135 | 131 |
136 class VisibleTilingIterator : public EvictionRectIterator { | 132 class VisibleTilingIterator : public EvictionRectIterator { |
137 public: | 133 public: |
138 VisibleTilingIterator() = default; | 134 VisibleTilingIterator() = default; |
139 VisibleTilingIterator(std::vector<PictureLayerTiling*>* tilings, | 135 VisibleTilingIterator(std::vector<PictureLayerTiling*>* tilings, |
140 WhichTree tree, | 136 WhichTree tree, |
141 bool skip_shared_out_of_order_tiles, | |
142 bool return_occluded_tiles, | 137 bool return_occluded_tiles, |
143 bool return_required_for_activation_tiles); | 138 bool return_required_for_activation_tiles); |
144 | 139 |
145 VisibleTilingIterator& operator++(); | 140 VisibleTilingIterator& operator++(); |
146 | 141 |
147 private: | 142 private: |
148 bool TileMatchesRequiredFlags(const Tile* tile) const; | 143 bool TileMatchesRequiredFlags(const Tile* tile) const; |
149 | 144 |
150 TilingData::Iterator iterator_; | 145 TilingData::Iterator iterator_; |
151 bool return_occluded_tiles_; | 146 bool return_occluded_tiles_; |
152 bool return_required_for_activation_tiles_; | 147 bool return_required_for_activation_tiles_; |
153 }; | 148 }; |
154 | 149 |
155 class SkewportTilingIterator : public EvictionRectIterator { | 150 class SkewportTilingIterator : public EvictionRectIterator { |
156 public: | 151 public: |
157 SkewportTilingIterator() = default; | 152 SkewportTilingIterator() = default; |
158 SkewportTilingIterator(std::vector<PictureLayerTiling*>* tilings, | 153 SkewportTilingIterator(std::vector<PictureLayerTiling*>* tilings, |
159 WhichTree tree, | 154 WhichTree tree); |
160 bool skip_shared_out_of_order_tiles); | |
161 | 155 |
162 SkewportTilingIterator& operator++(); | 156 SkewportTilingIterator& operator++(); |
163 | 157 |
164 private: | 158 private: |
165 TilingData::ReverseSpiralDifferenceIterator iterator_; | 159 TilingData::ReverseSpiralDifferenceIterator iterator_; |
166 }; | 160 }; |
167 | 161 |
168 class SoonBorderTilingIterator : public EvictionRectIterator { | 162 class SoonBorderTilingIterator : public EvictionRectIterator { |
169 public: | 163 public: |
170 SoonBorderTilingIterator() = default; | 164 SoonBorderTilingIterator() = default; |
171 SoonBorderTilingIterator(std::vector<PictureLayerTiling*>* tilings, | 165 SoonBorderTilingIterator(std::vector<PictureLayerTiling*>* tilings, |
172 WhichTree tree, | 166 WhichTree tree); |
173 bool skip_shared_out_of_order_tiles); | |
174 | 167 |
175 SoonBorderTilingIterator& operator++(); | 168 SoonBorderTilingIterator& operator++(); |
176 | 169 |
177 private: | 170 private: |
178 TilingData::ReverseSpiralDifferenceIterator iterator_; | 171 TilingData::ReverseSpiralDifferenceIterator iterator_; |
179 }; | 172 }; |
180 | 173 |
181 class EventuallyTilingIterator : public EvictionRectIterator { | 174 class EventuallyTilingIterator : public EvictionRectIterator { |
182 public: | 175 public: |
183 EventuallyTilingIterator() = default; | 176 EventuallyTilingIterator() = default; |
184 EventuallyTilingIterator(std::vector<PictureLayerTiling*>* tilings, | 177 EventuallyTilingIterator(std::vector<PictureLayerTiling*>* tilings, |
185 WhichTree tree, | 178 WhichTree tree); |
186 bool skip_shared_out_of_order_tiles); | |
187 | 179 |
188 EventuallyTilingIterator& operator++(); | 180 EventuallyTilingIterator& operator++(); |
189 | 181 |
190 private: | 182 private: |
191 TilingData::ReverseSpiralDifferenceIterator iterator_; | 183 TilingData::ReverseSpiralDifferenceIterator iterator_; |
192 }; | 184 }; |
193 | 185 |
194 void AdvancePhase(); | 186 void AdvancePhase(); |
195 | 187 |
196 WhichTree tree_; | 188 WhichTree tree_; |
197 bool skip_shared_out_of_order_tiles_; | |
198 Phase phase_; | 189 Phase phase_; |
199 Tile* current_tile_; | 190 Tile* current_tile_; |
200 std::vector<PictureLayerTiling*> tilings_; | 191 std::vector<PictureLayerTiling*> tilings_; |
201 | 192 |
202 EventuallyTilingIterator eventually_iterator_; | 193 EventuallyTilingIterator eventually_iterator_; |
203 SoonBorderTilingIterator soon_iterator_; | 194 SoonBorderTilingIterator soon_iterator_; |
204 SkewportTilingIterator skewport_iterator_; | 195 SkewportTilingIterator skewport_iterator_; |
205 PendingVisibleTilingIterator pending_visible_iterator_; | 196 PendingVisibleTilingIterator pending_visible_iterator_; |
206 VisibleTilingIterator visible_iterator_; | 197 VisibleTilingIterator visible_iterator_; |
207 }; | 198 }; |
208 | 199 |
209 } // namespace cc | 200 } // namespace cc |
210 | 201 |
211 #endif // CC_RESOURCES_TILING_SET_EVICTION_QUEUE_H_ | 202 #endif // CC_RESOURCES_TILING_SET_EVICTION_QUEUE_H_ |
OLD | NEW |