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 #include "cc/resources/tiling_set_raster_queue.h" | 5 #include "cc/resources/tiling_set_raster_queue_all.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "cc/resources/picture_layer_tiling_set.h" | 9 #include "cc/resources/picture_layer_tiling_set.h" |
10 #include "cc/resources/tile.h" | 10 #include "cc/resources/tile.h" |
11 #include "cc/resources/tile_priority.h" | 11 #include "cc/resources/tile_priority.h" |
12 | 12 |
13 namespace cc { | 13 namespace cc { |
14 | 14 |
15 TilingSetRasterQueue::TilingSetRasterQueue() | 15 TilingSetRasterQueueAll::TilingSetRasterQueueAll( |
16 : tiling_set_(nullptr), current_stage_(arraysize(stages_)) { | 16 PictureLayerTilingSet* tiling_set, |
17 } | 17 bool prioritize_low_res) |
18 | |
19 TilingSetRasterQueue::TilingSetRasterQueue(PictureLayerTilingSet* tiling_set, | |
20 bool prioritize_low_res) | |
21 : tiling_set_(tiling_set), current_stage_(0) { | 18 : tiling_set_(tiling_set), current_stage_(0) { |
22 DCHECK(tiling_set_); | 19 DCHECK(tiling_set_); |
23 | 20 |
24 // Early out if the tiling set has no tilings. | 21 // Early out if the tiling set has no tilings. |
25 if (!tiling_set_->num_tilings()) { | 22 if (!tiling_set_->num_tilings()) { |
26 current_stage_ = arraysize(stages_); | 23 current_stage_ = arraysize(stages_); |
27 return; | 24 return; |
28 } | 25 } |
29 | 26 |
30 // Find high and low res tilings and initialize the iterators. | 27 // Find high and low res tilings and initialize the iterators. |
(...skipping 20 matching lines...) Expand all Loading... |
51 } | 48 } |
52 | 49 |
53 stages_[2].iterator_type = HIGH_RES; | 50 stages_[2].iterator_type = HIGH_RES; |
54 stages_[2].tile_type = TilePriority::SOON; | 51 stages_[2].tile_type = TilePriority::SOON; |
55 | 52 |
56 stages_[3].iterator_type = HIGH_RES; | 53 stages_[3].iterator_type = HIGH_RES; |
57 stages_[3].tile_type = TilePriority::EVENTUALLY; | 54 stages_[3].tile_type = TilePriority::EVENTUALLY; |
58 | 55 |
59 IteratorType index = stages_[current_stage_].iterator_type; | 56 IteratorType index = stages_[current_stage_].iterator_type; |
60 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; | 57 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; |
61 if (!iterators_[index] || iterators_[index].type() != tile_type) | 58 if (iterators_[index].done() || iterators_[index].type() != tile_type) |
62 AdvanceToNextStage(); | 59 AdvanceToNextStage(); |
63 } | 60 } |
64 | 61 |
65 TilingSetRasterQueue::~TilingSetRasterQueue() { | 62 TilingSetRasterQueueAll::~TilingSetRasterQueueAll() { |
66 } | 63 } |
67 | 64 |
68 bool TilingSetRasterQueue::IsEmpty() const { | 65 bool TilingSetRasterQueueAll::IsEmpty() const { |
69 return current_stage_ >= arraysize(stages_); | 66 return current_stage_ >= arraysize(stages_); |
70 } | 67 } |
71 | 68 |
72 void TilingSetRasterQueue::Pop() { | 69 void TilingSetRasterQueueAll::Pop() { |
73 IteratorType index = stages_[current_stage_].iterator_type; | 70 IteratorType index = stages_[current_stage_].iterator_type; |
74 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; | 71 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; |
75 | 72 |
76 // First advance the iterator. | 73 // First advance the iterator. |
77 DCHECK(iterators_[index]); | 74 DCHECK(!iterators_[index].done()); |
78 DCHECK(iterators_[index].type() == tile_type); | 75 DCHECK(iterators_[index].type() == tile_type); |
79 ++iterators_[index]; | 76 ++iterators_[index]; |
80 | 77 |
81 if (!iterators_[index] || iterators_[index].type() != tile_type) | 78 if (iterators_[index].done() || iterators_[index].type() != tile_type) |
82 AdvanceToNextStage(); | 79 AdvanceToNextStage(); |
83 } | 80 } |
84 | 81 |
85 Tile* TilingSetRasterQueue::Top() { | 82 Tile* TilingSetRasterQueueAll::Top() { |
86 DCHECK(!IsEmpty()); | 83 DCHECK(!IsEmpty()); |
87 | 84 |
88 IteratorType index = stages_[current_stage_].iterator_type; | 85 IteratorType index = stages_[current_stage_].iterator_type; |
89 DCHECK(iterators_[index]); | 86 DCHECK(!iterators_[index].done()); |
90 DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type); | 87 DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type); |
91 | 88 |
92 return *iterators_[index]; | 89 return *iterators_[index]; |
93 } | 90 } |
94 | 91 |
95 const Tile* TilingSetRasterQueue::Top() const { | 92 const Tile* TilingSetRasterQueueAll::Top() const { |
96 DCHECK(!IsEmpty()); | 93 DCHECK(!IsEmpty()); |
97 | 94 |
98 IteratorType index = stages_[current_stage_].iterator_type; | 95 IteratorType index = stages_[current_stage_].iterator_type; |
99 DCHECK(iterators_[index]); | 96 DCHECK(!iterators_[index].done()); |
100 DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type); | 97 DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type); |
101 | 98 |
102 return *iterators_[index]; | 99 return *iterators_[index]; |
103 } | 100 } |
104 | 101 |
105 void TilingSetRasterQueue::AdvanceToNextStage() { | 102 void TilingSetRasterQueueAll::AdvanceToNextStage() { |
106 DCHECK_LT(current_stage_, arraysize(stages_)); | 103 DCHECK_LT(current_stage_, arraysize(stages_)); |
107 ++current_stage_; | 104 ++current_stage_; |
108 while (current_stage_ < arraysize(stages_)) { | 105 while (current_stage_ < arraysize(stages_)) { |
109 IteratorType index = stages_[current_stage_].iterator_type; | 106 IteratorType index = stages_[current_stage_].iterator_type; |
110 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; | 107 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; |
111 | 108 |
112 if (iterators_[index] && iterators_[index].type() == tile_type) | 109 if (!iterators_[index].done() && iterators_[index].type() == tile_type) |
113 break; | 110 break; |
114 ++current_stage_; | 111 ++current_stage_; |
115 } | 112 } |
116 } | 113 } |
117 | 114 |
118 TilingSetRasterQueue::TilingIterator::TilingIterator() | 115 TilingSetRasterQueueAll::TilingIterator::TilingIterator() |
119 : tiling_(NULL), current_tile_(NULL) { | 116 : tiling_(NULL), current_tile_(NULL) { |
120 } | 117 } |
121 | 118 |
122 TilingSetRasterQueue::TilingIterator::TilingIterator(PictureLayerTiling* tiling, | 119 TilingSetRasterQueueAll::TilingIterator::TilingIterator( |
123 TilingData* tiling_data) | 120 PictureLayerTiling* tiling, |
| 121 TilingData* tiling_data) |
124 : tiling_(tiling), | 122 : tiling_(tiling), |
125 tiling_data_(tiling_data), | 123 tiling_data_(tiling_data), |
126 phase_(VISIBLE_RECT), | 124 phase_(VISIBLE_RECT), |
127 current_tile_(NULL) { | 125 current_tile_(NULL) { |
128 if (!tiling_->has_visible_rect_tiles()) { | 126 if (!tiling_->has_visible_rect_tiles()) { |
129 AdvancePhase(); | 127 AdvancePhase(); |
130 return; | 128 return; |
131 } | 129 } |
132 | 130 |
133 visible_iterator_ = | 131 visible_iterator_ = |
134 TilingData::Iterator(tiling_data_, tiling_->current_visible_rect(), | 132 TilingData::Iterator(tiling_data_, tiling_->current_visible_rect(), |
135 false /* include_borders */); | 133 false /* include_borders */); |
136 if (!visible_iterator_) { | 134 if (!visible_iterator_) { |
137 AdvancePhase(); | 135 AdvancePhase(); |
138 return; | 136 return; |
139 } | 137 } |
140 | 138 |
141 current_tile_ = | 139 current_tile_ = |
142 tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y()); | 140 tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y()); |
143 if (!current_tile_ || !TileNeedsRaster(current_tile_)) { | 141 if (!current_tile_ || !TileNeedsRaster(current_tile_)) { |
144 ++(*this); | 142 ++(*this); |
145 return; | 143 return; |
146 } | 144 } |
147 tiling_->UpdateTileAndTwinPriority(current_tile_); | 145 tiling_->UpdateTileAndTwinPriority(current_tile_); |
148 } | 146 } |
149 | 147 |
150 TilingSetRasterQueue::TilingIterator::~TilingIterator() { | 148 TilingSetRasterQueueAll::TilingIterator::~TilingIterator() { |
151 } | 149 } |
152 | 150 |
153 void TilingSetRasterQueue::TilingIterator::AdvancePhase() { | 151 void TilingSetRasterQueueAll::TilingIterator::AdvancePhase() { |
154 DCHECK_LT(phase_, EVENTUALLY_RECT); | 152 DCHECK_LT(phase_, EVENTUALLY_RECT); |
155 | 153 |
156 do { | 154 do { |
157 phase_ = static_cast<Phase>(phase_ + 1); | 155 phase_ = static_cast<Phase>(phase_ + 1); |
158 switch (phase_) { | 156 switch (phase_) { |
159 case VISIBLE_RECT: | 157 case VISIBLE_RECT: |
160 NOTREACHED(); | 158 NOTREACHED(); |
161 return; | 159 return; |
162 case SKEWPORT_RECT: | 160 case SKEWPORT_RECT: |
163 if (!tiling_->has_skewport_rect_tiles()) | 161 if (!tiling_->has_skewport_rect_tiles()) |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
199 if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) { | 197 if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) { |
200 current_tile_ = NULL; | 198 current_tile_ = NULL; |
201 break; | 199 break; |
202 } | 200 } |
203 } while (!spiral_iterator_); | 201 } while (!spiral_iterator_); |
204 | 202 |
205 if (current_tile_) | 203 if (current_tile_) |
206 tiling_->UpdateTileAndTwinPriority(current_tile_); | 204 tiling_->UpdateTileAndTwinPriority(current_tile_); |
207 } | 205 } |
208 | 206 |
209 TilingSetRasterQueue::TilingIterator& TilingSetRasterQueue::TilingIterator:: | 207 TilingSetRasterQueueAll::TilingIterator& |
210 operator++() { | 208 TilingSetRasterQueueAll::TilingIterator:: |
| 209 operator++() { |
211 current_tile_ = NULL; | 210 current_tile_ = NULL; |
212 while (!current_tile_ || !TileNeedsRaster(current_tile_)) { | 211 while (!current_tile_ || !TileNeedsRaster(current_tile_)) { |
213 std::pair<int, int> next_index; | 212 std::pair<int, int> next_index; |
214 switch (phase_) { | 213 switch (phase_) { |
215 case VISIBLE_RECT: | 214 case VISIBLE_RECT: |
216 ++visible_iterator_; | 215 ++visible_iterator_; |
217 if (!visible_iterator_) { | 216 if (!visible_iterator_) { |
218 AdvancePhase(); | 217 AdvancePhase(); |
219 return *this; | 218 return *this; |
220 } | 219 } |
(...skipping 19 matching lines...) Expand all Loading... |
240 } | 239 } |
241 current_tile_ = tiling_->TileAt(next_index.first, next_index.second); | 240 current_tile_ = tiling_->TileAt(next_index.first, next_index.second); |
242 } | 241 } |
243 | 242 |
244 if (current_tile_) | 243 if (current_tile_) |
245 tiling_->UpdateTileAndTwinPriority(current_tile_); | 244 tiling_->UpdateTileAndTwinPriority(current_tile_); |
246 return *this; | 245 return *this; |
247 } | 246 } |
248 | 247 |
249 } // namespace cc | 248 } // namespace cc |
OLD | NEW |