cc/resources/picture_unittest.cc

   1 // Copyright 2013 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/resources/picture.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/values.h"
  10 #include "cc/test/fake_content_layer_client.h"
  11 #include "cc/test/skia_common.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/skia/include/core/SkCanvas.h"
  14 #include "third_party/skia/include/core/SkGraphics.h"
  15 #include "third_party/skia/include/core/SkPixelRef.h"
  16 #include "third_party/skia/include/core/SkTileGridPicture.h"
  17 #include "ui/gfx/rect.h"
  18 #include "ui/gfx/skia_util.h"
  19
  20 namespace cc {
  21 namespace {
  22
  23 TEST(PictureTest, AsBase64String) {
  24   SkGraphics::Init();
  25
  26   gfx::Rect layer_rect(100, 100);
  27
  28   SkTileGridPicture::TileGridInfo tile_grid_info;
  29   tile_grid_info.fTileInterval = SkISize::Make(100, 100);
  30   tile_grid_info.fMargin.setEmpty();
  31   tile_grid_info.fOffset.setZero();
  32
  33   FakeContentLayerClient content_layer_client;
  34
  35   scoped_ptr<base::Value> tmp;
  36
  37   SkPaint red_paint;
  38   red_paint.setColor(SkColorSetARGB(255, 255, 0, 0));
  39   SkPaint green_paint;
  40   green_paint.setColor(SkColorSetARGB(255, 0, 255, 0));
  41
  42   // Invalid picture (not a dict).
  43   tmp.reset(new base::StringValue("abc!@#$%"));
  44   scoped_refptr<Picture> invalid_picture =
  45       Picture::CreateFromValue(tmp.get());
  46   EXPECT_TRUE(!invalid_picture.get());
  47
  48   // Single full-size rect picture.
  49   content_layer_client.add_draw_rect(layer_rect, red_paint);
  50   scoped_refptr<Picture> one_rect_picture = Picture::Create(
  51       layer_rect, &content_layer_client, tile_grid_info, false, 0);
  52   scoped_ptr<base::Value> serialized_one_rect(
  53       one_rect_picture->AsValue());
  54
  55   // Reconstruct the picture.
  56   scoped_refptr<Picture> one_rect_picture_check =
  57       Picture::CreateFromValue(serialized_one_rect.get());
  58   EXPECT_TRUE(!!one_rect_picture_check.get());
  59
  60   // Check for equivalence.
  61   unsigned char one_rect_buffer[4 * 100 * 100] = {0};
  62   DrawPicture(one_rect_buffer, layer_rect, one_rect_picture);
  63   unsigned char one_rect_buffer_check[4 * 100 * 100] = {0};
  64   DrawPicture(one_rect_buffer_check, layer_rect, one_rect_picture_check);
  65
  66   EXPECT_EQ(one_rect_picture->LayerRect(),
  67             one_rect_picture_check->LayerRect());
  68   EXPECT_EQ(one_rect_picture->OpaqueRect(),
  69             one_rect_picture_check->OpaqueRect());
  70   EXPECT_TRUE(
  71       memcmp(one_rect_buffer, one_rect_buffer_check, 4 * 100 * 100) == 0);
  72
  73   // Two rect picture.
  74   content_layer_client.add_draw_rect(gfx::Rect(25, 25, 50, 50), green_paint);
  75   scoped_refptr<Picture> two_rect_picture = Picture::Create(
  76       layer_rect, &content_layer_client, tile_grid_info, false, 0);
  77
  78   scoped_ptr<base::Value> serialized_two_rect(
  79       two_rect_picture->AsValue());
  80
  81   // Reconstruct the picture.
  82   scoped_refptr<Picture> two_rect_picture_check =
  83       Picture::CreateFromValue(serialized_two_rect.get());
  84   EXPECT_TRUE(!!two_rect_picture_check.get());
  85
  86   // Check for equivalence.
  87   unsigned char two_rect_buffer[4 * 100 * 100] = {0};
  88   DrawPicture(two_rect_buffer, layer_rect, two_rect_picture);
  89   unsigned char two_rect_buffer_check[4 * 100 * 100] = {0};
  90   DrawPicture(two_rect_buffer_check, layer_rect, two_rect_picture_check);
  91
  92   EXPECT_EQ(two_rect_picture->LayerRect(),
  93             two_rect_picture_check->LayerRect());
  94   EXPECT_EQ(two_rect_picture->OpaqueRect(),
  95             two_rect_picture_check->OpaqueRect());
  96   EXPECT_TRUE(
  97       memcmp(two_rect_buffer, two_rect_buffer_check, 4 * 100 * 100) == 0);
  98 }
  99
 100 TEST(PictureTest, PixelRefIterator) {
 101   gfx::Rect layer_rect(2048, 2048);
 102
 103   SkTileGridPicture::TileGridInfo tile_grid_info;
 104   tile_grid_info.fTileInterval = SkISize::Make(512, 512);
 105   tile_grid_info.fMargin.setEmpty();
 106   tile_grid_info.fOffset.setZero();
 107
 108   FakeContentLayerClient content_layer_client;
 109
 110   // Discardable pixel refs are found in the following grids:
 111   // |---|---|---|---|
 112   // |   | x |   | x |
 113   // |---|---|---|---|
 114   // | x |   | x |   |
 115   // |---|---|---|---|
 116   // |   | x |   | x |
 117   // |---|---|---|---|
 118   // | x |   | x |   |
 119   // |---|---|---|---|
 120   SkBitmap discardable_bitmap[4][4];
 121   for (int y = 0; y < 4; ++y) {
 122     for (int x = 0; x < 4; ++x) {
 123       if ((x + y) & 1) {
 124         CreateBitmap(
 125             gfx::Size(500, 500), "discardable", &discardable_bitmap[y][x]);
 126         SkPaint paint;
 127         content_layer_client.add_draw_bitmap(
 128             discardable_bitmap[y][x],
 129             gfx::Point(x * 512 + 6, y * 512 + 6), paint);
 130       }
 131     }
 132   }
 133
 134   scoped_refptr<Picture> picture = Picture::Create(
 135       layer_rect, &content_layer_client, tile_grid_info, true, 0);
 136
 137   // Default iterator does not have any pixel refs
 138   {
 139     Picture::PixelRefIterator iterator;
 140     EXPECT_FALSE(iterator);
 141   }
 142   for (int y = 0; y < 4; ++y) {
 143     for (int x = 0; x < 4; ++x) {
 144       Picture::PixelRefIterator iterator(gfx::Rect(x * 512, y * 512, 500, 500),
 145                                          picture.get());
 146       if ((x + y) & 1) {
 147         EXPECT_TRUE(iterator) << x << " " << y;
 148         EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef()) << x <<
 149             " " << y;
 150         EXPECT_FALSE(++iterator) << x << " " << y;
 151       } else {
 152         EXPECT_FALSE(iterator) << x << " " << y;
 153       }
 154     }
 155   }
 156   // Capture 4 pixel refs.
 157   {
 158     Picture::PixelRefIterator iterator(gfx::Rect(512, 512, 2048, 2048),
 159                                        picture.get());
 160     EXPECT_TRUE(iterator);
 161     EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
 162     EXPECT_TRUE(++iterator);
 163     EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
 164     EXPECT_TRUE(++iterator);
 165     EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
 166     EXPECT_TRUE(++iterator);
 167     EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
 168     EXPECT_FALSE(++iterator);
 169   }
 170
 171   // Copy test.
 172   Picture::PixelRefIterator iterator(gfx::Rect(512, 512, 2048, 2048),
 173                                      picture.get());
 174   EXPECT_TRUE(iterator);
 175   EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
 176   EXPECT_TRUE(++iterator);
 177   EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
 178
 179   // copy now points to the same spot as iterator,
 180   // but both can be incremented independently.
 181   Picture::PixelRefIterator copy = iterator;
 182   EXPECT_TRUE(++iterator);
 183   EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
 184   EXPECT_TRUE(++iterator);
 185   EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
 186   EXPECT_FALSE(++iterator);
 187
 188   EXPECT_TRUE(copy);
 189   EXPECT_TRUE(*copy == discardable_bitmap[2][1].pixelRef());
 190   EXPECT_TRUE(++copy);
 191   EXPECT_TRUE(*copy == discardable_bitmap[2][3].pixelRef());
 192   EXPECT_TRUE(++copy);
 193   EXPECT_TRUE(*copy == discardable_bitmap[3][2].pixelRef());
 194   EXPECT_FALSE(++copy);
 195 }
 196
 197 TEST(PictureTest, PixelRefIteratorNonZeroLayer) {
 198   gfx::Rect layer_rect(1024, 0, 2048, 2048);
 199
 200   SkTileGridPicture::TileGridInfo tile_grid_info;
 201   tile_grid_info.fTileInterval = SkISize::Make(512, 512);
 202   tile_grid_info.fMargin.setEmpty();
 203   tile_grid_info.fOffset.setZero();
 204
 205   FakeContentLayerClient content_layer_client;
 206
 207   // Discardable pixel refs are found in the following grids:
 208   // |---|---|---|---|
 209   // |   | x |   | x |
 210   // |---|---|---|---|
 211   // | x |   | x |   |
 212   // |---|---|---|---|
 213   // |   | x |   | x |
 214   // |---|---|---|---|
 215   // | x |   | x |   |
 216   // |---|---|---|---|
 217   SkBitmap discardable_bitmap[4][4];
 218   for (int y = 0; y < 4; ++y) {
 219     for (int x = 0; x < 4; ++x) {
 220       if ((x + y) & 1) {
 221         CreateBitmap(
 222             gfx::Size(500, 500), "discardable", &discardable_bitmap[y][x]);
 223         SkPaint paint;
 224         content_layer_client.add_draw_bitmap(
 225             discardable_bitmap[y][x],
 226             gfx::Point(1024 + x * 512 + 6, y * 512 + 6), paint);
 227       }
 228     }
 229   }
 230
 231   scoped_refptr<Picture> picture = Picture::Create(
 232       layer_rect, &content_layer_client, tile_grid_info, true, 0);
 233
 234   // Default iterator does not have any pixel refs
 235   {
 236     Picture::PixelRefIterator iterator;
 237     EXPECT_FALSE(iterator);
 238   }
 239   for (int y = 0; y < 4; ++y) {
 240     for (int x = 0; x < 4; ++x) {
 241       Picture::PixelRefIterator iterator(
 242           gfx::Rect(1024 + x * 512, y * 512, 500, 500), picture.get());
 243       if ((x + y) & 1) {
 244         EXPECT_TRUE(iterator) << x << " " << y;
 245         EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef());
 246         EXPECT_FALSE(++iterator) << x << " " << y;
 247       } else {
 248         EXPECT_FALSE(iterator) << x << " " << y;
 249       }
 250     }
 251   }
 252   // Capture 4 pixel refs.
 253   {
 254     Picture::PixelRefIterator iterator(gfx::Rect(1024 + 512, 512, 2048, 2048),
 255                                        picture.get());
 256     EXPECT_TRUE(iterator);
 257     EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
 258     EXPECT_TRUE(++iterator);
 259     EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
 260     EXPECT_TRUE(++iterator);
 261     EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
 262     EXPECT_TRUE(++iterator);
 263     EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
 264     EXPECT_FALSE(++iterator);
 265   }
 266
 267   // Copy test.
 268   {
 269     Picture::PixelRefIterator iterator(gfx::Rect(1024 + 512, 512, 2048, 2048),
 270                                        picture.get());
 271     EXPECT_TRUE(iterator);
 272     EXPECT_TRUE(*iterator == discardable_bitmap[1][2].pixelRef());
 273     EXPECT_TRUE(++iterator);
 274     EXPECT_TRUE(*iterator == discardable_bitmap[2][1].pixelRef());
 275
 276     // copy now points to the same spot as iterator,
 277     // but both can be incremented independently.
 278     Picture::PixelRefIterator copy = iterator;
 279     EXPECT_TRUE(++iterator);
 280     EXPECT_TRUE(*iterator == discardable_bitmap[2][3].pixelRef());
 281     EXPECT_TRUE(++iterator);
 282     EXPECT_TRUE(*iterator == discardable_bitmap[3][2].pixelRef());
 283     EXPECT_FALSE(++iterator);
 284
 285     EXPECT_TRUE(copy);
 286     EXPECT_TRUE(*copy == discardable_bitmap[2][1].pixelRef());
 287     EXPECT_TRUE(++copy);
 288     EXPECT_TRUE(*copy == discardable_bitmap[2][3].pixelRef());
 289     EXPECT_TRUE(++copy);
 290     EXPECT_TRUE(*copy == discardable_bitmap[3][2].pixelRef());
 291     EXPECT_FALSE(++copy);
 292   }
 293
 294   // Non intersecting rects
 295   {
 296     Picture::PixelRefIterator iterator(gfx::Rect(0, 0, 1000, 1000),
 297                                        picture.get());
 298     EXPECT_FALSE(iterator);
 299   }
 300   {
 301     Picture::PixelRefIterator iterator(gfx::Rect(3500, 0, 1000, 1000),
 302                                        picture.get());
 303     EXPECT_FALSE(iterator);
 304   }
 305   {
 306     Picture::PixelRefIterator iterator(gfx::Rect(0, 1100, 1000, 1000),
 307                                        picture.get());
 308     EXPECT_FALSE(iterator);
 309   }
 310   {
 311     Picture::PixelRefIterator iterator(gfx::Rect(3500, 1100, 1000, 1000),
 312                                        picture.get());
 313     EXPECT_FALSE(iterator);
 314   }
 315 }
 316
 317 TEST(PictureTest, PixelRefIteratorOnePixelQuery) {
 318   gfx::Rect layer_rect(2048, 2048);
 319
 320   SkTileGridPicture::TileGridInfo tile_grid_info;
 321   tile_grid_info.fTileInterval = SkISize::Make(512, 512);
 322   tile_grid_info.fMargin.setEmpty();
 323   tile_grid_info.fOffset.setZero();
 324
 325   FakeContentLayerClient content_layer_client;
 326
 327   // Discardable pixel refs are found in the following grids:
 328   // |---|---|---|---|
 329   // |   | x |   | x |
 330   // |---|---|---|---|
 331   // | x |   | x |   |
 332   // |---|---|---|---|
 333   // |   | x |   | x |
 334   // |---|---|---|---|
 335   // | x |   | x |   |
 336   // |---|---|---|---|
 337   SkBitmap discardable_bitmap[4][4];
 338   for (int y = 0; y < 4; ++y) {
 339     for (int x = 0; x < 4; ++x) {
 340       if ((x + y) & 1) {
 341         CreateBitmap(
 342             gfx::Size(500, 500), "discardable", &discardable_bitmap[y][x]);
 343         SkPaint paint;
 344         content_layer_client.add_draw_bitmap(
 345             discardable_bitmap[y][x],
 346             gfx::Point(x * 512 + 6, y * 512 + 6), paint);
 347       }
 348     }
 349   }
 350
 351   scoped_refptr<Picture> picture = Picture::Create(
 352       layer_rect, &content_layer_client, tile_grid_info, true, 0);
 353
 354   for (int y = 0; y < 4; ++y) {
 355     for (int x = 0; x < 4; ++x) {
 356       Picture::PixelRefIterator iterator(
 357           gfx::Rect(x * 512, y * 512 + 256, 1, 1), picture.get());
 358       if ((x + y) & 1) {
 359         EXPECT_TRUE(iterator) << x << " " << y;
 360         EXPECT_TRUE(*iterator == discardable_bitmap[y][x].pixelRef());
 361         EXPECT_FALSE(++iterator) << x << " " << y;
 362       } else {
 363         EXPECT_FALSE(iterator) << x << " " << y;
 364       }
 365     }
 366   }
 367 }
 368
 369 TEST(PictureTest, CreateFromSkpValue) {
 370   SkGraphics::Init();
 371
 372   gfx::Rect layer_rect(100, 200);
 373
 374   SkTileGridPicture::TileGridInfo tile_grid_info;
 375   tile_grid_info.fTileInterval = SkISize::Make(100, 200);
 376   tile_grid_info.fMargin.setEmpty();
 377   tile_grid_info.fOffset.setZero();
 378
 379   FakeContentLayerClient content_layer_client;
 380
 381   scoped_ptr<base::Value> tmp;
 382
 383   SkPaint red_paint;
 384   red_paint.setColor(SkColorSetARGB(255, 255, 0, 0));
 385   SkPaint green_paint;
 386   green_paint.setColor(SkColorSetARGB(255, 0, 255, 0));
 387
 388   // Invalid picture (not a dict).
 389   tmp.reset(new base::StringValue("abc!@#$%"));
 390   scoped_refptr<Picture> invalid_picture =
 391       Picture::CreateFromSkpValue(tmp.get());
 392   EXPECT_TRUE(!invalid_picture.get());
 393
 394   // Single full-size rect picture.
 395   content_layer_client.add_draw_rect(layer_rect, red_paint);
 396   scoped_refptr<Picture> one_rect_picture = Picture::Create(
 397       layer_rect, &content_layer_client, tile_grid_info, false, 0);
 398   scoped_ptr<base::Value> serialized_one_rect(
 399       one_rect_picture->AsValue());
 400
 401   const base::DictionaryValue* value = NULL;
 402   EXPECT_TRUE(serialized_one_rect->GetAsDictionary(&value));
 403
 404   // Decode the picture from base64.
 405   const base::Value* skp_value;
 406   EXPECT_TRUE(value->Get("skp64", &skp_value));
 407
 408   // Reconstruct the picture.
 409   scoped_refptr<Picture> one_rect_picture_check =
 410       Picture::CreateFromSkpValue(skp_value);
 411   EXPECT_TRUE(!!one_rect_picture_check.get());
 412
 413   EXPECT_EQ(100, one_rect_picture_check->LayerRect().width());
 414   EXPECT_EQ(200, one_rect_picture_check->LayerRect().height());
 415   EXPECT_EQ(100, one_rect_picture_check->OpaqueRect().width());
 416   EXPECT_EQ(200, one_rect_picture_check->OpaqueRect().height());
 417 }
 418 }  // namespace
 419 }  // namespace cc