cc: Build Image to Region map during image meta-data generation.

cc/playback/discardable_image_map.cc

 // Copyright 2015 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/playback/discardable_image_map.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 42 matching lines @@
 
 namespace {
 
 // We're using an NWay canvas with no added canvases, so in effect
 // non-overridden functions are no-ops.
 class DiscardableImagesMetadataCanvas : public SkNWayCanvas {
  public:
   DiscardableImagesMetadataCanvas(
       int width,
       int height,
-      std::vector<std::pair<DrawImage, gfx::Rect>>* image_set)
+      std::vector<std::pair<DrawImage, gfx::Rect>>* image_set,
+      ImageToRegionMap* image_to_region)
       : SkNWayCanvas(width, height),
         image_set_(image_set),
+        image_to_region_(image_to_region),
         canvas_bounds_(SkRect::MakeIWH(width, height)),
         canvas_size_(width, height) {}
 
  protected:
   // we need to "undo" the behavior of SkNWayCanvas, which will try to forward
   // it.
   void onDrawPicture(const SkPicture* picture,
                      const SkMatrix* matrix,
                      const SkPaint* paint) override {
     SkCanvas::onDrawPicture(picture, matrix, paint);
@@ skipping 89 matching lines @@
     if (!paint_rect.intersects(canvas_bounds_))
       return;
 
     SkFilterQuality filter_quality = kNone_SkFilterQuality;
     if (paint) {
       filter_quality = paint->getFilterQuality();
     }
 
     SkIRect src_irect;
     src_rect.roundOut(&src_irect);
+    gfx::Rect image_rect = SafeClampPaintRectToSize(paint_rect, canvas_size_);
+
+    Region& region = (*image_to_region_)[image->uniqueID()];
+    region.Union(image_rect);
+
     image_set_->push_back(std::make_pair(
         DrawImage(std::move(image), src_irect, filter_quality, matrix),
-        SafeClampPaintRectToSize(paint_rect, canvas_size_)));
+        image_rect));
   }
 
   std::vector<std::pair<DrawImage, gfx::Rect>>* image_set_;
+  ImageToRegionMap* image_to_region_;
   const SkRect canvas_bounds_;
   const gfx::Size canvas_size_;
   std::vector<SkPaint> saved_paints_;
 };
 
 }  // namespace
 
 DiscardableImageMap::DiscardableImageMap() {}
 
 DiscardableImageMap::~DiscardableImageMap() {}
 
 sk_sp<SkCanvas> DiscardableImageMap::BeginGeneratingMetadata(
     const gfx::Size& bounds) {
   DCHECK(all_images_.empty());
   return sk_make_sp<DiscardableImagesMetadataCanvas>(
-      bounds.width(), bounds.height(), &all_images_);
+      bounds.width(), bounds.height(), &all_images_, &image_to_region_);
 }
 
 void DiscardableImageMap::EndGeneratingMetadata() {
   images_rtree_.Build(all_images_,
                       [](const std::pair<DrawImage, gfx::Rect>& image) {
                         return image.second;
                       });
 }
 
 void DiscardableImageMap::GetDiscardableImagesInRect(
     const gfx::Rect& rect,
     const gfx::SizeF& raster_scales,
     std::vector<DrawImage>* images) const {
   std::vector<size_t> indices;
   images_rtree_.Search(rect, &indices);
   for (size_t index : indices)
     images->push_back(all_images_[index].first.ApplyScale(raster_scales));
 }
 
+Region DiscardableImageMap::GetRegionForImage(const SkImage* image) const {
+  const auto& it = image_to_region_.find(image->uniqueID());
+  return it == image_to_region_.end() ? Region() : it->second;
+}
+
 DiscardableImageMap::ScopedMetadataGenerator::ScopedMetadataGenerator(
     DiscardableImageMap* image_map,
     const gfx::Size& bounds)
     : image_map_(image_map),
       metadata_canvas_(image_map->BeginGeneratingMetadata(bounds)) {}
 
 DiscardableImageMap::ScopedMetadataGenerator::~ScopedMetadataGenerator() {
   image_map_->EndGeneratingMetadata();
 }
 
 }  // namespace cc