cc: Update discardable image metadata generation to get PaintImages.

cc/paint/discardable_image_map_unittest.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/paint/discardable_image_map.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "cc/base/region.h"
+#include "cc/paint/clip_display_item.h"
+#include "cc/paint/discardable_image_store.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_recorder.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/skia_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 namespace {
 
 struct PositionScaleDrawImage {
   PositionScaleDrawImage(sk_sp<const SkImage> image,
                          const gfx::Rect& image_rect,
                          const SkSize& scale)
       : image(std::move(image)), image_rect(image_rect), scale(scale) {}
   sk_sp<const SkImage> image;
   gfx::Rect image_rect;
   SkSize scale;
 };
 
+sk_sp<PaintRecord> CreateRecording(
+    const sk_sp<const SkImage>& discardable_image,
+    const gfx::Rect& visible_rect) {
+  PaintRecorder recorder;
+  PaintCanvas* canvas =
+      recorder.beginRecording(visible_rect.width(), visible_rect.height());
+  canvas->drawImage(
+      PaintImage(discardable_image, PaintImage::AnimationType::STATIC,
+                 PaintImage::CompletionState::DONE),
+      0, 0, nullptr);
+  sk_sp<PaintRecord> record = recorder.finishRecordingAsPicture();
+  return record;
+}
+
 }  // namespace
 
 class DiscardableImageMapTest : public testing::Test {
  public:
   std::vector<PositionScaleDrawImage> GetDiscardableImagesInRect(
       const DiscardableImageMap& image_map,
       const gfx::Rect& rect) {
     std::vector<DrawImage> draw_images;
     // Choose a not-SRGB-and-not-invalid target color space to verify that it
     // is passed correctly to the resulting DrawImages.
@@ skipping 56 matching lines @@
         content_layer_client.add_draw_image(
             discardable_image[y][x], gfx::Point(x * 512 + 6, y * 512 + 6),
             flags);
       }
     }
   }
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(x * 512, y * 512, 500, 500));
       std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x])
             << x << " " << y;
@@ skipping 60 matching lines @@
         content_layer_client.add_draw_image(
             discardable_image[y][x],
             gfx::Point(1024 + x * 512 + 6, y * 512 + 6), flags);
       }
     }
   }
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           layer_size);
-    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(1024 + x * 512, y * 512, 500, 500));
       std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x])
             << x << " " << y;
@@ skipping 89 matching lines @@
         content_layer_client.add_draw_image(
             discardable_image[y][x], gfx::Point(x * 512 + 6, y * 512 + 6),
             flags);
       }
     }
   }
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(x * 512 + 256, y * 512 + 256, 1, 1));
       std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x])
             << x << " " << y;
@@ skipping 15 matching lines @@
 
   sk_sp<SkImage> discardable_image =
       CreateDiscardableImage(gfx::Size(1 << 25, 1 << 25));
   PaintFlags flags;
   content_layer_client.add_draw_image(discardable_image, gfx::Point(0, 0),
                                       flags);
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
   std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
   EXPECT_EQ(1u, images.size());
   EXPECT_TRUE(images[0].image == discardable_image);
   EXPECT_EQ(gfx::Rect(0, 0, 2048, 2048), inset_rects[0]);
   EXPECT_EQ(images[0].image_rect,
             image_map.GetRectForImage(images[0].image->uniqueID()));
 }
 
 TEST_F(DiscardableImageMapTest, PaintDestroyedWhileImageIsDrawn) {
   gfx::Rect visible_rect(2048, 2048);
   FakeContentLayerClient content_layer_client;
   content_layer_client.set_bounds(visible_rect.size());
 
   sk_sp<SkImage> discardable_image = CreateDiscardableImage(gfx::Size(10, 10));
+  sk_sp<PaintRecord> record = CreateRecording(discardable_image, visible_rect);
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
+    DiscardableImageStore* image_store = generator.image_store();
     {
       std::unique_ptr<SkPaint> paint(new SkPaint());
-      generator.canvas()->saveLayer(gfx::RectToSkRect(visible_rect),
-                                    paint.get());
+      image_store->GetNoDrawCanvas()->saveLayer(gfx::RectToSkRect(visible_rect),
+                                                paint.get());
     }
-    generator.canvas()->drawImage(discardable_image, 0, 0, nullptr);
-    generator.canvas()->restore();
+    image_store->GatherDiscardableImages(record.get());
+    image_store->GetNoDrawCanvas()->restore();
   }
 
   std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_TRUE(images[0].image == discardable_image);
 }
 
 TEST_F(DiscardableImageMapTest, NullPaintOnSaveLayer) {
   gfx::Rect visible_rect(2048, 2048);
   FakeContentLayerClient content_layer_client;
   content_layer_client.set_bounds(visible_rect.size());
 
   sk_sp<SkImage> discardable_image = CreateDiscardableImage(gfx::Size(10, 10));
+  sk_sp<PaintRecord> record = CreateRecording(discardable_image, visible_rect);
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
+    DiscardableImageStore* image_store = generator.image_store();
     SkPaint* null_paint = nullptr;
-    generator.canvas()->saveLayer(gfx::RectToSkRect(visible_rect), null_paint);
-    generator.canvas()->drawImage(discardable_image, 0, 0, nullptr);
-    generator.canvas()->restore();
+    image_store->GetNoDrawCanvas()->saveLayer(gfx::RectToSkRect(visible_rect),
+                                              null_paint);
+    image_store->GatherDiscardableImages(record.get());
+    image_store->GetNoDrawCanvas()->restore();
   }
 
   std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_TRUE(images[0].image == discardable_image);
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMaxImage) {
   gfx::Rect visible_rect(2048, 2048);
   FakeContentLayerClient content_layer_client;
   content_layer_client.set_bounds(visible_rect.size());
 
   int dimension = std::numeric_limits<int>::max();
   sk_sp<SkImage> discardable_image =
       CreateDiscardableImage(gfx::Size(dimension, dimension));
   PaintFlags flags;
   content_layer_client.add_draw_image(discardable_image, gfx::Point(42, 42),
                                       flags);
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
   std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(42, 42, 1, 1));
   std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
   EXPECT_EQ(1u, images.size());
   EXPECT_TRUE(images[0].image == discardable_image);
   EXPECT_EQ(gfx::Rect(42, 42, 2006, 2006), inset_rects[0]);
   EXPECT_EQ(images[0].image_rect,
             image_map.GetRectForImage(images[0].image->uniqueID()));
 }
 
@@ skipping 15 matching lines @@
   content_layer_client.add_draw_image(discardable_image, gfx::Point(0, 0),
                                       flags);
   content_layer_client.add_draw_image(discardable_image, gfx::Point(10000, 0),
                                       flags);
   content_layer_client.add_draw_image(discardable_image,
                                       gfx::Point(-10000, 500), flags);
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
   std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), inset_rects[0]);
 
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(10000, 0, 1, 1));
   inset_rects = InsetImageRects(images);
   EXPECT_EQ(2u, images.size());
   EXPECT_EQ(gfx::Rect(10000, 0, dimension - 10000, dimension), inset_rects[1]);
@@ skipping 28 matching lines @@
   content_layer_client.add_draw_image(discardable_image, gfx::Point(-10, -11),
                                       flags);
   content_layer_client.add_draw_image(discardable_image, gfx::Point(950, 951),
                                       flags);
   content_layer_client.add_draw_image(long_discardable_image,
                                       gfx::Point(-100, 500), flags);
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
   std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(0, 0, 90, 89), inset_rects[0]);
 
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(999, 999, 1, 1));
   inset_rects = InsetImageRects(images);
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(950, 951, 50, 49), inset_rects[0]);
@@ skipping 46 matching lines @@
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &scale));
         content_layer_client.add_draw_rect(
             gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500), flags);
       }
     }
   }
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+  display_list->GenerateDiscardableImagesMetadata();
 
-  DiscardableImageMap image_map;
-  {
-    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
-                                                           visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
-  }
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(x * 512, y * 512, 500, 500));
       std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x])
             << x << " " << y;
@@ skipping 15 matching lines @@
   EXPECT_TRUE(images[0].image == discardable_image[1][2]);
   EXPECT_EQ(gfx::Rect(2 * 512 + 6, 512 + 6, 500, 500), inset_rects[0]);
   EXPECT_TRUE(images[1].image == discardable_image[2][1]);
   EXPECT_EQ(gfx::Rect(512 + 6, 2 * 512 + 6, 500, 500), inset_rects[1]);
   EXPECT_TRUE(images[2].image == discardable_image[2][3]);
   EXPECT_EQ(gfx::Rect(3 * 512 + 6, 2 * 512 + 6, 500, 500), inset_rects[2]);
   EXPECT_TRUE(images[3].image == discardable_image[3][2]);
   EXPECT_EQ(gfx::Rect(2 * 512 + 6, 3 * 512 + 6, 500, 500), inset_rects[3]);
 }
 
+TEST_F(DiscardableImageMapTest, ClipsImageRects) {
+  gfx::Rect visible_rect(500, 500);
+
+  sk_sp<const SkImage> discardable_image =
+      CreateDiscardableImage(gfx::Size(500, 500));
+  sk_sp<PaintRecord> record = CreateRecording(discardable_image, visible_rect);
+
+  scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
+  display_list->CreateAndAppendPairedBeginItem<ClipDisplayItem>(
+      gfx::Rect(250, 250), std::vector<SkRRect>(), false);
+  display_list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
+      gfx::Rect(500, 500), record);
+  display_list->CreateAndAppendPairedEndItem<EndClipDisplayItem>();
+  display_list->Finalize();
+  display_list->GenerateDiscardableImagesMetadata();
+
+  const DiscardableImageMap& image_map =
+      display_list->discardable_image_map_for_testing();
+  std::vector<PositionScaleDrawImage> images =
+      GetDiscardableImagesInRect(image_map, visible_rect);
+  std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
+  EXPECT_EQ(1u, images.size());
+  EXPECT_TRUE(images[0].image == discardable_image);
+  EXPECT_EQ(gfx::Rect(250, 250), inset_rects[0]);
+}
+
+TEST_F(DiscardableImageMapTest, GathersDiscardableImagesFromNestedOps) {
+  sk_sp<PaintRecord> internal_record = sk_make_sp<PaintRecord>();
+  sk_sp<SkImage> discardable_image =
+      CreateDiscardableImage(gfx::Size(100, 100));
+  internal_record->push<DrawImageOp>(
+      PaintImage(discardable_image, PaintImage::AnimationType::STATIC,
+                 PaintImage::CompletionState::DONE),
+      0.f, 0.f, nullptr);
+
+  sk_sp<PaintRecord> list_record = sk_make_sp<PaintRecord>();
+  sk_sp<SkImage> discardable_image2 =
+      CreateDiscardableImage(gfx::Size(100, 100));
+  list_record->push<DrawImageOp>(
+      PaintImage(discardable_image2, PaintImage::AnimationType::STATIC,
+                 PaintImage::CompletionState::DONE),
+      100.f, 100.f, nullptr);
+  scoped_refptr<DisplayItemList> display_list = new DisplayItemList;
+  display_list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
+      gfx::Rect(100, 100, 100, 100), list_record);
+  display_list->Finalize();
+
+  PaintOpBuffer buffer;
+  buffer.push<DrawRecordOp>(internal_record);
+  buffer.push<DrawDisplayItemListOp>(display_list);
+  DiscardableImageMap image_map_;
+  {
+    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map_,
+                                                           gfx::Size(200, 200));
+    generator.image_store()->GatherDiscardableImages(&buffer);
+  }
+
+  gfx::ColorSpace target_color_space;
+  std::vector<DrawImage> images;
+  image_map_.GetDiscardableImagesInRect(gfx::Rect(0, 0, 5, 95), 1.f,
+                                        target_color_space, &images);
+  EXPECT_EQ(1u, images.size());
+  EXPECT_TRUE(discardable_image == images[0].image());
+
+  images.clear();
+  image_map_.GetDiscardableImagesInRect(gfx::Rect(105, 105, 5, 95), 1.f,
+                                        target_color_space, &images);
+  EXPECT_EQ(1u, images.size());
+  EXPECT_TRUE(discardable_image2 == images[0].image());
+}
+
 }  // namespace cc