cc/playback/pixel_ref_map_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/playback/pixel_ref_map.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/values.h"
  10 #include "cc/playback/picture.h"
  11 #include "cc/test/fake_content_layer_client.h"
  12 #include "cc/test/skia_common.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/skia/include/core/SkGraphics.h"
  15 #include "ui/gfx/geometry/rect.h"
  16 #include "ui/gfx/skia_util.h"
  17
  18 namespace cc {
  19 namespace {
  20
  21 TEST(PixelRefMapTest, PixelRefMapIterator) {
  22   gfx::Rect layer_rect(2048, 2048);
  23
  24   gfx::Size tile_grid_size(512, 512);
  25
  26   FakeContentLayerClient content_layer_client;
  27
  28   // Discardable pixel refs are found in the following grids:
  29   // |---|---|---|---|
  30   // |   | x |   | x |
  31   // |---|---|---|---|
  32   // | x |   | x |   |
  33   // |---|---|---|---|
  34   // |   | x |   | x |
  35   // |---|---|---|---|
  36   // | x |   | x |   |
  37   // |---|---|---|---|
  38   SkBitmap discardable_bitmap[4][4];
  39   for (int y = 0; y < 4; ++y) {
  40     for (int x = 0; x < 4; ++x) {
  41       if ((x + y) & 1) {
  42         CreateDiscardableBitmap(gfx::Size(500, 500), &discardable_bitmap[y][x]);
  43         SkPaint paint;
  44         content_layer_client.add_draw_bitmap(
  45             discardable_bitmap[y][x], gfx::Point(x * 512 + 6, y * 512 + 6),
  46             paint);
  47       }
  48     }
  49   }
  50
  51   scoped_refptr<Picture> picture =
  52       Picture::Create(layer_rect, &content_layer_client, tile_grid_size, true,
  53                       RecordingSource::RECORD_NORMALLY);
  54
  55   // Default iterator does not have any pixel refs.
  56   {
  57     PixelRefMap::Iterator iterator;
  58     EXPECT_FALSE(iterator);
  59   }
  60
  61   for (int y = 0; y < 4; ++y) {
  62     for (int x = 0; x < 4; ++x) {
  63       PixelRefMap::Iterator iterator(gfx::Rect(x * 512, y * 512, 500, 500),
  64                                      picture.get());
  65       if ((x + y) & 1) {
  66         EXPECT_TRUE(iterator) << x << " " << y;
  67         EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[y][x].pixelRef())
  68             << x << " " << y;
  69         EXPECT_EQ(gfx::RectF(x * 512 + 6, y * 512 + 6, 500, 500).ToString(),
  70                   gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
  71         EXPECT_FALSE(++iterator) << x << " " << y;
  72       } else {
  73         EXPECT_FALSE(iterator) << x << " " << y;
  74       }
  75     }
  76   }
  77   // Capture 4 pixel refs.
  78   {
  79     PixelRefMap::Iterator iterator(gfx::Rect(512, 512, 2048, 2048),
  80                                    picture.get());
  81     EXPECT_TRUE(iterator);
  82     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
  83     EXPECT_EQ(gfx::RectF(2 * 512 + 6, 512 + 6, 500, 500).ToString(),
  84               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
  85     EXPECT_TRUE(++iterator);
  86     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
  87     EXPECT_EQ(gfx::RectF(512 + 6, 2 * 512 + 6, 500, 500).ToString(),
  88               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
  89     EXPECT_TRUE(++iterator);
  90     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
  91     EXPECT_EQ(gfx::RectF(3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
  92               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
  93     EXPECT_TRUE(++iterator);
  94     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
  95     EXPECT_EQ(gfx::RectF(2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
  96               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
  97     EXPECT_FALSE(++iterator);
  98   }
  99
 100   {
 101     // Copy test.
 102     PixelRefMap::Iterator iterator(gfx::Rect(512, 512, 2048, 2048),
 103                                    picture.get());
 104     EXPECT_TRUE(iterator);
 105     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
 106     EXPECT_EQ(gfx::RectF(2 * 512 + 6, 512 + 6, 500, 500).ToString(),
 107               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 108     EXPECT_TRUE(++iterator);
 109     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
 110     EXPECT_EQ(gfx::RectF(512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 111               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 112
 113     // copy now points to the same spot as iterator,
 114     // but both can be incremented independently.
 115     PixelRefMap::Iterator copy = iterator;
 116     EXPECT_TRUE(++iterator);
 117     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
 118     EXPECT_EQ(gfx::RectF(3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 119               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 120     EXPECT_TRUE(++iterator);
 121     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
 122     EXPECT_EQ(gfx::RectF(2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
 123               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 124     EXPECT_FALSE(++iterator);
 125
 126     EXPECT_TRUE(copy);
 127     EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][1].pixelRef());
 128     EXPECT_EQ(gfx::RectF(512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 129               gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
 130     EXPECT_TRUE(++copy);
 131     EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][3].pixelRef());
 132     EXPECT_EQ(gfx::RectF(3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 133               gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
 134     EXPECT_TRUE(++copy);
 135     EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[3][2].pixelRef());
 136     EXPECT_EQ(gfx::RectF(2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
 137               gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
 138     EXPECT_FALSE(++copy);
 139   }
 140 }
 141
 142 TEST(PixelRefMapTest, PixelRefMapIteratorNonZeroLayer) {
 143   gfx::Rect layer_rect(1024, 0, 2048, 2048);
 144
 145   gfx::Size tile_grid_size(512, 512);
 146
 147   FakeContentLayerClient content_layer_client;
 148
 149   // Discardable pixel refs are found in the following grids:
 150   // |---|---|---|---|
 151   // |   | x |   | x |
 152   // |---|---|---|---|
 153   // | x |   | x |   |
 154   // |---|---|---|---|
 155   // |   | x |   | x |
 156   // |---|---|---|---|
 157   // | x |   | x |   |
 158   // |---|---|---|---|
 159   SkBitmap discardable_bitmap[4][4];
 160   for (int y = 0; y < 4; ++y) {
 161     for (int x = 0; x < 4; ++x) {
 162       if ((x + y) & 1) {
 163         CreateDiscardableBitmap(gfx::Size(500, 500), &discardable_bitmap[y][x]);
 164         SkPaint paint;
 165         content_layer_client.add_draw_bitmap(
 166             discardable_bitmap[y][x],
 167             gfx::Point(1024 + x * 512 + 6, y * 512 + 6), paint);
 168       }
 169     }
 170   }
 171
 172   scoped_refptr<Picture> picture =
 173       Picture::Create(layer_rect, &content_layer_client, tile_grid_size, true,
 174                       RecordingSource::RECORD_NORMALLY);
 175
 176   // Default iterator does not have any pixel refs.
 177   {
 178     PixelRefMap::Iterator iterator;
 179     EXPECT_FALSE(iterator);
 180   }
 181
 182   for (int y = 0; y < 4; ++y) {
 183     for (int x = 0; x < 4; ++x) {
 184       PixelRefMap::Iterator iterator(
 185           gfx::Rect(1024 + x * 512, y * 512, 500, 500), picture.get());
 186       if ((x + y) & 1) {
 187         EXPECT_TRUE(iterator) << x << " " << y;
 188         EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[y][x].pixelRef());
 189         EXPECT_EQ(
 190             gfx::RectF(1024 + x * 512 + 6, y * 512 + 6, 500, 500).ToString(),
 191             gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 192         EXPECT_FALSE(++iterator) << x << " " << y;
 193       } else {
 194         EXPECT_FALSE(iterator) << x << " " << y;
 195       }
 196     }
 197   }
 198   // Capture 4 pixel refs.
 199   {
 200     PixelRefMap::Iterator iterator(gfx::Rect(1024 + 512, 512, 2048, 2048),
 201                                    picture.get());
 202     EXPECT_TRUE(iterator);
 203     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
 204     EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 512 + 6, 500, 500).ToString(),
 205               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 206     EXPECT_TRUE(++iterator);
 207     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
 208     EXPECT_EQ(gfx::RectF(1024 + 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 209               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 210     EXPECT_TRUE(++iterator);
 211     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
 212     EXPECT_EQ(gfx::RectF(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 213               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 214     EXPECT_TRUE(++iterator);
 215     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
 216     EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
 217               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 218     EXPECT_FALSE(++iterator);
 219   }
 220
 221   // Copy test.
 222   {
 223     PixelRefMap::Iterator iterator(gfx::Rect(1024 + 512, 512, 2048, 2048),
 224                                    picture.get());
 225     EXPECT_TRUE(iterator);
 226     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[1][2].pixelRef());
 227     EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 512 + 6, 500, 500).ToString(),
 228               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 229     EXPECT_TRUE(++iterator);
 230     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][1].pixelRef());
 231     EXPECT_EQ(gfx::RectF(1024 + 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 232               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 233
 234     // copy now points to the same spot as iterator,
 235     // but both can be incremented independently.
 236     PixelRefMap::Iterator copy = iterator;
 237     EXPECT_TRUE(++iterator);
 238     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[2][3].pixelRef());
 239     EXPECT_EQ(gfx::RectF(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 240               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 241     EXPECT_TRUE(++iterator);
 242     EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[3][2].pixelRef());
 243     EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
 244               gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 245     EXPECT_FALSE(++iterator);
 246
 247     EXPECT_TRUE(copy);
 248     EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][1].pixelRef());
 249     EXPECT_EQ(gfx::RectF(1024 + 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 250               gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
 251     EXPECT_TRUE(++copy);
 252     EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[2][3].pixelRef());
 253     EXPECT_EQ(gfx::RectF(1024 + 3 * 512 + 6, 2 * 512 + 6, 500, 500).ToString(),
 254               gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
 255     EXPECT_TRUE(++copy);
 256     EXPECT_TRUE(copy->pixel_ref == discardable_bitmap[3][2].pixelRef());
 257     EXPECT_EQ(gfx::RectF(1024 + 2 * 512 + 6, 3 * 512 + 6, 500, 500).ToString(),
 258               gfx::SkRectToRectF(copy->pixel_ref_rect).ToString());
 259     EXPECT_FALSE(++copy);
 260   }
 261
 262   // Non intersecting rects
 263   {
 264     PixelRefMap::Iterator iterator(gfx::Rect(0, 0, 1000, 1000), picture.get());
 265     EXPECT_FALSE(iterator);
 266   }
 267   {
 268     PixelRefMap::Iterator iterator(gfx::Rect(3500, 0, 1000, 1000),
 269                                    picture.get());
 270     EXPECT_FALSE(iterator);
 271   }
 272   {
 273     PixelRefMap::Iterator iterator(gfx::Rect(0, 1100, 1000, 1000),
 274                                    picture.get());
 275     EXPECT_FALSE(iterator);
 276   }
 277   {
 278     PixelRefMap::Iterator iterator(gfx::Rect(3500, 1100, 1000, 1000),
 279                                    picture.get());
 280     EXPECT_FALSE(iterator);
 281   }
 282 }
 283
 284 TEST(PixelRefMapTest, PixelRefMapIteratorOnePixelQuery) {
 285   gfx::Rect layer_rect(2048, 2048);
 286
 287   gfx::Size tile_grid_size(512, 512);
 288
 289   FakeContentLayerClient content_layer_client;
 290
 291   // Discardable pixel refs are found in the following grids:
 292   // |---|---|---|---|
 293   // |   | x |   | x |
 294   // |---|---|---|---|
 295   // | x |   | x |   |
 296   // |---|---|---|---|
 297   // |   | x |   | x |
 298   // |---|---|---|---|
 299   // | x |   | x |   |
 300   // |---|---|---|---|
 301   SkBitmap discardable_bitmap[4][4];
 302   for (int y = 0; y < 4; ++y) {
 303     for (int x = 0; x < 4; ++x) {
 304       if ((x + y) & 1) {
 305         CreateDiscardableBitmap(gfx::Size(500, 500), &discardable_bitmap[y][x]);
 306         SkPaint paint;
 307         content_layer_client.add_draw_bitmap(
 308             discardable_bitmap[y][x], gfx::Point(x * 512 + 6, y * 512 + 6),
 309             paint);
 310       }
 311     }
 312   }
 313
 314   scoped_refptr<Picture> picture =
 315       Picture::Create(layer_rect, &content_layer_client, tile_grid_size, true,
 316                       RecordingSource::RECORD_NORMALLY);
 317
 318   // Default iterator does not have any pixel refs.
 319   {
 320     PixelRefMap::Iterator iterator;
 321     EXPECT_FALSE(iterator);
 322   }
 323
 324   for (int y = 0; y < 4; ++y) {
 325     for (int x = 0; x < 4; ++x) {
 326       PixelRefMap::Iterator iterator(gfx::Rect(x * 512, y * 512 + 256, 1, 1),
 327                                      picture.get());
 328       if ((x + y) & 1) {
 329         EXPECT_TRUE(iterator) << x << " " << y;
 330         EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap[y][x].pixelRef());
 331         EXPECT_EQ(gfx::RectF(x * 512 + 6, y * 512 + 6, 500, 500).ToString(),
 332                   gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 333         EXPECT_FALSE(++iterator) << x << " " << y;
 334       } else {
 335         EXPECT_FALSE(iterator) << x << " " << y;
 336       }
 337     }
 338   }
 339 }
 340
 341 TEST(PixelRefMapTest, PixelRefMapIteratorMassiveImage) {
 342   gfx::Rect layer_rect(2048, 2048);
 343   gfx::Size tile_grid_size(512, 512);
 344   FakeContentLayerClient content_layer_client;
 345
 346   SkBitmap discardable_bitmap;
 347   CreateDiscardableBitmap(gfx::Size(1 << 25, 1 << 25), &discardable_bitmap);
 348   SkPaint paint;
 349   content_layer_client.add_draw_bitmap(discardable_bitmap, gfx::Point(0, 0),
 350                                        paint);
 351
 352   scoped_refptr<Picture> picture =
 353       Picture::Create(layer_rect, &content_layer_client, tile_grid_size, true,
 354                       RecordingSource::RECORD_NORMALLY);
 355
 356   PixelRefMap::Iterator iterator(gfx::Rect(0, 0, 1, 1), picture.get());
 357   EXPECT_TRUE(iterator);
 358   EXPECT_TRUE(iterator->pixel_ref == discardable_bitmap.pixelRef());
 359   EXPECT_EQ(gfx::RectF(0, 0, 1 << 25, 1 << 25).ToString(),
 360             gfx::SkRectToRectF(iterator->pixel_ref_rect).ToString());
 361   EXPECT_FALSE(++iterator);
 362 }
 363
 364 }  // namespace
 365 }  // namespace cc