cc: Add image to rect map in DiscardableImageMap.

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 44 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,
+      std::unordered_map<ImageId, gfx::Rect>* image_id_to_rect)
       : SkNWayCanvas(width, height),
         image_set_(image_set),
+        image_id_to_rect_(image_id_to_rect),
         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 113 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_);
+
+    (*image_id_to_rect_)[image->uniqueID()].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));
   }
 
   // Currently this function only handles extracting images from SkImageShaders
   // embedded in SkPaints. Other embedded image cases, such as SkPictures,
   // are not yet handled.
   void AddPaintImage(const SkRect& rect, const SkPaint& paint) {
     SkShader* shader = paint.getShader();
     if (shader) {
       SkMatrix matrix;
       SkShader::TileMode xy[2];
       SkImage* image = shader->isAImage(&matrix, xy);
       if (image) {
         const SkMatrix& ctm = getTotalMatrix();
         matrix.postConcat(ctm);
         // TODO(ericrk): Handle cases where we only need a sub-rect from the
         // image. crbug.com/671821
         AddImage(sk_ref_sp(image), SkRect::MakeFromIRect(image->bounds()),
                  MapRect(ctm, rect), matrix, &paint);
       }
     }
   }
 
   std::vector<std::pair<DrawImage, gfx::Rect>>* image_set_;
+  std::unordered_map<ImageId, gfx::Rect>* image_id_to_rect_;
   const SkRect canvas_bounds_;
   const gfx::Size canvas_size_;
   std::vector<SkPaint> saved_paints_;
 };
 
 }  // namespace
 
 DiscardableImageMap::DiscardableImageMap() {}
 
 DiscardableImageMap::~DiscardableImageMap() {}
 
 std::unique_ptr<SkCanvas> DiscardableImageMap::BeginGeneratingMetadata(
     const gfx::Size& bounds) {
   DCHECK(all_images_.empty());
   return base::MakeUnique<DiscardableImagesMetadataCanvas>(
-      bounds.width(), bounds.height(), &all_images_);
+      bounds.width(), bounds.height(), &all_images_, &image_id_to_rect_);
 }
 
 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,
     float contents_scale,
     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(contents_scale));
 }
 
+gfx::Rect DiscardableImageMap::GetRectForImage(ImageId image_id) const {
+  const auto& it = image_id_to_rect_.find(image_id);
+  return it == image_id_to_rect_.end() ? gfx::Rect() : 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