Handle simple SkImageShaders

cc/playback/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/playback/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/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 PositionDrawImage {
-  PositionDrawImage(sk_sp<const SkImage> image, const gfx::Rect& image_rect)
-      : image(std::move(image)), image_rect(image_rect) {}
+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;
 };
 
 }  // namespace
 
 class DiscardableImageMapTest : public testing::Test {
  public:
-  std::vector<PositionDrawImage> GetDiscardableImagesInRect(
+  std::vector<PositionScaleDrawImage> GetDiscardableImagesInRect(
       const DiscardableImageMap& image_map,
       const gfx::Rect& rect) {
     std::vector<DrawImage> draw_images;
     image_map.GetDiscardableImagesInRect(rect, gfx::SizeF(1.f, 1.f),
                                          &draw_images);
 
     std::vector<size_t> indices;
     image_map.images_rtree_.Search(rect, &indices);
-    std::vector<PositionDrawImage> position_draw_images;
+    std::vector<PositionScaleDrawImage> position_draw_images;
     for (size_t index : indices) {
       position_draw_images.push_back(
-          PositionDrawImage(image_map.all_images_[index].first.image(),
-                            image_map.all_images_[index].second));
+          PositionScaleDrawImage(image_map.all_images_[index].first.image(),
+                                 image_map.all_images_[index].second,
+                                 image_map.all_images_[index].first.scale()));
     }
 
     EXPECT_EQ(draw_images.size(), position_draw_images.size());
     for (size_t i = 0; i < draw_images.size(); ++i)
       EXPECT_TRUE(draw_images[i].image() == position_draw_images[i].image);
     return position_draw_images;
   }
 };
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectTest) {
@@ skipping 30 matching lines @@
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
-      std::vector<PositionDrawImage> images = GetDiscardableImagesInRect(
+      std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(x * 512, y * 512, 500, 500));
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x]) << x << " "
                                                                 << y;
         EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
                   images[0].image_rect);
         EXPECT_EQ(Region(images[0].image_rect),
                   image_map.GetRegionForImage(images[0].image->uniqueID()));
       } else {
         EXPECT_EQ(0u, images.size()) << x << " " << y;
       }
     }
   }
 
   // Capture 4 pixel refs.
-  std::vector<PositionDrawImage> images =
+  std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(512, 512, 2048, 2048));
   EXPECT_EQ(4u, images.size());
 
   EXPECT_TRUE(images[0].image == discardable_image[1][2]);
   EXPECT_EQ(gfx::Rect(2 * 512 + 6, 512 + 6, 500, 500), images[0].image_rect);
   EXPECT_EQ(Region(images[0].image_rect),
             image_map.GetRegionForImage(images[0].image->uniqueID()));
 
   EXPECT_TRUE(images[1].image == discardable_image[2][1]);
   EXPECT_EQ(gfx::Rect(512 + 6, 2 * 512 + 6, 500, 500), images[1].image_rect);
@@ skipping 49 matching lines @@
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            layer_size);
     display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
-      std::vector<PositionDrawImage> images = GetDiscardableImagesInRect(
+      std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(1024 + x * 512, y * 512, 500, 500));
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x]) << x << " "
                                                                 << y;
         EXPECT_EQ(gfx::Rect(1024 + x * 512 + 6, y * 512 + 6, 500, 500),
                   images[0].image_rect);
         EXPECT_EQ(Region(images[0].image_rect),
                   image_map.GetRegionForImage(images[0].image->uniqueID()));
       } else {
         EXPECT_EQ(0u, images.size()) << x << " " << y;
       }
     }
   }
   // Capture 4 pixel refs.
   {
-    std::vector<PositionDrawImage> images = GetDiscardableImagesInRect(
+    std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
         image_map, gfx::Rect(1024 + 512, 512, 2048, 2048));
     EXPECT_EQ(4u, images.size());
 
     EXPECT_TRUE(images[0].image == discardable_image[1][2]);
     EXPECT_EQ(gfx::Rect(1024 + 2 * 512 + 6, 512 + 6, 500, 500),
               images[0].image_rect);
     EXPECT_EQ(Region(images[0].image_rect),
               image_map.GetRegionForImage(images[0].image->uniqueID()));
 
     EXPECT_TRUE(images[1].image == discardable_image[2][1]);
@@ skipping 10 matching lines @@
 
     EXPECT_TRUE(images[3].image == discardable_image[3][2]);
     EXPECT_EQ(gfx::Rect(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500),
               images[3].image_rect);
     EXPECT_EQ(Region(images[3].image_rect),
               image_map.GetRegionForImage(images[3].image->uniqueID()));
   }
 
   // Non intersecting rects
   {
-    std::vector<PositionDrawImage> images =
+    std::vector<PositionScaleDrawImage> images =
         GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
   {
-    std::vector<PositionDrawImage> images =
+    std::vector<PositionScaleDrawImage> images =
         GetDiscardableImagesInRect(image_map, gfx::Rect(3500, 0, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
   {
-    std::vector<PositionDrawImage> images =
+    std::vector<PositionScaleDrawImage> images =
         GetDiscardableImagesInRect(image_map, gfx::Rect(0, 1100, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
   {
-    std::vector<PositionDrawImage> images = GetDiscardableImagesInRect(
+    std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
         image_map, gfx::Rect(3500, 1100, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
 
   // Image not present in the list.
   {
     sk_sp<SkImage> image = CreateDiscardableImage(gfx::Size(500, 500));
     EXPECT_EQ(Region(), image_map.GetRegionForImage(image->uniqueID()));
   }
 }
@@ skipping 32 matching lines @@
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
-      std::vector<PositionDrawImage> images = GetDiscardableImagesInRect(
+      std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
           image_map, gfx::Rect(x * 512 + 256, y * 512 + 256, 1, 1));
       if ((x + y) & 1) {
         EXPECT_EQ(1u, images.size()) << x << " " << y;
         EXPECT_TRUE(images[0].image == discardable_image[y][x]) << x << " "
                                                                 << y;
         EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
                   images[0].image_rect);
         EXPECT_EQ(Region(images[0].image_rect),
                   image_map.GetRegionForImage(images[0].image->uniqueID()));
       } else {
@@ skipping 17 matching lines @@
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
-  std::vector<PositionDrawImage> images =
+  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);
   EXPECT_EQ(gfx::Rect(0, 0, 2048, 2048), images[0].image_rect);
   EXPECT_EQ(Region(images[0].image_rect),
             image_map.GetRegionForImage(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));
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     {
       std::unique_ptr<SkPaint> paint(new SkPaint());
       generator.canvas()->saveLayer(gfx::RectToSkRect(visible_rect),
                                     paint.get());
     }
     generator.canvas()->drawImage(discardable_image, 0, 0, nullptr);
     generator.canvas()->restore();
   }
 
-  std::vector<PositionDrawImage> images =
+  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));
   SkPaint paint;
   content_layer_client.add_draw_image(discardable_image, gfx::Point(42, 42),
                                       paint);
 
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
   }
-  std::vector<PositionDrawImage> images =
+  std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(42, 42, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_TRUE(images[0].image == discardable_image);
   EXPECT_EQ(gfx::Rect(42, 42, 2006, 2006), images[0].image_rect);
   EXPECT_EQ(Region(images[0].image_rect),
             image_map.GetRegionForImage(images[0].image->uniqueID()));
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMaxImageMaxLayer) {
   // At large values of integer x, x != static_cast<int>(static_cast<float>(x)).
@@ skipping 24 matching lines @@
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
   }
 
   EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension),
             image_map.GetRegionForImage(discardable_image->uniqueID()));
 
-  std::vector<PositionDrawImage> images =
+  std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), images[0].image_rect);
 
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(10000, 0, 1, 1));
   EXPECT_EQ(2u, images.size());
   EXPECT_EQ(gfx::Rect(10000, 0, dimension - 10000, dimension),
             images[1].image_rect);
   EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), images[0].image_rect);
 
@@ skipping 30 matching lines @@
   scoped_refptr<DisplayItemList> display_list =
       content_layer_client.PaintContentsToDisplayList(
           ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
 
   DiscardableImageMap image_map;
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
     display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
   }
-  std::vector<PositionDrawImage> images =
+  std::vector<PositionScaleDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(0, 0, 90, 89), images[0].image_rect);
 
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(999, 999, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(950, 951, 50, 49), images[0].image_rect);
 
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(0, 500, 1, 1));
   EXPECT_EQ(1u, images.size());
   EXPECT_EQ(gfx::Rect(0, 500, 1000, 100), images[0].image_rect);
 
   Region discardable_image_region;
   discardable_image_region.Union(gfx::Rect(0, 0, 90, 89));
   discardable_image_region.Union(gfx::Rect(950, 951, 50, 49));
   EXPECT_EQ(discardable_image_region,
             image_map.GetRegionForImage(discardable_image->uniqueID()));
 
   EXPECT_EQ(Region(gfx::Rect(0, 500, 1000, 100)),
             image_map.GetRegionForImage(long_discardable_image->uniqueID()));
 }
 
+TEST_F(DiscardableImageMapTest, GetDiscardableImagesInShader) {
+  gfx::Rect visible_rect(2048, 2048);
+  FakeContentLayerClient content_layer_client;
+  content_layer_client.set_bounds(visible_rect.size());
+
+  // Discardable pixel refs are found in the following grids:
+  // |---|---|---|---|
+  // |   | x |   | x |
+  // |---|---|---|---|
+  // | x |   | x |   |
+  // |---|---|---|---|
+  // |   | x |   | x |
+  // |---|---|---|---|
+  // | x |   | x |   |
+  // |---|---|---|---|
+  sk_sp<SkImage> discardable_image[4][4];
+  for (int y = 0; y < 4; ++y) {
+    for (int x = 0; x < 4; ++x) {
+      if ((x + y) & 1) {
+        discardable_image[y][x] = CreateDiscardableImage(gfx::Size(500, 500));
+        SkMatrix scale = SkMatrix::MakeScale(x * 0.5f, y * 0.5f);
+        SkPaint paint;
+        paint.setShader(discardable_image[y][x]->makeShader(
+            SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &scale));
+        content_layer_client.add_draw_rect(
+            gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500), paint);
+      }
+    }
+  }
+
+  scoped_refptr<DisplayItemList> display_list =
+      content_layer_client.PaintContentsToDisplayList(
+          ContentLayerClient::PAINTING_BEHAVIOR_NORMAL);
+
+  DiscardableImageMap image_map;
+  {
+    DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
+                                                           visible_rect.size());
+    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
+  }
+
+  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));
+      if ((x + y) & 1) {
+        EXPECT_EQ(1u, images.size()) << x << " " << y;
+        EXPECT_TRUE(images[0].image == discardable_image[y][x]) << x << " "
+                                                                << y;
+        EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
+                  images[0].image_rect);
+        EXPECT_EQ(x * 0.5f, images[0].scale.fWidth);
+        EXPECT_EQ(y * 0.5f, images[0].scale.fHeight);
+      } else {
+        EXPECT_EQ(0u, images.size()) << x << " " << y;
+      }
+    }
+  }
+
+  // Capture 4 pixel refs.
+  std::vector<PositionScaleDrawImage> images =
+      GetDiscardableImagesInRect(image_map, gfx::Rect(512, 512, 2048, 2048));
+  EXPECT_EQ(4u, images.size());
+  EXPECT_TRUE(images[0].image == discardable_image[1][2]);
+  EXPECT_EQ(gfx::Rect(2 * 512 + 6, 512 + 6, 500, 500), images[0].image_rect);
+  EXPECT_TRUE(images[1].image == discardable_image[2][1]);
+  EXPECT_EQ(gfx::Rect(512 + 6, 2 * 512 + 6, 500, 500), images[1].image_rect);
+  EXPECT_TRUE(images[2].image == discardable_image[2][3]);
+  EXPECT_EQ(gfx::Rect(3 * 512 + 6, 2 * 512 + 6, 500, 500),
+            images[2].image_rect);
+  EXPECT_TRUE(images[3].image == discardable_image[3][2]);
+  EXPECT_EQ(gfx::Rect(2 * 512 + 6, 3 * 512 + 6, 500, 500),
+            images[3].image_rect);
+}
+
 }  // namespace cc