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

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

Issue 246673005: cc: Start using raster/eviction iterators in tile manager (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 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 | Annotate | Revision Log
OLDNEW
1 // Copyright 2012 The Chromium Authors. All rights reserved. 1 // Copyright 2012 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/tile_manager.h" 5 #include "cc/resources/tile_manager.h"
6 6
7 #include <algorithm> 7 #include <algorithm>
8 #include <limits> 8 #include <limits>
9 #include <string> 9 #include <string>
10 10
(...skipping 227 matching lines...) Expand 10 before | Expand all | Expand 10 after
238 skia::RefPtr<SkPixelRef> pixel_ref_; 238 skia::RefPtr<SkPixelRef> pixel_ref_;
239 int layer_id_; 239 int layer_id_;
240 RenderingStatsInstrumentation* rendering_stats_; 240 RenderingStatsInstrumentation* rendering_stats_;
241 const base::Callback<void(bool was_canceled)> reply_; 241 const base::Callback<void(bool was_canceled)> reply_;
242 242
243 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl); 243 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
244 }; 244 };
245 245
246 const size_t kScheduledRasterTasksLimit = 32u; 246 const size_t kScheduledRasterTasksLimit = 32u;
247 247
248 // Memory limit policy works by mapping some bin states to the NEVER bin.
249 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
250 // [ALLOW_NOTHING]
251 {NEVER_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
252 NEVER_BIN, // [NOW_BIN]
253 NEVER_BIN, // [SOON_BIN]
254 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
255 NEVER_BIN, // [EVENTUALLY_BIN]
256 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN]
257 NEVER_BIN, // [AT_LAST_BIN]
258 NEVER_BIN // [NEVER_BIN]
259 },
260 // [ALLOW_ABSOLUTE_MINIMUM]
261 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
262 NOW_BIN, // [NOW_BIN]
263 NEVER_BIN, // [SOON_BIN]
264 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
265 NEVER_BIN, // [EVENTUALLY_BIN]
266 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN]
267 NEVER_BIN, // [AT_LAST_BIN]
268 NEVER_BIN // [NEVER_BIN]
269 },
270 // [ALLOW_PREPAINT_ONLY]
271 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
272 NOW_BIN, // [NOW_BIN]
273 SOON_BIN, // [SOON_BIN]
274 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
275 NEVER_BIN, // [EVENTUALLY_BIN]
276 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN]
277 NEVER_BIN, // [AT_LAST_BIN]
278 NEVER_BIN // [NEVER_BIN]
279 },
280 // [ALLOW_ANYTHING]
281 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
282 NOW_BIN, // [NOW_BIN]
283 SOON_BIN, // [SOON_BIN]
284 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
285 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
286 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
287 AT_LAST_BIN, // [AT_LAST_BIN]
288 NEVER_BIN // [NEVER_BIN]
289 }};
290
291 // Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN.
292 const ManagedTileBin kBinReadyToDrawMap[2][NUM_BINS] = {
293 // Not ready
294 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
295 NOW_BIN, // [NOW_BIN]
296 SOON_BIN, // [SOON_BIN]
297 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
298 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
299 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
300 AT_LAST_BIN, // [AT_LAST_BIN]
301 NEVER_BIN // [NEVER_BIN]
302 },
303 // Ready
304 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
305 NOW_AND_READY_TO_DRAW_BIN, // [NOW_BIN]
306 SOON_BIN, // [SOON_BIN]
307 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
308 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
309 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
310 AT_LAST_BIN, // [AT_LAST_BIN]
311 NEVER_BIN // [NEVER_BIN]
312 }};
313
314 // Active works by mapping some bin stats to equivalent _ACTIVE_BIN state.
315 const ManagedTileBin kBinIsActiveMap[2][NUM_BINS] = {
316 // Inactive
317 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
318 NOW_BIN, // [NOW_BIN]
319 SOON_BIN, // [SOON_BIN]
320 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
321 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
322 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
323 AT_LAST_BIN, // [AT_LAST_BIN]
324 NEVER_BIN // [NEVER_BIN]
325 },
326 // Active
327 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
328 NOW_BIN, // [NOW_BIN]
329 SOON_BIN, // [SOON_BIN]
330 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
331 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_BIN]
332 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
333 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_BIN]
334 NEVER_BIN // [NEVER_BIN]
335 }};
336
337 // Determine bin based on three categories of tiles: things we need now,
338 // things we need soon, and eventually.
339 inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) {
340 if (prio.priority_bin == TilePriority::NOW)
341 return NOW_BIN;
342
343 if (prio.priority_bin == TilePriority::SOON)
344 return SOON_BIN;
345
346 if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
347 return NEVER_BIN;
348
349 return EVENTUALLY_BIN;
350 }
351
352 } // namespace 248 } // namespace
353 249
354 RasterTaskCompletionStats::RasterTaskCompletionStats() 250 RasterTaskCompletionStats::RasterTaskCompletionStats()
355 : completed_count(0u), canceled_count(0u) {} 251 : completed_count(0u), canceled_count(0u) {}
356 252
357 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue( 253 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
358 const RasterTaskCompletionStats& stats) { 254 const RasterTaskCompletionStats& stats) {
359 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); 255 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
360 state->SetInteger("completed_count", stats.completed_count); 256 state->SetInteger("completed_count", stats.completed_count);
361 state->SetInteger("canceled_count", stats.canceled_count); 257 state->SetInteger("canceled_count", stats.canceled_count);
(...skipping 16 matching lines...) Expand all
378 274
379 TileManager::TileManager( 275 TileManager::TileManager(
380 TileManagerClient* client, 276 TileManagerClient* client,
381 ResourcePool* resource_pool, 277 ResourcePool* resource_pool,
382 Rasterizer* rasterizer, 278 Rasterizer* rasterizer,
383 bool use_rasterize_on_demand, 279 bool use_rasterize_on_demand,
384 RenderingStatsInstrumentation* rendering_stats_instrumentation) 280 RenderingStatsInstrumentation* rendering_stats_instrumentation)
385 : client_(client), 281 : client_(client),
386 resource_pool_(resource_pool), 282 resource_pool_(resource_pool),
387 rasterizer_(rasterizer), 283 rasterizer_(rasterizer),
388 prioritized_tiles_dirty_(false),
389 all_tiles_that_need_to_be_rasterized_have_memory_(true), 284 all_tiles_that_need_to_be_rasterized_have_memory_(true),
390 all_tiles_required_for_activation_have_memory_(true), 285 all_tiles_required_for_activation_have_memory_(true),
391 memory_required_bytes_(0),
392 memory_nice_to_have_bytes_(0),
393 bytes_releasable_(0), 286 bytes_releasable_(0),
394 resources_releasable_(0), 287 resources_releasable_(0),
395 ever_exceeded_memory_budget_(false), 288 ever_exceeded_memory_budget_(false),
396 rendering_stats_instrumentation_(rendering_stats_instrumentation), 289 rendering_stats_instrumentation_(rendering_stats_instrumentation),
397 did_initialize_visible_tile_(false), 290 did_initialize_visible_tile_(false),
398 did_check_for_completed_tasks_since_last_schedule_tasks_(true), 291 did_check_for_completed_tasks_since_last_schedule_tasks_(true),
399 use_rasterize_on_demand_(use_rasterize_on_demand) { 292 use_rasterize_on_demand_(use_rasterize_on_demand) {
400 rasterizer_->SetClient(this); 293 rasterizer_->SetClient(this);
401 } 294 }
402 295
(...skipping 19 matching lines...) Expand all
422 315
423 for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin(); 316 for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin();
424 it != layers_.end(); 317 it != layers_.end();
425 ++it) { 318 ++it) {
426 (*it)->DidUnregisterLayer(); 319 (*it)->DidUnregisterLayer();
427 } 320 }
428 layers_.clear(); 321 layers_.clear();
429 } 322 }
430 323
431 void TileManager::Release(Tile* tile) { 324 void TileManager::Release(Tile* tile) {
432 prioritized_tiles_dirty_ = true;
433 released_tiles_.push_back(tile); 325 released_tiles_.push_back(tile);
434 } 326 }
435 327
436 void TileManager::DidChangeTilePriority(Tile* tile) {
437 prioritized_tiles_dirty_ = true;
438 }
439
440 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { 328 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
441 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; 329 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
442 } 330 }
443 331
444 void TileManager::CleanUpReleasedTiles() { 332 void TileManager::CleanUpReleasedTiles() {
445 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); 333 for (std::vector<Tile*>::iterator it = released_tiles_.begin();
446 it != released_tiles_.end(); 334 it != released_tiles_.end();
447 ++it) { 335 ++it) {
448 Tile* tile = *it; 336 Tile* tile = *it;
449 ManagedTileState& mts = tile->managed_state(); 337 ManagedTileState& mts = tile->managed_state();
(...skipping 13 matching lines...) Expand all
463 used_layer_counts_.erase(layer_it); 351 used_layer_counts_.erase(layer_it);
464 image_decode_tasks_.erase(tile->layer_id()); 352 image_decode_tasks_.erase(tile->layer_id());
465 } 353 }
466 354
467 delete tile; 355 delete tile;
468 } 356 }
469 357
470 released_tiles_.clear(); 358 released_tiles_.clear();
471 } 359 }
472 360
473 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
474 if (!prioritized_tiles_dirty_)
475 return;
476
477 CleanUpReleasedTiles();
478
479 prioritized_tiles_.Clear();
480 GetTilesWithAssignedBins(&prioritized_tiles_);
481 prioritized_tiles_dirty_ = false;
482 }
483
484 void TileManager::DidFinishRunningTasks() { 361 void TileManager::DidFinishRunningTasks() {
485 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); 362 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
486 363
487 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() > 364 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() >
488 global_state_.soft_memory_limit_in_bytes; 365 global_state_.soft_memory_limit_in_bytes;
489 366
490 // When OOM, keep re-assigning memory until we reach a steady state 367 // When OOM, keep re-assigning memory until we reach a steady state
491 // where top-priority tiles are initialized. 368 // where top-priority tiles are initialized.
492 if (all_tiles_that_need_to_be_rasterized_have_memory_ && 369 if (all_tiles_that_need_to_be_rasterized_have_memory_ &&
493 !memory_usage_above_limit) 370 !memory_usage_above_limit)
494 return; 371 return;
495 372
496 rasterizer_->CheckForCompletedTasks(); 373 rasterizer_->CheckForCompletedTasks();
497 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 374 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
498 375
499 TileVector tiles_that_need_to_be_rasterized; 376 TileVector tiles_that_need_to_be_rasterized;
500 AssignGpuMemoryToTiles(&prioritized_tiles_, 377 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
501 &tiles_that_need_to_be_rasterized);
502 378
503 // |tiles_that_need_to_be_rasterized| will be empty when we reach a 379 // |tiles_that_need_to_be_rasterized| will be empty when we reach a
504 // steady memory state. Keep scheduling tasks until we reach this state. 380 // steady memory state. Keep scheduling tasks until we reach this state.
505 if (!tiles_that_need_to_be_rasterized.empty()) { 381 if (!tiles_that_need_to_be_rasterized.empty()) {
506 ScheduleTasks(tiles_that_need_to_be_rasterized); 382 ScheduleTasks(tiles_that_need_to_be_rasterized);
507 return; 383 return;
508 } 384 }
509 385
510 resource_pool_->ReduceResourceUsage(); 386 resource_pool_->ReduceResourceUsage();
511 387
(...skipping 29 matching lines...) Expand all
541 // activation are initialized when no tiles are OOM. We need to 417 // activation are initialized when no tiles are OOM. We need to
542 // wait for DidFinishRunningTasks() to be called, try to re-assign 418 // wait for DidFinishRunningTasks() to be called, try to re-assign
543 // memory and in worst case use on-demand raster when tiles 419 // memory and in worst case use on-demand raster when tiles
544 // required for activation are OOM. 420 // required for activation are OOM.
545 if (!all_tiles_required_for_activation_have_memory_) 421 if (!all_tiles_required_for_activation_have_memory_)
546 return; 422 return;
547 423
548 client_->NotifyReadyToActivate(); 424 client_->NotifyReadyToActivate();
549 } 425 }
550 426
551 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
552 TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
553
554 // Compute new stats to be return by GetMemoryStats().
555 memory_required_bytes_ = 0;
556 memory_nice_to_have_bytes_ = 0;
557
558 const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
559 const TreePriority tree_priority = global_state_.tree_priority;
560
561 // For each tree, bin into different categories of tiles.
562 for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
563 Tile* tile = it->second;
564 ManagedTileState& mts = tile->managed_state();
565
566 const ManagedTileState::TileVersion& tile_version =
567 tile->GetTileVersionForDrawing();
568 bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
569 bool tile_is_active = tile_is_ready_to_draw ||
570 mts.tile_versions[mts.raster_mode].raster_task_;
571
572 // Get the active priority and bin.
573 TilePriority active_priority = tile->priority(ACTIVE_TREE);
574 ManagedTileBin active_bin = BinFromTilePriority(active_priority);
575
576 // Get the pending priority and bin.
577 TilePriority pending_priority = tile->priority(PENDING_TREE);
578 ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
579
580 bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
581 bool pending_is_non_ideal =
582 pending_priority.resolution == NON_IDEAL_RESOLUTION;
583 bool active_is_non_ideal =
584 active_priority.resolution == NON_IDEAL_RESOLUTION;
585
586 // Adjust bin state based on if ready to draw.
587 active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
588 pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
589
590 // Adjust bin state based on if active.
591 active_bin = kBinIsActiveMap[tile_is_active][active_bin];
592 pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
593
594 // We never want to paint new non-ideal tiles, as we always have
595 // a high-res tile covering that content (paint that instead).
596 if (!tile_is_ready_to_draw && active_is_non_ideal)
597 active_bin = NEVER_BIN;
598 if (!tile_is_ready_to_draw && pending_is_non_ideal)
599 pending_bin = NEVER_BIN;
600
601 if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
602 // The bin that the tile would have if the GPU memory manager had
603 // a maximally permissive policy, send to the GPU memory manager
604 // to determine policy.
605 ManagedTileBin gpu_memmgr_stats_bin = std::min(active_bin, pending_bin);
606 if ((gpu_memmgr_stats_bin == NOW_BIN) ||
607 (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
608 memory_required_bytes_ += BytesConsumedIfAllocated(tile);
609 if (gpu_memmgr_stats_bin != NEVER_BIN)
610 memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
611 }
612
613 ManagedTileBin tree_bin[NUM_TREES];
614 tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
615 tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
616
617 // Adjust pending bin state for low res tiles. This prevents pending tree
618 // low-res tiles from being initialized before high-res tiles.
619 if (pending_is_low_res)
620 tree_bin[PENDING_TREE] = std::max(tree_bin[PENDING_TREE], EVENTUALLY_BIN);
621
622 TilePriority tile_priority;
623 switch (tree_priority) {
624 case SAME_PRIORITY_FOR_BOTH_TREES:
625 mts.bin = std::min(tree_bin[ACTIVE_TREE], tree_bin[PENDING_TREE]);
626 tile_priority = tile->combined_priority();
627 break;
628 case SMOOTHNESS_TAKES_PRIORITY:
629 mts.bin = tree_bin[ACTIVE_TREE];
630 tile_priority = active_priority;
631 break;
632 case NEW_CONTENT_TAKES_PRIORITY:
633 mts.bin = tree_bin[PENDING_TREE];
634 tile_priority = pending_priority;
635 break;
636 }
637
638 // Bump up the priority if we determined it's NEVER_BIN on one tree,
639 // but is still required on the other tree.
640 bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
641 tree_bin[PENDING_TREE] == NEVER_BIN;
642
643 if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
644 mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
645
646 mts.resolution = tile_priority.resolution;
647 mts.priority_bin = tile_priority.priority_bin;
648 mts.distance_to_visible = tile_priority.distance_to_visible;
649 mts.required_for_activation = tile_priority.required_for_activation;
650
651 mts.visible_and_ready_to_draw =
652 tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
653
654 // Tiles that are required for activation shouldn't be in NEVER_BIN unless
655 // smoothness takes priority or memory policy allows nothing to be
656 // initialized.
657 DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN ||
658 tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
659 memory_policy == ALLOW_NOTHING);
660
661 // If the tile is in NEVER_BIN and it does not have an active task, then we
662 // can release the resources early. If it does have the task however, we
663 // should keep it in the prioritized tile set to ensure that AssignGpuMemory
664 // can visit it.
665 if (mts.bin == NEVER_BIN &&
666 !mts.tile_versions[mts.raster_mode].raster_task_) {
667 FreeResourcesForTile(tile);
668 continue;
669 }
670
671 // Insert the tile into a priority set.
672 tiles->InsertTile(tile, mts.bin);
673 }
674 }
675
676 void TileManager::CleanUpLayers() { 427 void TileManager::CleanUpLayers() {
677 for (size_t i = 0; i < layers_.size(); ++i) { 428 for (size_t i = 0; i < layers_.size(); ++i) {
678 if (layers_[i]->IsDrawnRenderSurfaceLayerListMember()) 429 if (layers_[i]->IsDrawnRenderSurfaceLayerListMember())
679 continue; 430 continue;
680 431
681 layers_[i]->DidUnregisterLayer(); 432 layers_[i]->DidUnregisterLayer();
682 std::swap(layers_[i], layers_.back()); 433 std::swap(layers_[i], layers_.back());
683 layers_.pop_back(); 434 layers_.pop_back();
684 --i; 435 --i;
685 prioritized_tiles_dirty_ = true;
686 } 436 }
687 } 437 }
688 438
689 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) { 439 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
690 TRACE_EVENT0("cc", "TileManager::ManageTiles"); 440 TRACE_EVENT0("cc", "TileManager::ManageTiles");
691 441
692 // Update internal state. 442 // Update internal state.
693 if (state != global_state_) { 443 global_state_ = state;
694 global_state_ = state;
695 prioritized_tiles_dirty_ = true;
696 }
697 444
698 CleanUpLayers(); 445 CleanUpLayers();
699 446
447 // TODO(vmpstr): See if we still need to keep tiles alive when layers release
448 // them.
449 CleanUpReleasedTiles();
450
700 // We need to call CheckForCompletedTasks() once in-between each call 451 // We need to call CheckForCompletedTasks() once in-between each call
701 // to ScheduleTasks() to prevent canceled tasks from being scheduled. 452 // to ScheduleTasks() to prevent canceled tasks from being scheduled.
702 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { 453 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
703 rasterizer_->CheckForCompletedTasks(); 454 rasterizer_->CheckForCompletedTasks();
704 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 455 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
705 } 456 }
706 457
707 UpdatePrioritizedTileSetIfNeeded();
708
709 TileVector tiles_that_need_to_be_rasterized; 458 TileVector tiles_that_need_to_be_rasterized;
710 AssignGpuMemoryToTiles(&prioritized_tiles_, 459 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
711 &tiles_that_need_to_be_rasterized);
712 460
713 // Finally, schedule rasterizer tasks. 461 // Finally, schedule rasterizer tasks.
714 ScheduleTasks(tiles_that_need_to_be_rasterized); 462 ScheduleTasks(tiles_that_need_to_be_rasterized);
715 463
716 TRACE_EVENT_INSTANT1("cc", 464 TRACE_EVENT_INSTANT1("cc",
717 "DidManage", 465 "DidManage",
718 TRACE_EVENT_SCOPE_THREAD, 466 TRACE_EVENT_SCOPE_THREAD,
719 "state", 467 "state",
720 TracedValue::FromValue(BasicStateAsValue().release())); 468 TracedValue::FromValue(BasicStateAsValue().release()));
721 469
(...skipping 21 matching lines...) Expand all
743 491
744 bool did_initialize_visible_tile = did_initialize_visible_tile_; 492 bool did_initialize_visible_tile = did_initialize_visible_tile_;
745 did_initialize_visible_tile_ = false; 493 did_initialize_visible_tile_ = false;
746 return did_initialize_visible_tile; 494 return did_initialize_visible_tile;
747 } 495 }
748 496
749 void TileManager::GetMemoryStats(size_t* memory_required_bytes, 497 void TileManager::GetMemoryStats(size_t* memory_required_bytes,
750 size_t* memory_nice_to_have_bytes, 498 size_t* memory_nice_to_have_bytes,
751 size_t* memory_allocated_bytes, 499 size_t* memory_allocated_bytes,
752 size_t* memory_used_bytes) const { 500 size_t* memory_used_bytes) const {
753 *memory_required_bytes = memory_required_bytes_; 501 *memory_required_bytes = resource_pool_->total_memory_usage_bytes();
754 *memory_nice_to_have_bytes = memory_nice_to_have_bytes_; 502 *memory_nice_to_have_bytes = resource_pool_->total_memory_usage_bytes();
755 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes(); 503 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes();
756 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes(); 504 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes();
757 } 505 }
758 506
759 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const { 507 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
760 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); 508 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
761 state->SetInteger("tile_count", tiles_.size()); 509 state->SetInteger("tile_count", tiles_.size());
762 state->Set("global_state", global_state_.AsValue().release()); 510 state->Set("global_state", global_state_.AsValue().release());
763 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release()); 511 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
764 return state.PassAs<base::Value>(); 512 return state.PassAs<base::Value>();
(...skipping 19 matching lines...) Expand all
784 &memory_allocated_bytes, 532 &memory_allocated_bytes,
785 &memory_used_bytes); 533 &memory_used_bytes);
786 requirements->SetInteger("memory_required_bytes", memory_required_bytes); 534 requirements->SetInteger("memory_required_bytes", memory_required_bytes);
787 requirements->SetInteger("memory_nice_to_have_bytes", 535 requirements->SetInteger("memory_nice_to_have_bytes",
788 memory_nice_to_have_bytes); 536 memory_nice_to_have_bytes);
789 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes); 537 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes);
790 requirements->SetInteger("memory_used_bytes", memory_used_bytes); 538 requirements->SetInteger("memory_used_bytes", memory_used_bytes);
791 return requirements.PassAs<base::Value>(); 539 return requirements.PassAs<base::Value>();
792 } 540 }
793 541
542 bool TileManager::FreeTileResourcesUntilUsageIsWithinBudget(
543 EvictionTileIterator* eviction_iterator,
544 const MemoryBudget& required_budget,
545 MemoryBudget* current_budget,
546 const TilePriority& max_priority,
547 bool evict_unconditionally) {
548 bool evicted_tiles_required_for_activation = false;
549 while (required_budget.Exceeds(*current_budget)) {
550 if (!*eviction_iterator)
551 break;
552
553 Tile* eviction_tile = **eviction_iterator;
554 DCHECK(eviction_tile);
555
556 TilePriority eviction_priority =
557 eviction_tile->priority_for_tree_priority(global_state_.tree_priority);
558
559 if (!evict_unconditionally &&
560 !max_priority.IsHigherPriorityThan(eviction_priority))
561 break;
562
563 size_t eviction_bytes_if_allocated =
564 BytesConsumedIfAllocated(eviction_tile);
565 ManagedTileState& eviction_mts = eviction_tile->managed_state();
566 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
567 if (eviction_mts.tile_versions[mode].resource_) {
568 current_budget->hard_memory_bytes += eviction_bytes_if_allocated;
569 if (eviction_priority.priority_bin != TilePriority::NOW)
570 current_budget->soft_memory_bytes += eviction_bytes_if_allocated;
571 current_budget->resource_count++;
572 }
573 }
574 FreeResourcesForTile(eviction_tile);
575 ++(*eviction_iterator);
576
577 evicted_tiles_required_for_activation |=
578 eviction_tile->required_for_activation();
579 }
580 return evicted_tiles_required_for_activation;
581 }
582
583 bool TileManager::TilePriorityViolatesMemoryPolicy(
584 const TilePriority& priority) {
585 switch (global_state_.memory_limit_policy) {
586 case ALLOW_NOTHING:
587 return true;
588 case ALLOW_ABSOLUTE_MINIMUM:
589 return priority.priority_bin > TilePriority::NOW;
590 case ALLOW_PREPAINT_ONLY:
591 return priority.priority_bin > TilePriority::SOON;
592 case ALLOW_ANYTHING:
593 return priority.distance_to_visible ==
594 std::numeric_limits<float>::infinity();
595 case NUM_TILE_MEMORY_LIMIT_POLICIES:
reveman 2014/05/28 16:04:12 Please remove NUM_TILE_MEMORY_LIMIT_POLICIES and m
596 NOTREACHED();
597 break;
598 }
599 return true;
600 }
601
794 void TileManager::AssignGpuMemoryToTiles( 602 void TileManager::AssignGpuMemoryToTiles(
795 PrioritizedTileSet* tiles,
796 TileVector* tiles_that_need_to_be_rasterized) { 603 TileVector* tiles_that_need_to_be_rasterized) {
797 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); 604 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
798 605
799 // Maintain the list of released resources that can potentially be re-used 606 // Maintain the list of released resources that can potentially be re-used
800 // or deleted. 607 // or deleted.
801 // If this operation becomes expensive too, only do this after some 608 // If this operation becomes expensive too, only do this after some
802 // resource(s) was returned. Note that in that case, one also need to 609 // resource(s) was returned. Note that in that case, one also need to
803 // invalidate when releasing some resource from the pool. 610 // invalidate when releasing some resource from the pool.
804 resource_pool_->CheckBusyResources(); 611 resource_pool_->CheckBusyResources();
805 612
806 // Now give memory out to the tiles until we're out, and build 613 // Now give memory out to the tiles until we're out, and build
807 // the needs-to-be-rasterized queue. 614 // the needs-to-be-rasterized queue.
808 all_tiles_that_need_to_be_rasterized_have_memory_ = true; 615 all_tiles_that_need_to_be_rasterized_have_memory_ = true;
809 all_tiles_required_for_activation_have_memory_ = true; 616 all_tiles_required_for_activation_have_memory_ = true;
810 617
618 MemoryBudget budget;
811 // Cast to prevent overflow. 619 // Cast to prevent overflow.
812 int64 soft_bytes_available = 620 budget.soft_memory_bytes =
813 static_cast<int64>(bytes_releasable_) +
814 static_cast<int64>(global_state_.soft_memory_limit_in_bytes) - 621 static_cast<int64>(global_state_.soft_memory_limit_in_bytes) -
815 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); 622 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
816 int64 hard_bytes_available = 623 budget.hard_memory_bytes =
817 static_cast<int64>(bytes_releasable_) +
818 static_cast<int64>(global_state_.hard_memory_limit_in_bytes) - 624 static_cast<int64>(global_state_.hard_memory_limit_in_bytes) -
819 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); 625 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
820 int resources_available = resources_releasable_ + 626 budget.resource_count = global_state_.num_resources_limit -
821 global_state_.num_resources_limit - 627 resource_pool_->acquired_resource_count();
822 resource_pool_->acquired_resource_count(); 628
823 size_t soft_bytes_allocatable = 629 MemoryBudget initial_budget = budget;
824 std::max(static_cast<int64>(0), soft_bytes_available); 630
825 size_t hard_bytes_allocatable = 631 EvictionTileIterator eviction_it(this, global_state_.tree_priority);
826 std::max(static_cast<int64>(0), hard_bytes_available); 632
827 size_t resources_allocatable = std::max(0, resources_available); 633 MemoryBudget required_budget;
634 required_budget.soft_memory_bytes = 0;
635 required_budget.hard_memory_bytes = 0;
636 required_budget.resource_count = 0;
637
638 bool evicted_tiles_required_for_activation =
639 FreeTileResourcesUntilUsageIsWithinBudget(
640 &eviction_it, required_budget, &budget, TilePriority(), true);
828 641
829 size_t bytes_that_exceeded_memory_budget = 0; 642 size_t bytes_that_exceeded_memory_budget = 0;
830 size_t soft_bytes_left = soft_bytes_allocatable;
831 size_t hard_bytes_left = hard_bytes_allocatable;
832 643
833 size_t resources_left = resources_allocatable;
834 bool oomed_soft = false; 644 bool oomed_soft = false;
835 bool oomed_hard = false; 645 bool oomed_hard = false;
836 bool have_hit_soft_memory = false; // Soft memory comes after hard. 646 bool have_hit_soft_memory = false; // Soft memory comes after hard.
837 647
838 unsigned schedule_priority = 1u; 648 unsigned schedule_priority = 1u;
839 for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) { 649 for (RasterTileIterator it(this, global_state_.tree_priority); it; ++it) {
840 Tile* tile = *it; 650 Tile* tile = *it;
651 TilePriority priority =
652 tile->priority_for_tree_priority(global_state_.tree_priority);
653
654 if (TilePriorityViolatesMemoryPolicy(priority))
655 break;
656
841 ManagedTileState& mts = tile->managed_state(); 657 ManagedTileState& mts = tile->managed_state();
842 658
843 mts.scheduled_priority = schedule_priority++; 659 mts.scheduled_priority = schedule_priority++;
844 660
845 mts.raster_mode = tile->DetermineOverallRasterMode(); 661 mts.raster_mode = tile->DetermineOverallRasterMode();
846 662
847 ManagedTileState::TileVersion& tile_version = 663 ManagedTileState::TileVersion& tile_version =
848 mts.tile_versions[mts.raster_mode]; 664 mts.tile_versions[mts.raster_mode];
849 665
850 // If this tile doesn't need a resource, then nothing to do. 666 // If this tile version is ready to draw, then nothing to do.
851 if (!tile_version.requires_resource()) 667 if (tile_version.IsReadyToDraw())
852 continue; 668 continue;
853 669
854 // If the tile is not needed, free it up. 670 const bool tile_uses_hard_limit =
855 if (mts.bin == NEVER_BIN) { 671 priority.priority_bin == TilePriority::NOW;
856 FreeResourcesForTile(tile);
857 continue;
858 }
859
860 const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
861 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile); 672 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
862 const size_t tile_bytes_left =
863 (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
864 673
865 // Hard-limit is reserved for tiles that would cause a calamity 674 // Hard-limit is reserved for tiles that would cause a calamity
866 // if they were to go away, so by definition they are the highest 675 // if they were to go away, so by definition they are the highest
867 // priority memory, and must be at the front of the list. 676 // priority memory, and must be at the front of the list.
868 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit)); 677 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit));
869 have_hit_soft_memory |= !tile_uses_hard_limit; 678 have_hit_soft_memory |= !tile_uses_hard_limit;
870 679
871 size_t tile_bytes = 0; 680 int64 tile_bytes = 0;
872 size_t tile_resources = 0; 681 int tile_resources = 0;
873 682
874 // It costs to maintain a resource. 683 // It costs to maintain a resource.
875 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 684 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
876 if (mts.tile_versions[mode].resource_) { 685 if (mts.tile_versions[mode].resource_) {
877 tile_bytes += bytes_if_allocated; 686 tile_bytes += bytes_if_allocated;
878 tile_resources++; 687 tile_resources++;
879 } 688 }
880 } 689 }
881 690
882 // Allow lower priority tiles with initialized resources to keep 691 // If we don't have the required version, and it's not in flight
883 // their memory by only assigning memory to new raster tasks if 692 // then we'll have to pay to create a new task.
884 // they can be scheduled. 693 if (!tile_version.resource_ && !tile_version.raster_task_) {
885 bool reached_scheduled_raster_tasks_limit = 694 tile_bytes += bytes_if_allocated;
886 tiles_that_need_to_be_rasterized->size() >= kScheduledRasterTasksLimit; 695 tile_resources++;
887 if (!reached_scheduled_raster_tasks_limit) {
888 // If we don't have the required version, and it's not in flight
889 // then we'll have to pay to create a new task.
890 if (!tile_version.resource_ && !tile_version.raster_task_) {
891 tile_bytes += bytes_if_allocated;
892 tile_resources++;
893 }
894 } 696 }
895 697
896 // Tile is OOM. 698 required_budget.soft_memory_bytes = 0;
897 if (tile_bytes > tile_bytes_left || tile_resources > resources_left) { 699 required_budget.hard_memory_bytes = 0;
700 required_budget.resource_count = tile_resources;
701 if (tile_uses_hard_limit)
702 required_budget.hard_memory_bytes = tile_bytes;
703 else
704 required_budget.soft_memory_bytes = tile_bytes;
705
706 // Handle OOM tiles.
707 evicted_tiles_required_for_activation =
708 FreeTileResourcesUntilUsageIsWithinBudget(
709 &eviction_it, required_budget, &budget, priority, false) ||
710 evicted_tiles_required_for_activation;
711
712 // Tile is still OOM.
713 if (required_budget.Exceeds(budget)) {
898 FreeResourcesForTile(tile); 714 FreeResourcesForTile(tile);
899 715
900 // This tile was already on screen and now its resources have been 716 // This tile was already on screen and now its resources have been
901 // released. In order to prevent checkerboarding, set this tile as 717 // released. In order to prevent checkerboarding, set this tile as
902 // rasterize on demand immediately. 718 // rasterize on demand immediately.
903 if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_) 719 if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_)
904 tile_version.set_rasterize_on_demand(); 720 tile_version.set_rasterize_on_demand();
905 721
906 oomed_soft = true; 722 oomed_soft = true;
907 if (tile_uses_hard_limit) { 723 if (tile_uses_hard_limit) {
908 oomed_hard = true; 724 oomed_hard = true;
909 bytes_that_exceeded_memory_budget += tile_bytes; 725 bytes_that_exceeded_memory_budget += tile_bytes;
910 } 726 }
911 } else { 727 } else {
912 resources_left -= tile_resources; 728 budget.resource_count -= tile_resources;
913 hard_bytes_left -= tile_bytes; 729 budget.hard_memory_bytes -= tile_bytes;
914 soft_bytes_left = 730 budget.soft_memory_bytes = (budget.soft_memory_bytes > tile_bytes)
915 (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0; 731 ? budget.soft_memory_bytes - tile_bytes
732 : 0;
916 if (tile_version.resource_) 733 if (tile_version.resource_)
917 continue; 734 continue;
918 } 735 }
919 736
920 DCHECK(!tile_version.resource_); 737 DCHECK(!tile_version.resource_);
921 738
922 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized| 739 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
923 // has reached it's limit or we've failed to assign gpu memory to this 740 // has reached it's limit or we've failed to assign gpu memory to this
924 // or any higher priority tile. Preventing tiles that fit into memory 741 // or any higher priority tile. Preventing tiles that fit into memory
925 // budget to be rasterized when higher priority tile is oom is 742 // budget to be rasterized when higher priority tile is oom is
926 // important for two reasons: 743 // important for two reasons:
927 // 1. Tile size should not impact raster priority. 744 // 1. Tile size should not impact raster priority.
928 // 2. Tiles with existing raster task could otherwise incorrectly 745 // 2. Tiles with existing raster task could otherwise incorrectly
929 // be added as they are not affected by |bytes_allocatable|. 746 // be added as they are not affected by |bytes_allocatable|.
930 bool can_schedule_tile = 747 bool can_schedule_tile =
931 !oomed_soft && !reached_scheduled_raster_tasks_limit; 748 !oomed_soft &&
749 tiles_that_need_to_be_rasterized->size() < kScheduledRasterTasksLimit;
932 750
933 if (!can_schedule_tile) { 751 if (!can_schedule_tile) {
934 all_tiles_that_need_to_be_rasterized_have_memory_ = false; 752 all_tiles_that_need_to_be_rasterized_have_memory_ = false;
935 if (tile->required_for_activation()) 753 all_tiles_required_for_activation_have_memory_ =
reveman 2014/05/28 16:04:12 I don't think all_tiles_required_for_activation_ha
936 all_tiles_required_for_activation_have_memory_ = false; 754 !it.HasTilesRequiredForActivation() &&
937 it.DisablePriorityOrdering(); 755 !evicted_tiles_required_for_activation;
938 continue; 756 break;
939 } 757 }
940 758
941 tiles_that_need_to_be_rasterized->push_back(tile); 759 tiles_that_need_to_be_rasterized->push_back(tile);
942 } 760 }
943 761
944 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit. 762 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
945 ever_exceeded_memory_budget_ |= oomed_hard; 763 ever_exceeded_memory_budget_ |= oomed_hard;
946 if (ever_exceeded_memory_budget_) { 764 if (ever_exceeded_memory_budget_) {
947 TRACE_COUNTER_ID2("cc", 765 TRACE_COUNTER_ID2("cc",
948 "over_memory_budget", 766 "over_memory_budget",
949 this, 767 this,
950 "budget", 768 "budget",
951 global_state_.hard_memory_limit_in_bytes, 769 global_state_.hard_memory_limit_in_bytes,
952 "over", 770 "over",
953 bytes_that_exceeded_memory_budget); 771 bytes_that_exceeded_memory_budget);
954 } 772 }
955 memory_stats_from_last_assign_.total_budget_in_bytes = 773 memory_stats_from_last_assign_.total_budget_in_bytes =
956 global_state_.hard_memory_limit_in_bytes; 774 global_state_.hard_memory_limit_in_bytes;
957 memory_stats_from_last_assign_.bytes_allocated = 775 memory_stats_from_last_assign_.bytes_allocated =
958 hard_bytes_allocatable - hard_bytes_left; 776 initial_budget.hard_memory_bytes - budget.hard_memory_bytes;
959 memory_stats_from_last_assign_.bytes_unreleasable = 777 memory_stats_from_last_assign_.bytes_unreleasable =
960 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_; 778 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_;
961 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget; 779 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget;
962 } 780 }
963 781
964 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) { 782 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
965 ManagedTileState& mts = tile->managed_state(); 783 ManagedTileState& mts = tile->managed_state();
966 if (mts.tile_versions[mode].resource_) { 784 if (mts.tile_versions[mode].resource_) {
967 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass()); 785 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass());
968 786
(...skipping 241 matching lines...) Expand 10 before | Expand all | Expand 10 after
1210 content_rect, 1028 content_rect,
1211 opaque_rect, 1029 opaque_rect,
1212 contents_scale, 1030 contents_scale,
1213 layer_id, 1031 layer_id,
1214 source_frame_number, 1032 source_frame_number,
1215 flags)); 1033 flags));
1216 DCHECK(tiles_.find(tile->id()) == tiles_.end()); 1034 DCHECK(tiles_.find(tile->id()) == tiles_.end());
1217 1035
1218 tiles_[tile->id()] = tile; 1036 tiles_[tile->id()] = tile;
1219 used_layer_counts_[tile->layer_id()]++; 1037 used_layer_counts_[tile->layer_id()]++;
1220 prioritized_tiles_dirty_ = true;
1221 return tile; 1038 return tile;
1222 } 1039 }
1223 1040
1224 void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) { 1041 void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
1225 DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end()); 1042 DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end());
1226 layers_.push_back(layer); 1043 layers_.push_back(layer);
1227 } 1044 }
1228 1045
1229 void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { 1046 void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
1230 std::vector<PictureLayerImpl*>::iterator it = 1047 std::vector<PictureLayerImpl*>::iterator it =
(...skipping 14 matching lines...) Expand all
1245 PictureLayerImpl* layer = *it; 1062 PictureLayerImpl* layer = *it;
1246 1063
1247 // This is a recycle tree layer, we can safely skip since the tiles on this 1064 // This is a recycle tree layer, we can safely skip since the tiles on this
1248 // layer have to be accessible via the active tree. 1065 // layer have to be accessible via the active tree.
1249 if (!layer->IsOnActiveOrPendingTree()) 1066 if (!layer->IsOnActiveOrPendingTree())
1250 continue; 1067 continue;
1251 1068
1252 PictureLayerImpl* twin_layer = layer->GetTwinLayer(); 1069 PictureLayerImpl* twin_layer = layer->GetTwinLayer();
1253 1070
1254 // If the twin layer is recycled, it is not a valid twin. 1071 // If the twin layer is recycled, it is not a valid twin.
1255 if (twin_layer && !twin_layer->IsOnActiveOrPendingTree()) 1072 // Note another case twin is not valid is if it wasn't yet registered in
1073 // this tile manager. This can happen at the start of a new page when we
1074 // only update the pending tree's priority after the first commit.
1075 if (twin_layer && (!twin_layer->IsOnActiveOrPendingTree() ||
1076 !twin_layer->LayerRegisteredInTileManager())) {
1256 twin_layer = NULL; 1077 twin_layer = NULL;
1078 }
1257 1079
1258 PairedPictureLayer paired_layer; 1080 PairedPictureLayer paired_layer;
1259 WhichTree tree = layer->GetTree(); 1081 WhichTree tree = layer->GetTree();
1260 1082
1261 // If the current tree is ACTIVE_TREE, then always generate a paired_layer. 1083 // If the current tree is ACTIVE_TREE, then always generate a paired_layer.
1262 // If current tree is PENDING_TREE, then only generate a paired_layer if 1084 // If current tree is PENDING_TREE, then only generate a paired_layer if
1263 // there is no twin layer. 1085 // there is no twin layer.
1264 if (tree == ACTIVE_TREE) { 1086 if (tree == ACTIVE_TREE) {
1265 DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE); 1087 DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE);
1266 paired_layer.active_layer = layer; 1088 paired_layer.active_layer = layer;
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
1309 paired_iterators_.push_back(paired_iterator); 1131 paired_iterators_.push_back(paired_iterator);
1310 iterator_heap_.push_back(&paired_iterators_.back()); 1132 iterator_heap_.push_back(&paired_iterators_.back());
1311 } 1133 }
1312 } 1134 }
1313 1135
1314 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); 1136 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
1315 } 1137 }
1316 1138
1317 TileManager::RasterTileIterator::~RasterTileIterator() {} 1139 TileManager::RasterTileIterator::~RasterTileIterator() {}
1318 1140
1141 bool TileManager::RasterTileIterator::HasTilesRequiredForActivation() const {
1142 for (std::vector<PairedPictureLayerIterator*>::const_iterator it =
1143 iterator_heap_.begin();
1144 it != iterator_heap_.end();
1145 ++it) {
1146 const PairedPictureLayerIterator* pair = *it;
1147
1148 // Tiles required for activation can only come from pending layers.
1149 if (pair->pending_iterator.HasTilesRequiredForActivation())
1150 return true;
1151 }
1152 return false;
1153 }
1154
1319 TileManager::RasterTileIterator& TileManager::RasterTileIterator::operator++() { 1155 TileManager::RasterTileIterator& TileManager::RasterTileIterator::operator++() {
1320 DCHECK(*this); 1156 DCHECK(*this);
1321 1157
1322 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); 1158 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
1323 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back(); 1159 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back();
1324 iterator_heap_.pop_back(); 1160 iterator_heap_.pop_back();
1325 1161
1326 paired_iterator->PopTile(tree_priority_); 1162 paired_iterator->PopTile(tree_priority_);
1327 if (paired_iterator->PeekTile(tree_priority_) != NULL) { 1163 if (paired_iterator->PeekTile(tree_priority_) != NULL) {
1328 iterator_heap_.push_back(paired_iterator); 1164 iterator_heap_.push_back(paired_iterator);
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after
1441 1277
1442 Tile* a_tile = **a_pair.first; 1278 Tile* a_tile = **a_pair.first;
1443 Tile* b_tile = **b_pair.first; 1279 Tile* b_tile = **b_pair.first;
1444 1280
1445 const TilePriority& a_priority = 1281 const TilePriority& a_priority =
1446 a_tile->priority_for_tree_priority(tree_priority_); 1282 a_tile->priority_for_tree_priority(tree_priority_);
1447 const TilePriority& b_priority = 1283 const TilePriority& b_priority =
1448 b_tile->priority_for_tree_priority(tree_priority_); 1284 b_tile->priority_for_tree_priority(tree_priority_);
1449 bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY; 1285 bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
1450 1286
1451 if (b_priority.resolution != a_priority.resolution) { 1287 if (b_priority.priority_bin == a_priority.priority_bin &&
1288 b_priority.resolution != a_priority.resolution) {
1452 return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) || 1289 return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) ||
1453 (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) || 1290 (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) ||
1454 (a_priority.resolution == NON_IDEAL_RESOLUTION); 1291 (a_priority.resolution == NON_IDEAL_RESOLUTION);
1455 } 1292 }
1456 1293
1457 return b_priority.IsHigherPriorityThan(a_priority); 1294 return b_priority.IsHigherPriorityThan(a_priority);
1458 } 1295 }
1459 1296
1460 TileManager::EvictionTileIterator::EvictionTileIterator() 1297 TileManager::EvictionTileIterator::EvictionTileIterator()
1461 : comparator_(SAME_PRIORITY_FOR_BOTH_TREES) {} 1298 : initialized_(true),
1299 tile_manager_(NULL),
1300 comparator_(SAME_PRIORITY_FOR_BOTH_TREES) {
1301 }
1462 1302
1463 TileManager::EvictionTileIterator::EvictionTileIterator( 1303 TileManager::EvictionTileIterator::EvictionTileIterator(
1464 TileManager* tile_manager, 1304 TileManager* tile_manager,
1465 TreePriority tree_priority) 1305 TreePriority tree_priority)
1466 : tree_priority_(tree_priority), comparator_(tree_priority) { 1306 : initialized_(false),
1307 tile_manager_(tile_manager),
1308 tree_priority_(tree_priority),
1309 comparator_(tree_priority) {
1310 }
1311
1312 void TileManager::EvictionTileIterator::Initialize() {
1467 std::vector<TileManager::PairedPictureLayer> paired_layers; 1313 std::vector<TileManager::PairedPictureLayer> paired_layers;
1468 1314
1469 tile_manager->GetPairedPictureLayers(&paired_layers); 1315 tile_manager_->GetPairedPictureLayers(&paired_layers);
1470 1316
1471 paired_iterators_.reserve(paired_layers.size()); 1317 paired_iterators_.reserve(paired_layers.size());
1472 iterator_heap_.reserve(paired_layers.size()); 1318 iterator_heap_.reserve(paired_layers.size());
1473 for (std::vector<TileManager::PairedPictureLayer>::iterator it = 1319 for (std::vector<TileManager::PairedPictureLayer>::iterator it =
1474 paired_layers.begin(); 1320 paired_layers.begin();
1475 it != paired_layers.end(); 1321 it != paired_layers.end();
1476 ++it) { 1322 ++it) {
1477 PairedPictureLayerIterator paired_iterator; 1323 PairedPictureLayerIterator paired_iterator;
1478 if (it->active_layer) { 1324 if (it->active_layer) {
1479 paired_iterator.active_iterator = 1325 paired_iterator.active_iterator =
1480 PictureLayerImpl::LayerEvictionTileIterator(it->active_layer, 1326 PictureLayerImpl::LayerEvictionTileIterator(it->active_layer,
1481 tree_priority_); 1327 tree_priority_);
1482 } 1328 }
1483 1329
1484 if (it->pending_layer) { 1330 if (it->pending_layer) {
1485 paired_iterator.pending_iterator = 1331 paired_iterator.pending_iterator =
1486 PictureLayerImpl::LayerEvictionTileIterator(it->pending_layer, 1332 PictureLayerImpl::LayerEvictionTileIterator(it->pending_layer,
1487 tree_priority_); 1333 tree_priority_);
1488 } 1334 }
1489 1335
1490 if (paired_iterator.PeekTile(tree_priority_) != NULL) { 1336 if (paired_iterator.PeekTile(tree_priority_) != NULL) {
1491 paired_iterators_.push_back(paired_iterator); 1337 paired_iterators_.push_back(paired_iterator);
1492 iterator_heap_.push_back(&paired_iterators_.back()); 1338 iterator_heap_.push_back(&paired_iterators_.back());
1493 } 1339 }
1494 } 1340 }
1495 1341
1496 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); 1342 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
1343 initialized_ = true;
1497 } 1344 }
1498 1345
1499 TileManager::EvictionTileIterator::~EvictionTileIterator() {} 1346 TileManager::EvictionTileIterator::~EvictionTileIterator() {}
1500 1347
1501 TileManager::EvictionTileIterator& TileManager::EvictionTileIterator:: 1348 TileManager::EvictionTileIterator& TileManager::EvictionTileIterator::
1502 operator++() { 1349 operator++() {
1350 DCHECK(initialized_);
1351
1503 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); 1352 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
1504 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back(); 1353 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back();
1505 iterator_heap_.pop_back(); 1354 iterator_heap_.pop_back();
1506 1355
1507 paired_iterator->PopTile(tree_priority_); 1356 paired_iterator->PopTile(tree_priority_);
1508 if (paired_iterator->PeekTile(tree_priority_) != NULL) { 1357 if (paired_iterator->PeekTile(tree_priority_) != NULL) {
1509 iterator_heap_.push_back(paired_iterator); 1358 iterator_heap_.push_back(paired_iterator);
1510 std::push_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); 1359 std::push_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
1511 } 1360 }
1512 return *this; 1361 return *this;
1513 } 1362 }
1514 1363
1515 TileManager::EvictionTileIterator::operator bool() const { 1364 TileManager::EvictionTileIterator::operator bool() {
1365 if (!initialized_)
1366 Initialize();
1367
1516 return !iterator_heap_.empty(); 1368 return !iterator_heap_.empty();
1517 } 1369 }
1518 1370
1519 Tile* TileManager::EvictionTileIterator::operator*() { 1371 Tile* TileManager::EvictionTileIterator::operator*() {
1372 DCHECK(initialized_);
1520 DCHECK(*this); 1373 DCHECK(*this);
1521 return iterator_heap_.front()->PeekTile(tree_priority_); 1374 return iterator_heap_.front()->PeekTile(tree_priority_);
1522 } 1375 }
1523 1376
1524 TileManager::EvictionTileIterator::PairedPictureLayerIterator:: 1377 TileManager::EvictionTileIterator::PairedPictureLayerIterator::
1525 PairedPictureLayerIterator() {} 1378 PairedPictureLayerIterator() {}
1526 1379
1527 TileManager::EvictionTileIterator::PairedPictureLayerIterator:: 1380 TileManager::EvictionTileIterator::PairedPictureLayerIterator::
1528 ~PairedPictureLayerIterator() {} 1381 ~PairedPictureLayerIterator() {}
1529 1382
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
1621 } 1474 }
1622 return a_priority.IsHigherPriorityThan(b_priority); 1475 return a_priority.IsHigherPriorityThan(b_priority);
1623 } 1476 }
1624 1477
1625 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) { 1478 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
1626 rasterizer_ = rasterizer; 1479 rasterizer_ = rasterizer;
1627 rasterizer_->SetClient(this); 1480 rasterizer_->SetClient(this);
1628 } 1481 }
1629 1482
1630 } // namespace cc 1483 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698