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

Side by Side Diff: cc/resources/tiling_set_raster_queue_all.cc

Issue 816453008: cc: Split tiling set raster queues into all and required. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebase Created 5 years, 11 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 #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
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
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
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
OLDNEW
« no previous file with comments | « cc/resources/tiling_set_raster_queue_all.h ('k') | cc/resources/tiling_set_raster_queue_required.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698