cc: Optimize decode scheduling for checker-images.

cc/tiles/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 673 matching lines @@
     // 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_) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     tile->scheduled_priority_ = schedule_priority++;
 
     DCHECK(tile->draw_info().mode() == TileDrawInfo::OOM_MODE ||
-           !tile->draw_info().IsReadyToDraw());
+           !tile->draw_info().IsReadyToDraw() || tile->is_checker_imaged());
 
     // If the tile already has a raster_task, then the memory used by it is
     // already accounted for in memory_usage. Otherwise, we'll have to acquire
     // more memory to create a raster task.
     MemoryUsage memory_required_by_tile_to_be_scheduled;
     if (!tile->raster_task_.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
           tile->desired_texture_size(), DetermineResourceFormat(tile));
     }
 
@@ skipping 89 matching lines @@
   has_scheduled_tile_tasks_ = true;
 
   // Track the number of dependents for each *_done task.
   size_t required_for_activate_count = 0;
   size_t required_for_draw_count = 0;
   size_t all_count = 0;
 
   size_t priority = kTileTaskPriorityBase;
 
   graph_.Reset();
+  checker_image_tracker_.ResetImageDecodeQueue();
 
   gfx::ColorSpace target_color_space = client_->GetTileColorSpace();
 
   scoped_refptr<TileTask> required_for_activation_done_task =
       CreateTaskSetFinishedTask(
           &TileManager::DidFinishRunningTileTasksRequiredForActivation);
   scoped_refptr<TileTask> required_for_draw_done_task =
       CreateTaskSetFinishedTask(
           &TileManager::DidFinishRunningTileTasksRequiredForDraw);
   scoped_refptr<TileTask> all_done_task =
       CreateTaskSetFinishedTask(&TileManager::DidFinishRunningAllTileTasks);
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (auto& prioritized_tile : tiles_that_need_to_be_rasterized) {
     Tile* tile = prioritized_tile.tile();
 
     DCHECK(tile->draw_info().requires_resource());
-    DCHECK(!tile->draw_info().resource());
+    DCHECK(!tile->draw_info().resource() || tile->is_checker_imaged());
+
+    bool process_tile_for_checker_images_only = tile->draw_info().resource();
+    if (process_tile_for_checker_images_only) {
+      std::vector<DrawImage> images;
+      ImageIdFlatSet checkered_images;
+      prioritized_tile.raster_source()->GetDiscardableImagesInRect(
+          tile->enclosing_layer_rect(), tile->contents_scale(), &images);
+      checker_image_tracker_.FilterImagesForCheckeringForTile(

[vmpstr, 2017/03/07 19:25:08]

Yeah I think filter might be a bad name since from here it looks like you're
partitioning the images into two sets and then discarding this information. Btw,
when do we unlock these images?

[Khushal, 2017/03/13 20:35:08]

I pulled that function into the TileManager. Does filter make sense now?
And we unlock the images after the sync tree on which they were invalidated has
been activated. They could be unlocked earlier, may be after we've built the
raster tasks following the invalidation, since that should add the necessary
refs.

+          &images, &checkered_images, tile->tiling()->tree());
+      DCHECK(!checkered_images.empty())
+          << "Checker-imaged state is sticky on a Tile";
+      continue;
+    }
 
     if (!tile->raster_task_) {
       tile->raster_task_ =
           CreateRasterTask(prioritized_tile, target_color_space);
     }
 
     TileTask* task = tile->raster_task_.get();
 
     DCHECK(!task->HasCompleted());
 
@@ skipping 130 matching lines @@
   // Create and queue all image decode tasks that this tile depends on.
   TileTask::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   ImageIdFlatSet images_to_skip;
   images.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());
+    if (!images_to_skip.empty())
+      tile->set_is_checker_imaged();

[vmpstr, 2017/03/07 19:25:08]

When is this flag reset?

[Khushal, 2017/03/13 20:35:08]

Its not. If a tile is checker-imaged. It can only be replaced by another tile.
This state is never changed for a particular tile once set.

   }
 
   // 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);
 
   // Get the tasks for the required images.
   ImageDecodeCache::TracingInfo tracing_info(
@@ skipping 449 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc