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/raster_tile_priority_queue.h" | 5 #include "cc/resources/raster_tile_priority_queue.h" |
6 | 6 |
7 #include "cc/resources/tiling_set_raster_queue_all.h" | |
8 #include "cc/resources/tiling_set_raster_queue_required.h" | |
9 | |
7 namespace cc { | 10 namespace cc { |
8 | 11 |
9 namespace { | 12 namespace { |
10 | 13 |
11 class RasterOrderComparator { | 14 class RasterOrderComparator { |
12 public: | 15 public: |
13 explicit RasterOrderComparator(TreePriority tree_priority) | 16 explicit RasterOrderComparator(TreePriority tree_priority) |
14 : tree_priority_(tree_priority) {} | 17 : tree_priority_(tree_priority) {} |
15 | 18 |
16 bool operator()( | 19 bool operator()( |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
117 if (active_priority.IsHigherPriorityThan(pending_priority)) | 120 if (active_priority.IsHigherPriorityThan(pending_priority)) |
118 return ACTIVE_TREE; | 121 return ACTIVE_TREE; |
119 return PENDING_TREE; | 122 return PENDING_TREE; |
120 } | 123 } |
121 default: | 124 default: |
122 NOTREACHED(); | 125 NOTREACHED(); |
123 return ACTIVE_TREE; | 126 return ACTIVE_TREE; |
124 } | 127 } |
125 } | 128 } |
126 | 129 |
130 scoped_ptr<TilingSetRasterQueue> CreateTilingSetRasterQueue( | |
131 PictureLayerImpl* layer, | |
132 TreePriority tree_priority, | |
133 RasterTilePriorityQueue::Type type) { | |
134 if (!layer) | |
135 return nullptr; | |
136 PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set(); | |
137 if (!tiling_set) | |
danakj
2015/01/08 23:24:40
dont think this can be null anymore can it?
| |
138 return nullptr; | |
139 | |
140 if (type == RasterTilePriorityQueue::Type::ALL) { | |
141 return make_scoped_ptr(new TilingSetRasterQueueAll( | |
142 tiling_set, tree_priority == SMOOTHNESS_TAKES_PRIORITY)); | |
danakj
2015/01/08 23:24:40
can you use a temp var to give this bool a name re
| |
143 } | |
144 return make_scoped_ptr(new TilingSetRasterQueueRequired(tiling_set, type)); | |
145 } | |
146 | |
127 } // namespace | 147 } // namespace |
128 | 148 |
129 RasterTilePriorityQueue::RasterTilePriorityQueue() { | 149 RasterTilePriorityQueue::RasterTilePriorityQueue() { |
130 } | 150 } |
131 | 151 |
132 RasterTilePriorityQueue::~RasterTilePriorityQueue() { | 152 RasterTilePriorityQueue::~RasterTilePriorityQueue() { |
133 } | 153 } |
134 | 154 |
135 void RasterTilePriorityQueue::Build( | 155 void RasterTilePriorityQueue::Build( |
136 const std::vector<PictureLayerImpl::Pair>& paired_layers, | 156 const std::vector<PictureLayerImpl::Pair>& paired_layers, |
137 TreePriority tree_priority) { | 157 TreePriority tree_priority, |
158 Type type) { | |
138 tree_priority_ = tree_priority; | 159 tree_priority_ = tree_priority; |
139 for (std::vector<PictureLayerImpl::Pair>::const_iterator it = | 160 for (std::vector<PictureLayerImpl::Pair>::const_iterator it = |
140 paired_layers.begin(); | 161 paired_layers.begin(); |
141 it != paired_layers.end(); | 162 it != paired_layers.end(); |
142 ++it) { | 163 ++it) { |
143 paired_queues_.push_back( | 164 paired_queues_.push_back( |
144 make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_))); | 165 make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_, type))); |
145 } | 166 } |
146 paired_queues_.make_heap(RasterOrderComparator(tree_priority_)); | 167 paired_queues_.make_heap(RasterOrderComparator(tree_priority_)); |
147 } | 168 } |
148 | 169 |
149 void RasterTilePriorityQueue::Reset() { | 170 void RasterTilePriorityQueue::Reset() { |
150 paired_queues_.clear(); | 171 paired_queues_.clear(); |
151 } | 172 } |
152 | 173 |
153 bool RasterTilePriorityQueue::IsEmpty() const { | 174 bool RasterTilePriorityQueue::IsEmpty() const { |
154 return paired_queues_.empty() || paired_queues_.front()->IsEmpty(); | 175 return paired_queues_.empty() || paired_queues_.front()->IsEmpty(); |
(...skipping 11 matching lines...) Expand all Loading... | |
166 PairedTilingSetQueue* paired_queue = paired_queues_.back(); | 187 PairedTilingSetQueue* paired_queue = paired_queues_.back(); |
167 paired_queue->Pop(tree_priority_); | 188 paired_queue->Pop(tree_priority_); |
168 paired_queues_.push_heap(RasterOrderComparator(tree_priority_)); | 189 paired_queues_.push_heap(RasterOrderComparator(tree_priority_)); |
169 } | 190 } |
170 | 191 |
171 RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue() { | 192 RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue() { |
172 } | 193 } |
173 | 194 |
174 RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue( | 195 RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue( |
175 const PictureLayerImpl::Pair& layer_pair, | 196 const PictureLayerImpl::Pair& layer_pair, |
176 TreePriority tree_priority) | 197 TreePriority tree_priority, |
177 : has_both_layers(layer_pair.active && layer_pair.pending) { | 198 Type type) |
178 if (layer_pair.active) { | 199 : has_both_layers(false) { |
179 active_queue = layer_pair.active->CreateRasterQueue( | 200 switch (type) { |
180 tree_priority == SMOOTHNESS_TAKES_PRIORITY); | 201 case RasterTilePriorityQueue::Type::ALL: |
202 has_both_layers = layer_pair.active && layer_pair.pending; | |
203 active_queue = | |
204 CreateTilingSetRasterQueue(layer_pair.active, tree_priority, type); | |
205 pending_queue = | |
206 CreateTilingSetRasterQueue(layer_pair.pending, tree_priority, type); | |
207 break; | |
danakj
2015/01/08 23:24:40
maybe dhceck that if has_both_layers then both que
| |
208 case RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION: | |
209 pending_queue = | |
210 CreateTilingSetRasterQueue(layer_pair.pending, tree_priority, type); | |
211 break; | |
212 case RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW: | |
213 active_queue = | |
214 CreateTilingSetRasterQueue(layer_pair.active, tree_priority, type); | |
215 break; | |
181 } | 216 } |
182 | 217 |
183 if (layer_pair.pending) { | 218 SkipTilesReturnedByTwin(tree_priority); |
184 pending_queue = layer_pair.pending->CreateRasterQueue( | |
185 tree_priority == SMOOTHNESS_TAKES_PRIORITY); | |
186 } | |
187 | |
188 if (has_both_layers) | |
189 SkipTilesReturnedByTwin(tree_priority); | |
190 | 219 |
191 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 220 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
192 "PairedTilingSetQueue::PairedTilingSetQueue", | 221 "PairedTilingSetQueue::PairedTilingSetQueue", |
193 TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue()); | 222 TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue()); |
194 } | 223 } |
195 | 224 |
196 RasterTilePriorityQueue::PairedTilingSetQueue::~PairedTilingSetQueue() { | 225 RasterTilePriorityQueue::PairedTilingSetQueue::~PairedTilingSetQueue() { |
197 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 226 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
198 "PairedTilingSetQueue::~PairedTilingSetQueue", | 227 "PairedTilingSetQueue::~PairedTilingSetQueue", |
199 TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue()); | 228 TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue()); |
(...skipping 21 matching lines...) Expand all Loading... | |
221 TreePriority tree_priority) { | 250 TreePriority tree_priority) { |
222 DCHECK(!IsEmpty()); | 251 DCHECK(!IsEmpty()); |
223 | 252 |
224 WhichTree next_tree = NextTileIteratorTree(tree_priority); | 253 WhichTree next_tree = NextTileIteratorTree(tree_priority); |
225 TilingSetRasterQueue* next_queue = | 254 TilingSetRasterQueue* next_queue = |
226 next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get(); | 255 next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get(); |
227 DCHECK(next_queue && !next_queue->IsEmpty()); | 256 DCHECK(next_queue && !next_queue->IsEmpty()); |
228 DCHECK(returned_tiles_for_debug.insert(next_queue->Top()).second); | 257 DCHECK(returned_tiles_for_debug.insert(next_queue->Top()).second); |
229 next_queue->Pop(); | 258 next_queue->Pop(); |
230 | 259 |
231 if (has_both_layers) | 260 SkipTilesReturnedByTwin(tree_priority); |
232 SkipTilesReturnedByTwin(tree_priority); | |
233 | 261 |
234 // If no empty, use Top to do DCHECK the next iterator. | 262 // If no empty, use Top to do DCHECK the next iterator. |
235 DCHECK(IsEmpty() || Top(tree_priority)); | 263 DCHECK(IsEmpty() || Top(tree_priority)); |
236 } | 264 } |
237 | 265 |
238 void RasterTilePriorityQueue::PairedTilingSetQueue::SkipTilesReturnedByTwin( | 266 void RasterTilePriorityQueue::PairedTilingSetQueue::SkipTilesReturnedByTwin( |
239 TreePriority tree_priority) { | 267 TreePriority tree_priority) { |
268 if (!has_both_layers) | |
269 return; | |
270 | |
240 // We have both layers (active and pending) thus we can encounter shared | 271 // We have both layers (active and pending) thus we can encounter shared |
241 // tiles twice (from the active iterator and from the pending iterator). | 272 // tiles twice (from the active iterator and from the pending iterator). |
242 while (!IsEmpty()) { | 273 while (!IsEmpty()) { |
243 WhichTree next_tree = NextTileIteratorTree(tree_priority); | 274 WhichTree next_tree = NextTileIteratorTree(tree_priority); |
244 TilingSetRasterQueue* next_queue = | 275 TilingSetRasterQueue* next_queue = |
245 next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get(); | 276 next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get(); |
246 DCHECK(next_queue && !next_queue->IsEmpty()); | 277 DCHECK(next_queue && !next_queue->IsEmpty()); |
247 | 278 |
248 // Accept all non-shared tiles. | 279 // Accept all non-shared tiles. |
249 const Tile* tile = next_queue->Top(); | 280 const Tile* tile = next_queue->Top(); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
308 | 339 |
309 state->BeginDictionary("pending_queue"); | 340 state->BeginDictionary("pending_queue"); |
310 state->SetBoolean("has_tile", active_queue_has_tile); | 341 state->SetBoolean("has_tile", active_queue_has_tile); |
311 state->SetInteger("active_priority_bin", active_priority_bin); | 342 state->SetInteger("active_priority_bin", active_priority_bin); |
312 state->SetInteger("pending_priority_bin", pending_priority_bin); | 343 state->SetInteger("pending_priority_bin", pending_priority_bin); |
313 state->EndDictionary(); | 344 state->EndDictionary(); |
314 return state; | 345 return state; |
315 } | 346 } |
316 | 347 |
317 } // namespace cc | 348 } // namespace cc |
OLD | NEW |