cc: Add image to rect map in DiscardableImageMap.

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 93 matching lines @@
   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(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));
   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(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(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(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(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);
 
   // Discardable pixel refs are found in the following grids:
@@ skipping 33 matching lines @@
   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));
       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(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));
     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(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(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);
+    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);
+    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());
   }
   {
     std::vector<PositionScaleDrawImage> images =
         GetDiscardableImagesInRect(image_map, gfx::Rect(3500, 0, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
   {
     std::vector<PositionScaleDrawImage> images =
         GetDiscardableImagesInRect(image_map, gfx::Rect(0, 1100, 1000, 1000));
     EXPECT_EQ(0u, images.size());
   }
   {
     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(gfx::Rect(), image_map.GetRectForImage(image->uniqueID()));
+  }
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectOnePixelQuery) {
   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 31 matching lines @@
   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));
       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(images[0].image_rect,
+                  image_map.GetRectForImage(images[0].image->uniqueID()));
       } else {
         EXPECT_EQ(0u, images.size()) << x << " " << y;
       }
     }
   }
 }
 
 TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMassiveImage) {
   gfx::Rect visible_rect(2048, 2048);
   FakeContentLayerClient content_layer_client;
@@ skipping 13 matching lines @@
   {
     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));
   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(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));
 
   DiscardableImageMap image_map;
@@ skipping 35 matching lines @@
   {
     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));
   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(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.
   int dimension = static_cast<int>(
       static_cast<float>(std::numeric_limits<int>::max() - 64));
@@ skipping 35 matching lines @@
   // 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));
   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, 0, dimension, dimension),
+            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));
   sk_sp<SkImage> long_discardable_image =
@@ skipping 22 matching lines @@
   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);
+
+  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));
+  EXPECT_EQ(discardable_image_rect,
+            image_map.GetRectForImage(discardable_image->uniqueID()));
+
+  EXPECT_EQ(gfx::Rect(0, 500, 1000, 100),
+            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:
   // |---|---|---|---|
   // |   | x |   | x |
@@ skipping 58 matching lines @@
   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