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

Side by Side Diff: cc/resources/raster_tile_priority_queue.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/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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698