OLD | NEW |
---|---|
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 371 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
382 base::Bind(&TileManager::CheckIfReadyToActivate, | 382 base::Bind(&TileManager::CheckIfReadyToActivate, |
383 base::Unretained(this))) { | 383 base::Unretained(this))) { |
384 rasterizer_->SetClient(this); | 384 rasterizer_->SetClient(this); |
385 } | 385 } |
386 | 386 |
387 TileManager::~TileManager() { | 387 TileManager::~TileManager() { |
388 // Reset global state and manage. This should cause | 388 // Reset global state and manage. This should cause |
389 // our memory usage to drop to zero. | 389 // our memory usage to drop to zero. |
390 global_state_ = GlobalStateThatImpactsTilePriority(); | 390 global_state_ = GlobalStateThatImpactsTilePriority(); |
391 | 391 |
392 CleanUpReleasedTiles(); | |
393 DCHECK_EQ(0u, tiles_.size()); | |
394 | |
395 RasterTaskQueue empty; | 392 RasterTaskQueue empty; |
396 rasterizer_->ScheduleTasks(&empty); | 393 rasterizer_->ScheduleTasks(&empty); |
397 orphan_raster_tasks_.clear(); | 394 orphan_raster_tasks_.clear(); |
398 | 395 |
399 // This should finish all pending tasks and release any uninitialized | 396 // This should finish all pending tasks and release any uninitialized |
400 // resources. | 397 // resources. |
401 rasterizer_->Shutdown(); | 398 rasterizer_->Shutdown(); |
402 rasterizer_->CheckForCompletedTasks(); | 399 rasterizer_->CheckForCompletedTasks(); |
403 | 400 |
401 FreeResourcesForReleasedTiles(); | |
402 | |
404 DCHECK_EQ(0u, bytes_releasable_); | 403 DCHECK_EQ(0u, bytes_releasable_); |
405 DCHECK_EQ(0u, resources_releasable_); | 404 DCHECK_EQ(0u, resources_releasable_); |
406 } | 405 } |
407 | 406 |
408 void TileManager::Release(Tile* tile) { | 407 void TileManager::Release(Tile* tile) { |
408 DCHECK(TilePriority() == tile->combined_priority()); | |
409 | |
409 prioritized_tiles_dirty_ = true; | 410 prioritized_tiles_dirty_ = true; |
410 released_tiles_.push_back(tile); | 411 released_tiles_.push_back(tile); |
411 } | 412 } |
412 | 413 |
413 void TileManager::DidChangeTilePriority(Tile* tile) { | 414 void TileManager::DidChangeTilePriority(Tile* tile) { |
414 prioritized_tiles_dirty_ = true; | 415 prioritized_tiles_dirty_ = true; |
415 } | 416 } |
416 | 417 |
417 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { | 418 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { |
418 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; | 419 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; |
419 } | 420 } |
420 | 421 |
421 void TileManager::CleanUpReleasedTiles() { | 422 void TileManager::FreeResourcesForReleasedTiles() { |
422 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); | 423 for (ScopedVector<Tile>::iterator it = released_tiles_.begin(); |
423 it != released_tiles_.end(); | 424 it != released_tiles_.end(); |
424 ++it) { | 425 ++it) { |
425 Tile* tile = *it; | 426 Tile* tile = *it; |
426 ManagedTileState& mts = tile->managed_state(); | 427 FreeResourcesForTile(tile); |
428 } | |
429 } | |
427 | 430 |
428 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 431 void TileManager::CleanUpReleasedTiles() { |
429 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); | 432 // Ensure the prioritized set is rebuild. |
430 orphan_raster_tasks_.push_back(mts.tile_versions[mode].raster_task_); | 433 DCHECK(prioritized_tiles_dirty_); |
reveman
2014/07/28 02:24:35
Let's change this to DCHECK(prioritized_tiles_.Emp
sohanjg
2014/07/28 10:10:19
Are you sure we want this, because if we check for
reveman
2014/07/28 15:50:53
I want the check to prevent this from being broken
sohanjg
2014/07/28 17:36:02
OK.
The test fails when this is invoked from Updat
reveman
2014/07/28 18:27:51
yes, it's of course not going to work otherwise.
sohanjg
2014/07/30 11:12:56
Done.
| |
434 | |
435 ScopedVector<Tile>::iterator it = released_tiles_.begin(); | |
436 while (it != released_tiles_.end()) { | |
437 Tile* tile = *it; | |
438 | |
439 if (tile->HasRasterTask()) { | |
440 ++it; | |
441 continue; | |
431 } | 442 } |
432 | 443 |
444 DCHECK(!tile->HasResources()); | |
433 DCHECK(tiles_.find(tile->id()) != tiles_.end()); | 445 DCHECK(tiles_.find(tile->id()) != tiles_.end()); |
434 tiles_.erase(tile->id()); | 446 tiles_.erase(tile->id()); |
435 | 447 |
436 LayerCountMap::iterator layer_it = | 448 LayerCountMap::iterator layer_it = |
437 used_layer_counts_.find(tile->layer_id()); | 449 used_layer_counts_.find(tile->layer_id()); |
438 DCHECK_GT(layer_it->second, 0); | 450 DCHECK_GT(layer_it->second, 0); |
439 if (--layer_it->second == 0) { | 451 if (--layer_it->second == 0) { |
440 used_layer_counts_.erase(layer_it); | 452 used_layer_counts_.erase(layer_it); |
441 image_decode_tasks_.erase(tile->layer_id()); | 453 image_decode_tasks_.erase(tile->layer_id()); |
442 } | 454 } |
443 | 455 |
444 delete tile; | 456 delete tile; |
457 it = released_tiles_.weak_erase(it); | |
reveman
2014/07/28 02:24:35
remove "delete tile" and use standard erase instea
sohanjg
2014/07/28 10:10:19
Done.
| |
445 } | 458 } |
446 | |
447 released_tiles_.clear(); | |
448 } | 459 } |
449 | 460 |
450 void TileManager::UpdatePrioritizedTileSetIfNeeded() { | 461 void TileManager::UpdatePrioritizedTileSetIfNeeded() { |
451 if (!prioritized_tiles_dirty_) | 462 if (!prioritized_tiles_dirty_) |
452 return; | 463 return; |
453 | 464 |
465 FreeResourcesForReleasedTiles(); | |
454 CleanUpReleasedTiles(); | 466 CleanUpReleasedTiles(); |
455 | 467 |
456 prioritized_tiles_.Clear(); | 468 prioritized_tiles_.Clear(); |
457 GetTilesWithAssignedBins(&prioritized_tiles_); | 469 GetTilesWithAssignedBins(&prioritized_tiles_); |
458 prioritized_tiles_dirty_ = false; | 470 prioritized_tiles_dirty_ = false; |
459 } | 471 } |
460 | 472 |
461 void TileManager::DidFinishRunningTasks() { | 473 void TileManager::DidFinishRunningTasks() { |
462 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); | 474 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); |
463 | 475 |
(...skipping 13 matching lines...) Expand all Loading... | |
477 AssignGpuMemoryToTiles(&prioritized_tiles_, | 489 AssignGpuMemoryToTiles(&prioritized_tiles_, |
478 &tiles_that_need_to_be_rasterized); | 490 &tiles_that_need_to_be_rasterized); |
479 | 491 |
480 // |tiles_that_need_to_be_rasterized| will be empty when we reach a | 492 // |tiles_that_need_to_be_rasterized| will be empty when we reach a |
481 // steady memory state. Keep scheduling tasks until we reach this state. | 493 // steady memory state. Keep scheduling tasks until we reach this state. |
482 if (!tiles_that_need_to_be_rasterized.empty()) { | 494 if (!tiles_that_need_to_be_rasterized.empty()) { |
483 ScheduleTasks(tiles_that_need_to_be_rasterized); | 495 ScheduleTasks(tiles_that_need_to_be_rasterized); |
484 return; | 496 return; |
485 } | 497 } |
486 | 498 |
499 FreeResourcesForReleasedTiles(); | |
500 | |
487 resource_pool_->ReduceResourceUsage(); | 501 resource_pool_->ReduceResourceUsage(); |
488 | 502 |
489 // We don't reserve memory for required-for-activation tiles during | 503 // We don't reserve memory for required-for-activation tiles during |
490 // accelerated gestures, so we just postpone activation when we don't | 504 // accelerated gestures, so we just postpone activation when we don't |
491 // have these tiles, and activate after the accelerated gesture. | 505 // have these tiles, and activate after the accelerated gesture. |
492 bool allow_rasterize_on_demand = | 506 bool allow_rasterize_on_demand = |
493 global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; | 507 global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; |
494 | 508 |
495 // Use on-demand raster for any required-for-activation tiles that have not | 509 // Use on-demand raster for any required-for-activation tiles that have not |
496 // been been assigned memory after reaching a steady memory state. This | 510 // been been assigned memory after reaching a steady memory state. This |
(...skipping 567 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1064 if (task_it != pixel_ref_tasks.end()) | 1078 if (task_it != pixel_ref_tasks.end()) |
1065 pixel_ref_tasks.erase(task_it); | 1079 pixel_ref_tasks.erase(task_it); |
1066 } | 1080 } |
1067 | 1081 |
1068 void TileManager::OnRasterTaskCompleted( | 1082 void TileManager::OnRasterTaskCompleted( |
1069 Tile::Id tile_id, | 1083 Tile::Id tile_id, |
1070 scoped_ptr<ScopedResource> resource, | 1084 scoped_ptr<ScopedResource> resource, |
1071 RasterMode raster_mode, | 1085 RasterMode raster_mode, |
1072 const PicturePileImpl::Analysis& analysis, | 1086 const PicturePileImpl::Analysis& analysis, |
1073 bool was_canceled) { | 1087 bool was_canceled) { |
1074 TileMap::iterator it = tiles_.find(tile_id); | 1088 DCHECK(tiles_.find(tile_id) != tiles_.end()); |
1075 if (it == tiles_.end()) { | |
1076 ++update_visible_tiles_stats_.canceled_count; | |
1077 resource_pool_->ReleaseResource(resource.Pass()); | |
1078 return; | |
1079 } | |
1080 | 1089 |
1081 Tile* tile = it->second; | 1090 Tile* tile = tiles_[tile_id]; |
1082 ManagedTileState& mts = tile->managed_state(); | 1091 ManagedTileState& mts = tile->managed_state(); |
1083 ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode]; | 1092 ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode]; |
1084 DCHECK(tile_version.raster_task_); | 1093 DCHECK(tile_version.raster_task_); |
1085 orphan_raster_tasks_.push_back(tile_version.raster_task_); | 1094 orphan_raster_tasks_.push_back(tile_version.raster_task_); |
1086 tile_version.raster_task_ = NULL; | 1095 tile_version.raster_task_ = NULL; |
1087 | 1096 |
1088 if (was_canceled) { | 1097 if (was_canceled) { |
1089 ++update_visible_tiles_stats_.canceled_count; | 1098 ++update_visible_tiles_stats_.canceled_count; |
1090 resource_pool_->ReleaseResource(resource.Pass()); | 1099 resource_pool_->ReleaseResource(resource.Pass()); |
1091 return; | 1100 return; |
(...skipping 501 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1593 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); | 1602 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); |
1594 | 1603 |
1595 rasterizer_->CheckForCompletedTasks(); | 1604 rasterizer_->CheckForCompletedTasks(); |
1596 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 1605 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
1597 | 1606 |
1598 if (IsReadyToActivate()) | 1607 if (IsReadyToActivate()) |
1599 client_->NotifyReadyToActivate(); | 1608 client_->NotifyReadyToActivate(); |
1600 } | 1609 } |
1601 | 1610 |
1602 } // namespace cc | 1611 } // namespace cc |
OLD | NEW |