OLD | NEW |
| (Empty) |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef CC_RESOURCES_TILING_SET_RASTER_QUEUE_ALL_H_ | |
6 #define CC_RESOURCES_TILING_SET_RASTER_QUEUE_ALL_H_ | |
7 | |
8 #include "base/containers/stack_container.h" | |
9 #include "cc/base/cc_export.h" | |
10 #include "cc/resources/picture_layer_tiling_set.h" | |
11 #include "cc/resources/prioritized_tile.h" | |
12 #include "cc/resources/tile.h" | |
13 #include "cc/resources/tile_priority.h" | |
14 | |
15 namespace cc { | |
16 | |
17 // This queue returns all tiles required to be rasterized from HIGH_RESOLUTION | |
18 // and LOW_RESOLUTION tilings. | |
19 class CC_EXPORT TilingSetRasterQueueAll { | |
20 public: | |
21 TilingSetRasterQueueAll(PictureLayerTilingSet* tiling_set, | |
22 bool prioritize_low_res); | |
23 ~TilingSetRasterQueueAll(); | |
24 | |
25 const PrioritizedTile& Top() const; | |
26 void Pop(); | |
27 bool IsEmpty() const; | |
28 | |
29 private: | |
30 // Helper base class for individual region iterators. | |
31 class OnePriorityRectIterator { | |
32 public: | |
33 OnePriorityRectIterator(); | |
34 OnePriorityRectIterator( | |
35 PictureLayerTiling* tiling, | |
36 TilingData* tiling_data, | |
37 PictureLayerTiling::PriorityRectType priority_rect_type); | |
38 | |
39 bool done() const { return !current_tile_.tile(); } | |
40 const PrioritizedTile& operator*() const { return current_tile_; } | |
41 | |
42 protected: | |
43 ~OnePriorityRectIterator() = default; | |
44 bool TileNeedsRaster(Tile* tile) const { | |
45 return tile->draw_info().NeedsRaster() && !tiling_->IsTileOccluded(tile); | |
46 } | |
47 | |
48 template <typename TilingIteratorType> | |
49 void AdvanceToNextTile(TilingIteratorType* iterator); | |
50 template <typename TilingIteratorType> | |
51 bool GetFirstTileAndCheckIfValid(TilingIteratorType* iterator); | |
52 | |
53 PrioritizedTile current_tile_; | |
54 PictureLayerTiling* tiling_; | |
55 TilingData* tiling_data_; | |
56 PictureLayerTiling::PriorityRectType priority_rect_type_; | |
57 }; | |
58 | |
59 // Iterates over visible rect only, left to right top to bottom order. | |
60 class VisibleTilingIterator : public OnePriorityRectIterator { | |
61 public: | |
62 VisibleTilingIterator() = default; | |
63 VisibleTilingIterator(PictureLayerTiling* tiling, TilingData* tiling_data); | |
64 | |
65 VisibleTilingIterator& operator++(); | |
66 | |
67 private: | |
68 TilingData::Iterator iterator_; | |
69 }; | |
70 | |
71 class PendingVisibleTilingIterator : public OnePriorityRectIterator { | |
72 public: | |
73 PendingVisibleTilingIterator() = default; | |
74 PendingVisibleTilingIterator(PictureLayerTiling* tiling, | |
75 TilingData* tiling_data); | |
76 | |
77 PendingVisibleTilingIterator& operator++(); | |
78 | |
79 private: | |
80 TilingData::DifferenceIterator iterator_; | |
81 }; | |
82 | |
83 // Iterates over skewport only, spiral around the visible rect. | |
84 class SkewportTilingIterator : public OnePriorityRectIterator { | |
85 public: | |
86 SkewportTilingIterator() = default; | |
87 SkewportTilingIterator(PictureLayerTiling* tiling, TilingData* tiling_data); | |
88 | |
89 SkewportTilingIterator& operator++(); | |
90 | |
91 private: | |
92 TilingData::SpiralDifferenceIterator iterator_; | |
93 gfx::Rect pending_visible_rect_; | |
94 }; | |
95 | |
96 // Iterates over soon border only, spiral around the visible rect. | |
97 class SoonBorderTilingIterator : public OnePriorityRectIterator { | |
98 public: | |
99 SoonBorderTilingIterator() = default; | |
100 SoonBorderTilingIterator(PictureLayerTiling* tiling, | |
101 TilingData* tiling_data); | |
102 | |
103 SoonBorderTilingIterator& operator++(); | |
104 | |
105 private: | |
106 TilingData::SpiralDifferenceIterator iterator_; | |
107 gfx::Rect pending_visible_rect_; | |
108 }; | |
109 | |
110 // Iterates over eventually rect only, spiral around the soon rect. | |
111 class EventuallyTilingIterator : public OnePriorityRectIterator { | |
112 public: | |
113 EventuallyTilingIterator() = default; | |
114 EventuallyTilingIterator(PictureLayerTiling* tiling, | |
115 TilingData* tiling_data); | |
116 | |
117 EventuallyTilingIterator& operator++(); | |
118 | |
119 private: | |
120 TilingData::SpiralDifferenceIterator iterator_; | |
121 gfx::Rect pending_visible_rect_; | |
122 }; | |
123 | |
124 // Iterates over all of the above phases in the following order: visible, | |
125 // skewport, soon border, eventually. | |
126 class TilingIterator { | |
127 public: | |
128 TilingIterator(); | |
129 explicit TilingIterator(PictureLayerTiling* tiling, | |
130 TilingData* tiling_data); | |
131 ~TilingIterator(); | |
132 | |
133 bool done() const { return !current_tile_.tile(); } | |
134 const PrioritizedTile& operator*() const { return current_tile_; } | |
135 TilePriority::PriorityBin type() const { | |
136 switch (phase_) { | |
137 case Phase::VISIBLE_RECT: | |
138 return TilePriority::NOW; | |
139 case Phase::PENDING_VISIBLE_RECT: | |
140 case Phase::SKEWPORT_RECT: | |
141 case Phase::SOON_BORDER_RECT: | |
142 return TilePriority::SOON; | |
143 case Phase::EVENTUALLY_RECT: | |
144 return TilePriority::EVENTUALLY; | |
145 } | |
146 NOTREACHED(); | |
147 return TilePriority::EVENTUALLY; | |
148 } | |
149 | |
150 TilingIterator& operator++(); | |
151 | |
152 private: | |
153 using Phase = PictureLayerTiling::PriorityRectType; | |
154 | |
155 void AdvancePhase(); | |
156 | |
157 PictureLayerTiling* tiling_; | |
158 TilingData* tiling_data_; | |
159 | |
160 Phase phase_; | |
161 | |
162 PrioritizedTile current_tile_; | |
163 VisibleTilingIterator visible_iterator_; | |
164 PendingVisibleTilingIterator pending_visible_iterator_; | |
165 SkewportTilingIterator skewport_iterator_; | |
166 SoonBorderTilingIterator soon_border_iterator_; | |
167 EventuallyTilingIterator eventually_iterator_; | |
168 }; | |
169 | |
170 enum IteratorType { | |
171 LOW_RES, | |
172 HIGH_RES, | |
173 ACTIVE_NON_IDEAL_PENDING_HIGH_RES, | |
174 NUM_ITERATORS | |
175 }; | |
176 | |
177 void AdvanceToNextStage(); | |
178 | |
179 PictureLayerTilingSet* tiling_set_; | |
180 | |
181 struct IterationStage { | |
182 IterationStage(IteratorType type, TilePriority::PriorityBin bin); | |
183 IteratorType iterator_type; | |
184 TilePriority::PriorityBin tile_type; | |
185 }; | |
186 | |
187 size_t current_stage_; | |
188 | |
189 // The max number of stages is 6: 1 low res, 3 high res, and 2 active non | |
190 // ideal pending high res. | |
191 base::StackVector<IterationStage, 6> stages_; | |
192 TilingIterator iterators_[NUM_ITERATORS]; | |
193 | |
194 DISALLOW_COPY_AND_ASSIGN(TilingSetRasterQueueAll); | |
195 }; | |
196 | |
197 } // namespace cc | |
198 | |
199 #endif // CC_RESOURCES_TILING_SET_RASTER_QUEUE_ALL_H_ | |
OLD | NEW |