cc: Plumb more details about pixel refs to tile manager.

cc/playback/pixel_ref_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/pixel_ref_map.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/playback/picture.h"
@@ skipping 47 matching lines @@
     PixelRefMap::Iterator iterator;
     EXPECT_FALSE(iterator);
   }
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       PixelRefMap::Iterator iterator(gfx::Rect(x * 512, y * 512, 500, 500),
                                      picture.get());
       if ((x + y) & 1) {
         EXPECT_TRUE(iterator) << x << " " << y;
-        EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef())
+        EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[y][x].pixelRef())
             << x << " " << y;
+        EXPECT_EQ(gfx::RectF(x * 512 + 6, y * 512 + 6, 500, 500).ToString(),
+                  gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
         EXPECT_FALSE(++iterator) << x << " " << y;
       } else {
         EXPECT_FALSE(iterator) << x << " " << y;
       }
     }
   }
   // Capture 4 pixel refs.
   {
     PixelRefMap::Iterator iterator(gfx::Rect(512, 512, 2048, 2048),
                                    picture.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(2 * 512 + 6, 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
+    EXPECT_EQ(gfx::RectF(512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
+    EXPECT_EQ(gfx::RectF(3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_FALSE(++iterator);
   }
 
-  // Copy test.
-  PixelRefMap::Iterator iterator(gfx::Rect(512, 512, 2048, 2048),
-                                 picture.get());
-  EXPECT_TRUE(iterator);
-  EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
-  EXPECT_TRUE(++iterator);
-  EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
+  {
+    // Copy test.
+    PixelRefMap::Iterator iterator(gfx::Rect(512, 512, 2048, 2048),
+                                   picture.get());
+    EXPECT_TRUE(iterator);
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(2 * 512 + 6, 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
+    EXPECT_TRUE(++iterator);
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
+    EXPECT_EQ(gfx::RectF(512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 
-  // copy now points to the same spot as iterator,
-  // but both can be incremented independently.
-  PixelRefMap::Iterator copy = iterator;
-  EXPECT_TRUE(++iterator);
-  EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
-  EXPECT_TRUE(++iterator);
-  EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
-  EXPECT_FALSE(++iterator);
+    // copy now points to the same spot as iterator,
+    // but both can be incremented independently.
+    PixelRefMap::Iterator copy = iterator;
+    EXPECT_TRUE(++iterator);
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
+    EXPECT_EQ(gfx::RectF(3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
+    EXPECT_TRUE(++iterator);
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
+    EXPECT_FALSE(++iterator);
 
-  EXPECT_TRUE(copy);
-  EXPECT_TRUE(*copy == discardable_bitmap[2][1].pixelRef());
-  EXPECT_TRUE(++copy);
-  EXPECT_TRUE(*copy == discardable_bitmap[2][3].pixelRef());
-  EXPECT_TRUE(++copy);
-  EXPECT_TRUE(*copy == discardable_bitmap[3][2].pixelRef());
-  EXPECT_FALSE(++copy);
+    EXPECT_TRUE(copy);
+    EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][1].pixelRef());
+    EXPECT_EQ(gfx::RectF(512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
+    EXPECT_TRUE(++copy);
+    EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][3].pixelRef());
+    EXPECT_EQ(gfx::RectF(3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
+    EXPECT_TRUE(++copy);
+    EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[3][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
+    EXPECT_FALSE(++copy);
+  }
 }
 
 TEST(PixelRefMapTest, PixelRefMapIteratorNonZeroLayer) {
   gfx::Rect layer_rect(1024, 0, 2048, 2048);
 
   gfx::Size tile_grid_size(512, 512);
 
   FakeContentLayerClient content_layer_client;
 
   // Discardable pixel refs are found in the following grids:
@@ skipping 29 matching lines @@
     PixelRefMap::Iterator iterator;
     EXPECT_FALSE(iterator);
   }
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       PixelRefMap::Iterator iterator(
           gfx::Rect(1024 + x * 512, y * 512, 500, 500), picture.get());
       if ((x + y) & 1) {
         EXPECT_TRUE(iterator) << x << " " << y;
-        EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef());
+        EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[y][x].pixelRef());
+        EXPECT_EQ(
+            gfx::RectF(1024 + x * 512 + 6, y * 512 + 6, 500, 500).ToString(),
+            gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
         EXPECT_FALSE(++iterator) << x << " " << y;
       } else {
         EXPECT_FALSE(iterator) << x << " " << y;
       }
     }
   }
   // Capture 4 pixel refs.
   {
     PixelRefMap::Iterator iterator(gfx::Rect(1024 + 512, 512, 2048, 2048),
                                    picture.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_FALSE(++iterator);
   }
 
   // Copy test.
   {
     PixelRefMap::Iterator iterator(gfx::Rect(1024 + 512, 512, 2048, 2048),
                                    picture.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 
     // copy now points to the same spot as iterator,
     // but both can be incremented independently.
     PixelRefMap::Iterator copy = iterator;
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
+    EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
     EXPECT_FALSE(++iterator);
 
     EXPECT_TRUE(copy);
-    EXPECT_TRUE(*copy == discardable_bitmap[2][1].pixelRef());
+    EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][1].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
     EXPECT_TRUE(++copy);
-    EXPECT_TRUE(*copy == discardable_bitmap[2][3].pixelRef());
+    EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][3].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
     EXPECT_TRUE(++copy);
-    EXPECT_TRUE(*copy == discardable_bitmap[3][2].pixelRef());
+    EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[3][2].pixelRef());
+    EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
+              gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
     EXPECT_FALSE(++copy);
   }
 
   // Non intersecting rects
   {
     PixelRefMap::Iterator iterator(gfx::Rect(0, 0, 1000, 1000), picture.get());
     EXPECT_FALSE(iterator);
   }
   {
     PixelRefMap::Iterator iterator(gfx::Rect(3500, 0, 1000, 1000),
@@ skipping 52 matching lines @@
     PixelRefMap::Iterator iterator;
     EXPECT_FALSE(iterator);
   }
 
   for (int y = 0; y < 4; ++y) {
     for (int x = 0; x < 4; ++x) {
       PixelRefMap::Iterator iterator(gfx::Rect(x * 512, y * 512 + 256, 1, 1),
                                      picture.get());
       if ((x + y) & 1) {
         EXPECT_TRUE(iterator) << x << " " << y;
-        EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef());
+        EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[y][x].pixelRef());
+        EXPECT_EQ(gfx::RectF(x * 512 + 6, y * 512 + 6, 500, 500).ToString(),
+                  gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
         EXPECT_FALSE(++iterator) << x << " " << y;
       } else {
         EXPECT_FALSE(iterator) << x << " " << y;
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace cc