cc: Keep PaintImage in DrawImage.

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 833 matching lines @@
   bool was_ready_to_draw = tile->draw_info().IsReadyToDraw();
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     client_->NotifyTileStateChanged(tile);
 }
 
 void TileManager::PartitionImagesForCheckering(
     const PrioritizedTile& prioritized_tile,
     const gfx::ColorSpace& raster_color_space,
     std::vector<DrawImage>* sync_decoded_images,
-    std::vector<sk_sp<const SkImage>>* checkered_images) {
+    std::vector<PaintImage>* checkered_images) {
   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.image(), tree))
-      checkered_images->push_back(draw_image.image());
+    if (checker_image_tracker_.ShouldCheckerImage(draw_image.paint_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::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.image(), tree))
-      image_decode_queue->push_back(draw_image.image());
+    if (checker_image_tracker_.ShouldCheckerImage(draw_image.paint_image(),
+                                                  tree))
+      image_decode_queue->push_back(draw_image.paint_image());
   }
 }
 
 void TileManager::ScheduleTasks(
     const 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());
 
@@ skipping 187 matching lines @@
 
   // 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>& sync_decoded_images =
       scheduled_draw_images_[tile->id()];
   sync_decoded_images.clear();
   if (!playback_settings.skip_images) {
-    std::vector<sk_sp<const SkImage>> checkered_images;
+    std::vector<PaintImage> checkered_images;
     PartitionImagesForCheckering(prioritized_tile, color_space,
                                  &sync_decoded_images, &checkered_images);
     for (const auto& image : checkered_images) {
-      ImageId image_id = image->uniqueID();
-      playback_settings.images_to_skip.insert(image_id);
+      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);
     }
   }
 
@@ skipping 273 matching lines @@
   // Mark required tiles as OOM so that we can activate/draw without them.
   for (; !queue->IsEmpty(); queue->Pop()) {
     Tile* tile = queue->Top().tile();
     if (tile->draw_info().IsReadyToDraw())
       continue;
     tile->draw_info().set_oom();
     client_->NotifyTileStateChanged(tile);
   }
 }
 
-const ImageIdFlatSet& TileManager::TakeImagesToInvalidateOnSyncTree() {
+const PaintImageIdFlatSet& TileManager::TakeImagesToInvalidateOnSyncTree() {
   return checker_image_tracker_.TakeImagesToInvalidateOnSyncTree();
 }
 
 void TileManager::DidActivateSyncTree() {
   checker_image_tracker_.DidActivateSyncTree();
 }
 
 void TileManager::ClearCheckerImageTracking(
     bool can_clear_decode_policy_tracking) {
   checker_image_tracker_.ClearTracker(can_clear_decode_policy_tracking);
@@ skipping 245 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