Index: cc/tiles/tile_manager.cc |
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc |
index 9916918d96ce14d636b40f0b846acd4fa3b8f952..b6e9cecf260a24961b85043eb678db676c0ff0ea 100644 |
--- a/cc/tiles/tile_manager.cc |
+++ b/cc/tiles/tile_manager.cc |
@@ -681,6 +681,21 @@ TileManager::PrioritizedWorkToSchedule TileManager::AssignGpuMemoryToTiles() { |
continue; |
} |
+ // Tiles in the raster queue should either require raster or decode for |
+ // checker-images. If this tile does not need raster, process it only to |
+ // build the decode queue for checkered images. |
+ // Note that performing this check after the solif color analysis is not |
+ // necessary for correctness. |
+ if (!tile->draw_info().NeedsRaster()) { |
+ DCHECK(tile->draw_info().is_checker_imaged()); |
+ DCHECK(tile->is_image_analysis_performed()); |
+ |
+ work_to_schedule.checker_image_decode_queue.insert( |
+ work_to_schedule.checker_image_decode_queue.end(), |
+ tile->images_to_checker().begin(), tile->images_to_checker().end()); |
+ continue; |
+ } |
+ |
// We won't be able to schedule this tile, so break out early. |
if (work_to_schedule.tiles_to_raster.size() >= |
scheduled_raster_task_limit_) { |
@@ -727,6 +742,27 @@ TileManager::PrioritizedWorkToSchedule TileManager::AssignGpuMemoryToTiles() { |
} |
memory_usage += memory_required_by_tile_to_be_scheduled; |
+ |
+ // If the tile has a scheduled task that will rasterize a resource with |
+ // checker-imaged content, add those images to the decode queue. Note that |
+ // we add all images as we process the raster priority queue to ensure that |
+ // images are added to the decode queue in raster priority order. |
+ if (tile->HasRasterTask()) { |
+ DCHECK(tile->is_image_analysis_performed()); |
+ |
+ if (tile->raster_task_scheduled_with_checker_images()) { |
+ work_to_schedule.checker_image_decode_queue.insert( |
+ work_to_schedule.checker_image_decode_queue.end(), |
+ tile->images_to_checker().begin(), tile->images_to_checker().end()); |
+ } |
+ } else { |
+ // Creating the raster task here will acquire resources, but |
+ // this resource usage has already been accounted for above. |
+ tile->raster_task_ = |
+ CreateRasterTask(prioritized_tile, client_->GetRasterColorSpace(), |
+ &work_to_schedule.checker_image_decode_queue); |
+ } |
+ |
work_to_schedule.tiles_to_raster.push_back(prioritized_tile); |
} |
@@ -736,6 +772,22 @@ TileManager::PrioritizedWorkToSchedule TileManager::AssignGpuMemoryToTiles() { |
eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit( |
std::move(eviction_priority_queue), hard_memory_limit, &memory_usage); |
+ // At this point if we still have a tile that is holding onto a resource with |
+ // checker-imaged content, add it to the decode queue to ensure that the |
+ // resource is eventually invalidated. |
+ while (!raster_priority_queue->IsEmpty()) { |
+ const PrioritizedTile& prioritized_tile = raster_priority_queue->Top(); |
+ Tile* tile = prioritized_tile.tile(); |
+ if (tile->draw_info().is_checker_imaged() || |
+ tile->raster_task_scheduled_with_checker_images()) { |
Khushal
2017/03/31 04:31:01
This part still needs to be worked out.
|
+ std::vector<DrawImage> images_in_tile; |
+ prioritized_tile.raster_source()->GetDiscardableImagesInRect( |
+ tile->enclosing_layer_rect(), tile->contents_scale(), |
+ &images_in_tile); |
+ } |
+ raster_priority_queue->Pop(); |
+ } |
+ |
UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget", |
!had_enough_memory_to_schedule_tiles_needed_now); |
did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now; |
@@ -772,6 +824,29 @@ void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw( |
client_->NotifyTileStateChanged(tile); |
} |
+void TileManager::EnsureImageAnalysisPerformed( |
+ const PrioritizedTile& prioritized_tile) { |
+ Tile* tile = prioritized_tile.tile(); |
+ if (tile->is_image_analysis_performed()) |
+ return; |
+ |
+ std::vector<DrawImage> images_in_tile; |
+ prioritized_tile.raster_source()->GetDiscardableImagesInRect( |
+ tile->enclosing_layer_rect(), tile->contents_scale(), &images_in_tile); |
+ WhichTree tree = tile->tiling()->tree(); |
+ |
+ std::vector<DrawImage> images_to_decode_before_raster; |
+ std::vector<sk_sp<const SkImage>> images_to_checker; |
+ for (auto& draw_image : images_in_tile) { |
+ if (checker_image_tracker_.ShouldCheckerImage(draw_image.image(), tree)) |
+ images_to_checker.push_back(draw_image.image()); |
+ else |
+ images_to_decode_before_raster.push_back(draw_image); |
+ } |
+ tile->SetImageAnalysisResult(std::move(images_to_decode_before_raster), |
+ std::move(images_to_checker)); |
+} |
+ |
void TileManager::ScheduleTasks( |
const PrioritizedWorkToSchedule& work_to_schedule) { |
const std::vector<PrioritizedTile>& tiles_that_need_to_be_rasterized = |
@@ -821,10 +896,8 @@ void TileManager::ScheduleTasks( |
DCHECK(tile->draw_info().requires_resource()); |
DCHECK(!tile->draw_info().resource()); |
- if (!tile->raster_task_) { |
- tile->raster_task_ = |
- CreateRasterTask(prioritized_tile, raster_color_space); |
- } |
+ // Raster task for these tiles should be created in AssignGpuMemoryToTiles. |
+ DCHECK(tile->HasRasterTask()); |
TileTask* task = tile->raster_task_.get(); |
@@ -876,7 +949,6 @@ void TileManager::ScheduleTasks( |
std::vector<scoped_refptr<TileTask>> new_locked_image_tasks = |
image_controller_.SetPredecodeImages(std::move(new_locked_images), |
tracing_info); |
- |
for (auto& task : new_locked_image_tasks) { |
auto decode_it = std::find_if(graph_.nodes.begin(), graph_.nodes.end(), |
[&task](const TaskGraph::Node& node) { |
@@ -925,6 +997,12 @@ void TileManager::ScheduleTasks( |
// in |raster_queue_|. |
tile_task_manager_->ScheduleTasks(&graph_); |
+ // Schedule running of the checker-image decode queue. This replaces the |
+ // previously scheduled queue and effectively cancels image decodes from the |
+ // previous queue, if not already started. |
+ checker_image_tracker_.ScheduleImageDecodeQueue( |
+ std::move(work_to_schedule.checker_image_decode_queue)); |
+ |
did_check_for_completed_tasks_since_last_schedule_tasks_ = false; |
TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state", |
@@ -933,8 +1011,11 @@ void TileManager::ScheduleTasks( |
scoped_refptr<TileTask> TileManager::CreateRasterTask( |
const PrioritizedTile& prioritized_tile, |
- const gfx::ColorSpace& color_space) { |
+ const gfx::ColorSpace& color_space, |
+ CheckerImageTracker::ImageDecodeQueue* checker_image_decode_queue) { |
Tile* tile = prioritized_tile.tile(); |
+ TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
+ "TileManager::CreateRasterTask", "Tile", tile->id()); |
// Get the resource. |
uint64_t resource_content_id = 0; |
@@ -960,29 +1041,37 @@ scoped_refptr<TileTask> TileManager::CreateRasterTask( |
playback_settings.skip_images = |
prioritized_tile.priority().resolution == LOW_RESOLUTION; |
- // Create and queue all image decode tasks that this tile depends on. |
+ // Create and queue all image decode tasks that this tile depends on. Note |
+ // that we need to store the images for decode tasks in |
+ // |scheduled_draw_images_| since the tile might have been destroyed by the |
+ // time the raster task finishes. |
TileTask::Vector decode_tasks; |
- std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()]; |
- ImageIdFlatSet images_to_skip; |
- images.clear(); |
+ std::vector<DrawImage>& images_to_decode_for_raster = |
+ scheduled_draw_images_[tile->id()]; |
+ images_to_decode_for_raster.clear(); |
if (!playback_settings.skip_images) { |
- prioritized_tile.raster_source()->GetDiscardableImagesInRect( |
- tile->enclosing_layer_rect(), tile->contents_scale(), &images); |
- checker_image_tracker_.FilterImagesForCheckeringForTile( |
- &images, &images_to_skip, prioritized_tile.tile()->tiling()->tree()); |
+ EnsureImageAnalysisPerformed(prioritized_tile); |
+ images_to_decode_for_raster = tile->images_to_decode_before_raster(); |
+ for (const auto& image : tile->images_to_checker()) { |
+ ImageId image_id = image->uniqueID(); |
+ playback_settings.images_to_skip.insert(image_id); |
+ checker_image_decode_queue->push_back(image); |
+ } |
} |
// We can skip the image hijack canvas if we have no images, or no images to |
// skip during raster. |
playback_settings.use_image_hijack_canvas = |
- !images.empty() || !images_to_skip.empty(); |
- playback_settings.images_to_skip = std::move(images_to_skip); |
+ !images_to_decode_for_raster.empty() || |
+ !playback_settings.images_to_skip.empty(); |
+ tile->set_raster_task_scheduled_with_checker_images( |
+ !playback_settings.images_to_skip.empty()); |
// Get the tasks for the required images. |
ImageDecodeCache::TracingInfo tracing_info( |
prepare_tiles_count_, prioritized_tile.priority().priority_bin); |
- image_controller_.GetTasksForImagesAndRef(&images, &decode_tasks, |
- tracing_info); |
+ image_controller_.GetTasksForImagesAndRef(&images_to_decode_for_raster, |
+ &decode_tasks, tracing_info); |
std::unique_ptr<RasterBuffer> raster_buffer = |
raster_buffer_provider_->AcquireBufferForRaster( |
@@ -1007,10 +1096,13 @@ void TileManager::OnRasterTaskCompleted( |
auto found = tiles_.find(tile_id); |
Tile* tile = nullptr; |
+ bool raster_task_was_scheduled_with_checker_images = false; |
if (found != tiles_.end()) { |
tile = found->second; |
DCHECK(tile->raster_task_.get()); |
tile->raster_task_ = nullptr; |
+ raster_task_was_scheduled_with_checker_images = |
+ tile->set_raster_task_scheduled_with_checker_images(false); |
} |
// Unref all the images. |
@@ -1033,7 +1125,8 @@ void TileManager::OnRasterTaskCompleted( |
} |
TileDrawInfo& draw_info = tile->draw_info(); |
- draw_info.set_resource(resource); |
+ draw_info.set_resource(resource, |
+ raster_task_was_scheduled_with_checker_images); |
draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile); |
// In SMOOTHNESS_TAKES_PRIORITY mode, we wait for GPU work to complete for a |