cc: Move pre-decodes to background worker.

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 491 matching lines @@
 
   PrioritizedWorkToSchedule prioritized_work = AssignGpuMemoryToTiles();
 
   // Inform the client that will likely require a draw if the highest priority
   // tile that will be rasterized is required for draw.
   client_->SetIsLikelyToRequireADraw(
       !prioritized_work.tiles_to_raster.empty() &&
       prioritized_work.tiles_to_raster.front().tile()->required_for_draw());
 
   // Schedule tile tasks.
-  ScheduleTasks(prioritized_work);
+  ScheduleTasks(std::move(prioritized_work));
 
   TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
                        "state", BasicStateAsValue());
   return true;
 }
 
 void TileManager::Flush() {
   TRACE_EVENT0("cc", "TileManager::Flush");
 
   if (!tile_task_manager_) {
@@ skipping 175 matching lines @@
     // 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 solid color analysis is not
     // necessary for correctness.
     if (!tile->draw_info().NeedsRaster()) {
       DCHECK(tile->draw_info().is_checker_imaged());
       DCHECK(prioritized_tile.should_decode_checkered_images_for_tile());
 
       AddCheckeredImagesToDecodeQueue(
           prioritized_tile, raster_color_space,
+          CheckerImageTracker::DecodeType::kRaster,
           &work_to_schedule.checker_image_decode_queue);
       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_) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
@@ skipping 38 matching lines @@
 
     // 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()) {
       if (tile->raster_task_scheduled_with_checker_images() &&
           prioritized_tile.should_decode_checkered_images_for_tile()) {
         AddCheckeredImagesToDecodeQueue(
             prioritized_tile, raster_color_space,
+            CheckerImageTracker::DecodeType::kRaster,
             &work_to_schedule.checker_image_decode_queue);
       }
     } 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);
     }
 
@@ skipping 22 matching lines @@
         break;
 
       if (!prioritized_tile.should_decode_checkered_images_for_tile())
         continue;
 
       Tile* tile = prioritized_tile.tile();
       if (tile->draw_info().is_checker_imaged() ||
           tile->raster_task_scheduled_with_checker_images()) {
         AddCheckeredImagesToDecodeQueue(
             prioritized_tile, raster_color_space,
+            CheckerImageTracker::DecodeType::kRaster,
             &work_to_schedule.checker_image_decode_queue);
       }
     }
   }
 
   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;
 
   memory_stats_from_last_assign_.total_budget_in_bytes =
@@ skipping 49 matching lines @@
     if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree))
       checkered_images->push_back(draw_image.paint_image());
     else
       sync_decoded_images->push_back(draw_image);
   }
 }
 
 void TileManager::AddCheckeredImagesToDecodeQueue(
     const PrioritizedTile& prioritized_tile,
     const gfx::ColorSpace& raster_color_space,
+    CheckerImageTracker::DecodeType decode_type,
     CheckerImageTracker::ImageDecodeQueue* image_decode_queue) {
   Tile* tile = prioritized_tile.tile();
   std::vector<DrawImage> images_in_tile;
   prioritized_tile.raster_source()->GetDiscardableImagesInRect(
       tile->enclosing_layer_rect(), tile->raster_transform().scale(),
       raster_color_space, &images_in_tile);
   WhichTree tree = tile->tiling()->tree();
 
   for (auto& draw_image : images_in_tile) {
-    if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree))
-      image_decode_queue->push_back(draw_image.paint_image());
+    if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree)) {
+      image_decode_queue->push_back(CheckerImageTracker::ImageDecodeRequest(
+          draw_image.paint_image(), decode_type));
+    }
   }
 }
 
-void TileManager::ScheduleTasks(
-    const PrioritizedWorkToSchedule& work_to_schedule) {
+void TileManager::ScheduleTasks(PrioritizedWorkToSchedule work_to_schedule) {
   const std::vector<PrioritizedTile>& tiles_that_need_to_be_rasterized =
       work_to_schedule.tiles_to_raster;
   TRACE_EVENT1("cc", "TileManager::ScheduleTasks", "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
   if (!has_scheduled_tile_tasks_) {
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
   }
 
+  // Ensure that we don't schedule any pre-decode work till all tile tasks have

[enne (OOO), 2017/06/08 20:08:10]

I'm mostly going to defer to vmpstr on this review, but I just had some higher
level questions:

(1) Is this the right priority for checker image decodes (i.e. last)? Sure,
visible tiles probably should have highest priority, but should we fix checker
images before we do pre-raster work of offscreen tiles?  Maybe this is correct,
but I just wanted clarification that this is intended.

(2) Similarly, checker image scheduling seems kind of bolted onto the side and
not prioritized against other work.  I suspect maybe it's not desirable to mix
tile prioritization with decode prioritization, but mixing the two systems seems
a little awkward from an outside perspective.

[Khushal, 2017/06/08 20:34:15]

This is only going to defer the decoding for pre-decode tiles. The decodes for
checkered images from any tiles that are being rasterized will still continue in
parallel with the raster work.
The fact that checker image scheduling is completely independent of work done by
the raster worker pool creates interesting scenarios on devices that have a
limited number of cores. Currently the raster worker pool first runs visible
tile tasks on the foreground workers, followed by pre-paint tiles on the
background worker, and lastly decodes for pre-decoded tiles. With
checker-imaging on the side, we could have cases where the visible tile work is
scheduled in parallel with the decode for an offscreen tile on the image worker
and it starts pre-empting the raster work. Should we try to avoid that? Listen
to when all NOW bin tiles are done before starting checkered decodes for
pre-paint tiles for instance? At the least I wanted to keep decodes for
pre-decode tiles from interrupting raster work we know is higher priority.

+  // finished.
+  checker_image_tracker_.SetCanSchedulePredecodeImages(false);
+
   // Cancel existing OnTaskSetFinished callbacks.
   task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Even when scheduling an empty set of tiles, the TTWP does some work, and
   // will always trigger a DidFinishRunningTileTasks notification. Because of
   // this we unconditionally set |has_scheduled_tile_tasks_| to true.
   has_scheduled_tile_tasks_ = true;
 
   // Track the number of dependents for each *_done task.
   size_t required_for_activate_count = 0;
@@ skipping 48 matching lines @@
         tile->required_for_draw() || tile->required_for_activation() ||
         prioritized_tile.priority().priority_bin == TilePriority::NOW;
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++,
                              use_foreground_category);
   }
 
   const std::vector<PrioritizedTile>& tiles_to_process_for_images =
       work_to_schedule.tiles_to_process_for_images;
   std::vector<DrawImage> new_locked_images;
   for (const PrioritizedTile& prioritized_tile : tiles_to_process_for_images) {
-    Tile* tile = prioritized_tile.tile();
+    std::vector<DrawImage> sync_decoded_images;
+    std::vector<PaintImage> checkered_images;
+    PartitionImagesForCheckering(prioritized_tile, raster_color_space,
+                                 &sync_decoded_images, &checkered_images);
 
-    // TODO(khushalsagar): Send these images to the ImageDecodeService, through
-    // the CheckerImageTracker as well. See crbug.com/691087.
-    std::vector<DrawImage> images;
-    prioritized_tile.raster_source()->GetDiscardableImagesInRect(
-        tile->enclosing_layer_rect(), tile->raster_transform().scale(),
-        raster_color_space, &images);
-    new_locked_images.insert(new_locked_images.end(), images.begin(),
-                             images.end());
+    // Add the sync decoded images to |new_locked_images| so they can be added
+    // to the task graph.
+    new_locked_images.insert(new_locked_images.end(),
+                             sync_decoded_images.begin(),
+                             sync_decoded_images.end());
+
+    // For checkered-images, send them to the decode service.
+    for (auto& image : checkered_images) {
+      work_to_schedule.checker_image_decode_queue.push_back(
+          CheckerImageTracker::ImageDecodeRequest(
+              std::move(image), CheckerImageTracker::DecodeType::kPreDecode));
+    }
   }
 
   // TODO(vmpstr): SOON is misleading here, but these images can come from
   // several diffent tiles. Rethink what we actually want to trace here. Note
   // that I'm using SOON, since it can't be NOW (these are prepaint).
   ImageDecodeCache::TracingInfo tracing_info(
       prepare_tiles_count_, TilePriority::SOON,
       ImageDecodeCache::TaskType::kInRaster);
   std::vector<scoped_refptr<TileTask>> new_locked_image_tasks =
       image_controller_.SetPredecodeImages(std::move(new_locked_images),
@@ skipping 105 matching lines @@
     PartitionImagesForCheckering(prioritized_tile, color_space,
                                  &sync_decoded_images, &checkered_images);
     for (const auto& image : checkered_images) {
       playback_settings.images_to_skip.insert(image.sk_image()->uniqueID());
 
       // This can be the case for tiles on the active tree that will be replaced
       // or are occluded on the pending tree. While we still need to continue
       // skipping images for these tiles, we don't need to decode them since
       // they will not be required on the next active tree.
       if (prioritized_tile.should_decode_checkered_images_for_tile())
-        checker_image_decode_queue->push_back(image);
+        checker_image_decode_queue->push_back(
+            CheckerImageTracker::ImageDecodeRequest(
+                image, CheckerImageTracker::DecodeType::kRaster));
     }
   }
 
   // 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 =
       !sync_decoded_images.empty() || !playback_settings.images_to_skip.empty();
 
   bool has_checker_images = !playback_settings.images_to_skip.empty();
   tile->set_raster_task_scheduled_with_checker_images(has_checker_images);
@@ skipping 175 matching lines @@
 
   // All tile tasks completed.
   if (signals_.all_tile_tasks_completed &&
       !signals_.did_notify_all_tile_tasks_completed) {
     signals_.all_tile_tasks_completed = false;
     if (!has_scheduled_tile_tasks_) {
       TRACE_EVENT0(
           TRACE_DISABLED_BY_DEFAULT("cc.debug"),
           "TileManager::CheckAndIssueSignals - all tile tasks completed");
       signals_.did_notify_all_tile_tasks_completed = true;
+      checker_image_tracker_.SetCanSchedulePredecodeImages(true);

[vmpstr, 2017/06/12 21:45:30]

Can you document the order of execution somewhere? Maybe on TileManager class to
explain the total order of things

[Khushal, 2017/06/14 00:29:20]

I added a comment on TileManager. Does that look sufficient?

       client_->NotifyAllTileTasksCompleted();
     }
   }
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   tile_task_manager_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   PrioritizedWorkToSchedule work_to_schedule = AssignGpuMemoryToTiles();
 
   // Inform the client that will likely require a draw if the highest priority
   // tile that will be rasterized is required for draw.
   client_->SetIsLikelyToRequireADraw(
       !work_to_schedule.tiles_to_raster.empty() &&
       work_to_schedule.tiles_to_raster.front().tile()->required_for_draw());
 
   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
   // steady memory state. Keep scheduling tasks until we reach this state.
   if (!work_to_schedule.tiles_to_raster.empty()) {
-    ScheduleTasks(work_to_schedule);
+    ScheduleTasks(std::move(work_to_schedule));
     return;
   }
 
   // If we're not in SMOOTHNESS_TAKES_PRIORITY  mode, we should unlock all
   // images since we're technically going idle here at least for this frame.
   if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY) {
     image_controller_.SetPredecodeImages(std::vector<DrawImage>(),
                                          ImageDecodeCache::TracingInfo());
     locked_image_tasks_.clear();
   }
@@ skipping 320 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