cc: Outset image rects by 1 for the purposes of the rtree.

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>
 
@@ skipping 42 matching lines @@
           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;
   }
+
+  // Note that the image rtree outsets the images by 1, see the comment in
+  // DiscardableImagesMetadataCanvas::AddImage.
+  std::vector<gfx::Rect> InsetImageRects(
+      const std::vector<PositionScaleDrawImage>& images) {
+    std::vector<gfx::Rect> result;
+    for (auto& image : images) {
+      result.push_back(image.image_rect);
+      result.back().Inset(1, 1, 1, 1);
+    }
+    return result;
+  }
 };
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectTest) {
   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 |
@@ skipping 25 matching lines @@
   {
     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));
+      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;
         EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
-                  images[0].image_rect);
+                  inset_rects[0]);
         EXPECT_EQ(images[0].image_rect,
                   image_map.GetRectForImage(images[0].image->uniqueID()));
       } 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));
+  std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
   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(gfx::Rect(2 * 512 + 6, 512 + 6, 500, 500), inset_rects[0]);
   EXPECT_EQ(images[0].image_rect,
             image_map.GetRectForImage(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);
+  EXPECT_EQ(gfx::Rect(512 + 6, 2 * 512 + 6, 500, 500), inset_rects[1]);
   EXPECT_EQ(images[1].image_rect,
             image_map.GetRectForImage(images[1].image->uniqueID()));
 
   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_EQ(gfx::Rect(3 * 512 + 6, 2 * 512 + 6, 500, 500), inset_rects[2]);
   EXPECT_EQ(images[2].image_rect,
             image_map.GetRectForImage(images[2].image->uniqueID()));
 
   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);
+  EXPECT_EQ(gfx::Rect(2 * 512 + 6, 3 * 512 + 6, 500, 500), inset_rects[3]);
   EXPECT_EQ(images[3].image_rect,
             image_map.GetRectForImage(images[3].image->uniqueID()));
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectNonZeroLayer) {
   gfx::Rect visible_rect(1024, 0, 2048, 2048);
   // Make sure visible rect fits into the layer size.
   gfx::Size layer_size(visible_rect.right(), visible_rect.bottom());
   FakeContentLayerClient content_layer_client;
   content_layer_client.set_bounds(layer_size);
@@ skipping 29 matching lines @@
   {
     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<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;
         EXPECT_EQ(gfx::Rect(1024 + x * 512 + 6, y * 512 + 6, 500, 500),
-                  images[0].image_rect);
+                  inset_rects[0]);
         EXPECT_EQ(images[0].image_rect,
                   image_map.GetRectForImage(images[0].image->uniqueID()));
       } else {
         EXPECT_EQ(0u, images.size()) << x << " " << y;
       }
     }
   }
   // Capture 4 pixel refs.
   {
     std::vector<PositionScaleDrawImage> images = GetDiscardableImagesInRect(
         image_map, gfx::Rect(1024 + 512, 512, 2048, 2048));
+    std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
     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(gfx::Rect(1024 + 2 * 512 + 6, 512 + 6, 500, 500), inset_rects[0]);
     EXPECT_EQ(images[0].image_rect,
               image_map.GetRectForImage(images[0].image->uniqueID()));
 
     EXPECT_TRUE(images[1].image == discardable_image[2][1]);
-    EXPECT_EQ(gfx::Rect(1024 + 512 + 6, 2 * 512 + 6, 500, 500),
-              images[1].image_rect);
+    EXPECT_EQ(gfx::Rect(1024 + 512 + 6, 2 * 512 + 6, 500, 500), inset_rects[1]);
     EXPECT_EQ(images[1].image_rect,
               image_map.GetRectForImage(images[1].image->uniqueID()));
 
     EXPECT_TRUE(images[2].image == discardable_image[2][3]);
     EXPECT_EQ(gfx::Rect(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500),
-              images[2].image_rect);
+              inset_rects[2]);
     EXPECT_EQ(images[2].image_rect,
               image_map.GetRectForImage(images[2].image->uniqueID()));
 
     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);
+              inset_rects[3]);
     EXPECT_EQ(images[3].image_rect,
               image_map.GetRectForImage(images[3].image->uniqueID()));
   }
 
   // Non intersecting rects
   {
     std::vector<PositionScaleDrawImage> images =
         GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
@@ skipping 56 matching lines @@
   {
     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 + 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;
         EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
-                  images[0].image_rect);
+                  inset_rects[0]);
         EXPECT_EQ(images[0].image_rect,
                   image_map.GetRectForImage(images[0].image->uniqueID()));
       } else {
         EXPECT_EQ(0u, images.size()) << x << " " << y;
       }
     }
   }
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMassiveImage) {
@@ skipping 12 matching lines @@
           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<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), images[0].image_rect);
+  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));
@@ skipping 34 matching lines @@
           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<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), images[0].image_rect);
+  EXPECT_EQ(gfx::Rect(42, 42, 2006, 2006), inset_rects[0]);
   EXPECT_EQ(images[0].image_rect,
             image_map.GetRectForImage(images[0].image->uniqueID()));
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMaxImageMaxLayer) {
   // At large values of integer x, x != static_cast<int>(static_cast<float>(x)).
   // So, make sure the dimension can be converted back and forth for the
   // purposes of the unittest. Also, at near max int values, Skia seems to skip
   // some draw calls, so we subtract 64 since we only care about "really large"
   // values, not necessarily max int values.
@@ skipping 18 matching lines @@
           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<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), images[0].image_rect);
+  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),
-            images[1].image_rect);
-  EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), images[0].image_rect);
+  EXPECT_EQ(gfx::Rect(10000, 0, dimension - 10000, dimension), inset_rects[1]);
+  EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), inset_rects[0]);
 
   // Since we adjust negative offsets before using ToEnclosingRect, the expected
   // width will be converted to float, which means that we lose some precision.
   // The expected value is whatever the value is converted to float and then
   // back to int.
   int expected10k = static_cast<int>(static_cast<float>(dimension - 10000));
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(0, 500, 1, 1));
+  inset_rects = InsetImageRects(images);
   EXPECT_EQ(2u, images.size());
-  EXPECT_EQ(gfx::Rect(0, 500, expected10k, dimension - 500),
-            images[1].image_rect);
-  EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), images[0].image_rect);
+  EXPECT_EQ(gfx::Rect(0, 500, expected10k, dimension - 500), inset_rects[1]);
+  EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension), inset_rects[0]);
 
-  EXPECT_EQ(gfx::Rect(0, 0, dimension, dimension),
+  EXPECT_EQ(images[0].image_rect,
             image_map.GetRectForImage(discardable_image->uniqueID()));
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesRectInBounds) {
   gfx::Rect visible_rect(1000, 1000);
   FakeContentLayerClient content_layer_client;
   content_layer_client.set_bounds(visible_rect.size());
 
   sk_sp<SkImage> discardable_image =
       CreateDiscardableImage(gfx::Size(100, 100));
@@ skipping 13 matching lines @@
           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<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), images[0].image_rect);
+  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), images[0].image_rect);
+  EXPECT_EQ(gfx::Rect(950, 951, 50, 49), inset_rects[0]);
 
   images = GetDiscardableImagesInRect(image_map, gfx::Rect(0, 500, 1, 1));
+  inset_rects = InsetImageRects(images);
   EXPECT_EQ(1u, images.size());
-  EXPECT_EQ(gfx::Rect(0, 500, 1000, 100), images[0].image_rect);
+  EXPECT_EQ(gfx::Rect(0, 500, 1000, 100), inset_rects[0]);
 
   gfx::Rect discardable_image_rect;
   discardable_image_rect.Union(gfx::Rect(0, 0, 90, 89));
   discardable_image_rect.Union(gfx::Rect(950, 951, 50, 49));
+  discardable_image_rect.Inset(-1, -1, -1, -1);
   EXPECT_EQ(discardable_image_rect,
             image_map.GetRectForImage(discardable_image->uniqueID()));
 
-  EXPECT_EQ(gfx::Rect(0, 500, 1000, 100),
+  EXPECT_EQ(gfx::Rect(-1, 499, 1002, 102),
             image_map.GetRectForImage(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:
   // |---|---|---|---|
@@ skipping 34 matching lines @@
   {
     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));
+      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;
         EXPECT_EQ(gfx::Rect(x * 512 + 6, y * 512 + 6, 500, 500),
-                  images[0].image_rect);
+                  inset_rects[0]);
         EXPECT_EQ(std::max(x * 0.5f, kMinScale), images[0].scale.fWidth);
         EXPECT_EQ(std::max(y * 0.5f, kMinScale), 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));
+  std::vector<gfx::Rect> inset_rects = InsetImageRects(images);
   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(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), images[1].image_rect);
+  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),
-            images[2].image_rect);
+  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),
-            images[3].image_rect);
+  EXPECT_EQ(gfx::Rect(2 * 512 + 6, 3 * 512 + 6, 500, 500), inset_rects[3]);
 }
 
 }  // namespace cc