skia/ext/pixel_ref_utils_unittest.cc

   1 // Copyright 2014 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 "base/compiler_specific.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "cc/test/geometry_test_utils.h"
   8 #include "skia/ext/pixel_ref_utils.h"
   9 #include "skia/ext/refptr.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "third_party/skia/include/core/SkBitmap.h"
  12 #include "third_party/skia/include/core/SkCanvas.h"
  13 #include "third_party/skia/include/core/SkPictureRecorder.h"
  14 #include "third_party/skia/include/core/SkPixelRef.h"
  15 #include "third_party/skia/include/core/SkPoint.h"
  16 #include "third_party/skia/include/core/SkShader.h"
  17 #include "third_party/skia/src/core/SkOrderedReadBuffer.h"
  18 #include "ui/gfx/rect.h"
  19 #include "ui/gfx/skia_util.h"
  20
  21 namespace skia {
  22
  23 namespace {
  24
  25 void CreateBitmap(gfx::Size size, const char* uri, SkBitmap* bitmap);
  26
  27 class TestDiscardableShader : public SkShader {
  28  public:
  29   TestDiscardableShader() {
  30     CreateBitmap(gfx::Size(50, 50), "discardable", &bitmap_);
  31   }
  32
  33   TestDiscardableShader(SkReadBuffer& buffer) {
  34     CreateBitmap(gfx::Size(50, 50), "discardable", &bitmap_);
  35   }
  36
  37   SkShader::BitmapType asABitmap(SkBitmap* bitmap,
  38                                  SkMatrix* matrix,
  39                                  TileMode xy[2]) const override {
  40     if (bitmap)
  41       *bitmap = bitmap_;
  42     return SkShader::kDefault_BitmapType;
  43   }
  44
  45   // not indended to return an actual context. Just need to supply this.
  46   size_t contextSize() const override { return sizeof(SkShader::Context); }
  47
  48   void flatten(SkWriteBuffer&) const override {}
  49
  50   SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(TestDiscardableShader);
  51
  52  private:
  53   SkBitmap bitmap_;
  54 };
  55
  56 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
  57 SkFlattenable* TestDiscardableShader::CreateProc(SkReadBuffer&) {
  58   return new TestDiscardableShader;
  59 }
  60 #endif
  61
  62 void CreateBitmap(gfx::Size size, const char* uri, SkBitmap* bitmap) {
  63   bitmap->allocN32Pixels(size.width(), size.height());
  64   bitmap->pixelRef()->setImmutable();
  65   bitmap->pixelRef()->setURI(uri);
  66 }
  67
  68 SkCanvas* StartRecording(SkPictureRecorder* recorder, gfx::Rect layer_rect) {
  69   SkCanvas* canvas =
  70       recorder->beginRecording(layer_rect.width(), layer_rect.height());
  71
  72   canvas->save();
  73   canvas->translate(-layer_rect.x(), -layer_rect.y());
  74   canvas->clipRect(SkRect::MakeXYWH(
  75       layer_rect.x(), layer_rect.y(), layer_rect.width(), layer_rect.height()));
  76
  77   return canvas;
  78 }
  79
  80 SkPicture* StopRecording(SkPictureRecorder* recorder, SkCanvas* canvas) {
  81   canvas->restore();
  82   return recorder->endRecording();
  83 }
  84
  85 }  // namespace
  86
  87 TEST(PixelRefUtilsTest, DrawPaint) {
  88   gfx::Rect layer_rect(0, 0, 256, 256);
  89
  90   SkPictureRecorder recorder;
  91   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
  92
  93   TestDiscardableShader first_shader;
  94   SkPaint first_paint;
  95   first_paint.setShader(&first_shader);
  96
  97   TestDiscardableShader second_shader;
  98   SkPaint second_paint;
  99   second_paint.setShader(&second_shader);
 100
 101   TestDiscardableShader third_shader;
 102   SkPaint third_paint;
 103   third_paint.setShader(&third_shader);
 104
 105   canvas->drawPaint(first_paint);
 106   canvas->clipRect(SkRect::MakeXYWH(34, 45, 56, 67));
 107   canvas->drawPaint(second_paint);
 108   // Total clip is now (34, 45, 56, 55)
 109   canvas->clipRect(SkRect::MakeWH(100, 100));
 110   canvas->drawPaint(third_paint);
 111
 112   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 113
 114   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 115   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 116
 117   EXPECT_EQ(3u, pixel_refs.size());
 118   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 256, 256),
 119                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 120   EXPECT_FLOAT_RECT_EQ(gfx::RectF(34, 45, 56, 67),
 121                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 122   EXPECT_FLOAT_RECT_EQ(gfx::RectF(34, 45, 56, 55),
 123                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 124 }
 125
 126 TEST(PixelRefUtilsTest, DrawPoints) {
 127   gfx::Rect layer_rect(0, 0, 256, 256);
 128
 129   SkPictureRecorder recorder;
 130   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 131
 132   TestDiscardableShader first_shader;
 133   SkPaint first_paint;
 134   first_paint.setShader(&first_shader);
 135
 136   TestDiscardableShader second_shader;
 137   SkPaint second_paint;
 138   second_paint.setShader(&second_shader);
 139
 140   TestDiscardableShader third_shader;
 141   SkPaint third_paint;
 142   third_paint.setShader(&third_shader);
 143
 144   SkPoint points[3];
 145   points[0].set(10, 10);
 146   points[1].set(100, 20);
 147   points[2].set(50, 100);
 148   // (10, 10, 90, 90).
 149   canvas->drawPoints(SkCanvas::kPolygon_PointMode, 3, points, first_paint);
 150
 151   canvas->save();
 152
 153   canvas->clipRect(SkRect::MakeWH(50, 50));
 154   // (10, 10, 40, 40).
 155   canvas->drawPoints(SkCanvas::kPolygon_PointMode, 3, points, second_paint);
 156
 157   canvas->restore();
 158
 159   points[0].set(50, 55);
 160   points[1].set(50, 55);
 161   points[2].set(200, 200);
 162   // (50, 55, 150, 145).
 163   canvas->drawPoints(SkCanvas::kPolygon_PointMode, 3, points, third_paint);
 164
 165   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 166
 167   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 168   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 169
 170   EXPECT_EQ(3u, pixel_refs.size());
 171   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 10, 90, 90),
 172                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 173   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 10, 40, 40),
 174                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 175   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 55, 150, 145),
 176                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 177 }
 178
 179 TEST(PixelRefUtilsTest, DrawRect) {
 180   gfx::Rect layer_rect(0, 0, 256, 256);
 181
 182   SkPictureRecorder recorder;
 183   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 184
 185   TestDiscardableShader first_shader;
 186   SkPaint first_paint;
 187   first_paint.setShader(&first_shader);
 188
 189   TestDiscardableShader second_shader;
 190   SkPaint second_paint;
 191   second_paint.setShader(&second_shader);
 192
 193   TestDiscardableShader third_shader;
 194   SkPaint third_paint;
 195   third_paint.setShader(&third_shader);
 196
 197   // (10, 20, 30, 40).
 198   canvas->drawRect(SkRect::MakeXYWH(10, 20, 30, 40), first_paint);
 199
 200   canvas->save();
 201
 202   canvas->translate(5, 17);
 203   // (5, 50, 25, 35)
 204   canvas->drawRect(SkRect::MakeXYWH(0, 33, 25, 35), second_paint);
 205
 206   canvas->restore();
 207
 208   canvas->clipRect(SkRect::MakeXYWH(50, 50, 50, 50));
 209   canvas->translate(20, 20);
 210   // (50, 50, 50, 50)
 211   canvas->drawRect(SkRect::MakeXYWH(0, 0, 100, 100), third_paint);
 212
 213   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 214
 215   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 216   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 217
 218   EXPECT_EQ(3u, pixel_refs.size());
 219   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 20, 30, 40),
 220                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 221   EXPECT_FLOAT_RECT_EQ(gfx::RectF(5, 50, 25, 35),
 222                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 223   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 50, 50, 50),
 224                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 225 }
 226
 227 TEST(PixelRefUtilsTest, DrawRRect) {
 228   gfx::Rect layer_rect(0, 0, 256, 256);
 229
 230   SkPictureRecorder recorder;
 231   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 232
 233   TestDiscardableShader first_shader;
 234   SkPaint first_paint;
 235   first_paint.setShader(&first_shader);
 236
 237   TestDiscardableShader second_shader;
 238   SkPaint second_paint;
 239   second_paint.setShader(&second_shader);
 240
 241   TestDiscardableShader third_shader;
 242   SkPaint third_paint;
 243   third_paint.setShader(&third_shader);
 244
 245   SkRRect rrect;
 246   rrect.setRect(SkRect::MakeXYWH(10, 20, 30, 40));
 247
 248   // (10, 20, 30, 40).
 249   canvas->drawRRect(rrect, first_paint);
 250
 251   canvas->save();
 252
 253   canvas->translate(5, 17);
 254   rrect.setRect(SkRect::MakeXYWH(0, 33, 25, 35));
 255   // (5, 50, 25, 35)
 256   canvas->drawRRect(rrect, second_paint);
 257
 258   canvas->restore();
 259
 260   canvas->clipRect(SkRect::MakeXYWH(50, 50, 50, 50));
 261   canvas->translate(20, 20);
 262   rrect.setRect(SkRect::MakeXYWH(0, 0, 100, 100));
 263   // (50, 50, 50, 50)
 264   canvas->drawRRect(rrect, third_paint);
 265
 266   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 267
 268   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 269   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 270
 271   EXPECT_EQ(3u, pixel_refs.size());
 272   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 20, 30, 40),
 273                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 274   EXPECT_FLOAT_RECT_EQ(gfx::RectF(5, 50, 25, 35),
 275                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 276   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 50, 50, 50),
 277                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 278 }
 279
 280 TEST(PixelRefUtilsTest, DrawOval) {
 281   gfx::Rect layer_rect(0, 0, 256, 256);
 282
 283   SkPictureRecorder recorder;
 284   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 285
 286   TestDiscardableShader first_shader;
 287   SkPaint first_paint;
 288   first_paint.setShader(&first_shader);
 289
 290   TestDiscardableShader second_shader;
 291   SkPaint second_paint;
 292   second_paint.setShader(&second_shader);
 293
 294   TestDiscardableShader third_shader;
 295   SkPaint third_paint;
 296   third_paint.setShader(&third_shader);
 297
 298   canvas->save();
 299
 300   canvas->scale(2, 0.5);
 301   // (20, 10, 60, 20).
 302   canvas->drawOval(SkRect::MakeXYWH(10, 20, 30, 40), first_paint);
 303
 304   canvas->restore();
 305   canvas->save();
 306
 307   canvas->translate(1, 2);
 308   // (1, 35, 25, 35)
 309   canvas->drawRect(SkRect::MakeXYWH(0, 33, 25, 35), second_paint);
 310
 311   canvas->restore();
 312
 313   canvas->clipRect(SkRect::MakeXYWH(50, 50, 50, 50));
 314   canvas->translate(20, 20);
 315   // (50, 50, 50, 50)
 316   canvas->drawRect(SkRect::MakeXYWH(0, 0, 100, 100), third_paint);
 317
 318   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 319
 320   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 321   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 322
 323   EXPECT_EQ(3u, pixel_refs.size());
 324   EXPECT_FLOAT_RECT_EQ(gfx::RectF(20, 10, 60, 20),
 325                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 326   EXPECT_FLOAT_RECT_EQ(gfx::RectF(1, 35, 25, 35),
 327                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 328   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 50, 50, 50),
 329                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 330 }
 331
 332 TEST(PixelRefUtilsTest, DrawPath) {
 333   gfx::Rect layer_rect(0, 0, 256, 256);
 334
 335   SkPictureRecorder recorder;
 336   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 337
 338   TestDiscardableShader first_shader;
 339   SkPaint first_paint;
 340   first_paint.setShader(&first_shader);
 341
 342   TestDiscardableShader second_shader;
 343   SkPaint second_paint;
 344   second_paint.setShader(&second_shader);
 345
 346   SkPath path;
 347   path.moveTo(12, 13);
 348   path.lineTo(50, 50);
 349   path.lineTo(22, 101);
 350
 351   // (12, 13, 38, 88).
 352   canvas->drawPath(path, first_paint);
 353
 354   canvas->save();
 355   canvas->clipRect(SkRect::MakeWH(50, 50));
 356
 357   // (12, 13, 38, 37).
 358   canvas->drawPath(path, second_paint);
 359
 360   canvas->restore();
 361
 362   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 363
 364   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 365   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 366
 367   EXPECT_EQ(2u, pixel_refs.size());
 368   EXPECT_FLOAT_RECT_EQ(gfx::RectF(12, 13, 38, 88),
 369                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 370   EXPECT_FLOAT_RECT_EQ(gfx::RectF(12, 13, 38, 37),
 371                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 372 }
 373
 374 TEST(PixelRefUtilsTest, DrawBitmap) {
 375   gfx::Rect layer_rect(0, 0, 256, 256);
 376
 377   SkPictureRecorder recorder;
 378   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 379
 380   SkBitmap first;
 381   CreateBitmap(gfx::Size(50, 50), "discardable", &first);
 382   SkBitmap second;
 383   CreateBitmap(gfx::Size(50, 50), "discardable", &second);
 384   SkBitmap third;
 385   CreateBitmap(gfx::Size(50, 50), "discardable", &third);
 386   SkBitmap fourth;
 387   CreateBitmap(gfx::Size(50, 1), "discardable", &fourth);
 388   SkBitmap fifth;
 389   CreateBitmap(gfx::Size(10, 10), "discardable", &fifth);
 390
 391   canvas->save();
 392
 393   // At (0, 0).
 394   canvas->drawBitmap(first, 0, 0);
 395   canvas->translate(25, 0);
 396   // At (25, 0).
 397   canvas->drawBitmap(second, 0, 0);
 398   canvas->translate(0, 50);
 399   // At (50, 50).
 400   canvas->drawBitmap(third, 25, 0);
 401
 402   canvas->restore();
 403   canvas->save();
 404
 405   canvas->translate(1, 0);
 406   canvas->rotate(90);
 407   // At (1, 0), rotated 90 degrees
 408   canvas->drawBitmap(fourth, 0, 0);
 409
 410   canvas->restore();
 411
 412   canvas->scale(5, 6);
 413   // At (0, 0), scaled by 5 and 6
 414   canvas->drawBitmap(fifth, 0, 0);
 415
 416   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 417
 418   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 419   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 420
 421   EXPECT_EQ(5u, pixel_refs.size());
 422   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 50),
 423                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 424   EXPECT_FLOAT_RECT_EQ(gfx::RectF(25, 0, 50, 50),
 425                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 426   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 50, 50, 50),
 427                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 428   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 1, 50),
 429                        gfx::SkRectToRectF(pixel_refs[3].pixel_ref_rect));
 430   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 60),
 431                        gfx::SkRectToRectF(pixel_refs[4].pixel_ref_rect));
 432
 433 }
 434
 435 TEST(PixelRefUtilsTest, DrawBitmapRect) {
 436   gfx::Rect layer_rect(0, 0, 256, 256);
 437
 438   SkPictureRecorder recorder;
 439   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 440
 441   SkBitmap first;
 442   CreateBitmap(gfx::Size(50, 50), "discardable", &first);
 443   SkBitmap second;
 444   CreateBitmap(gfx::Size(50, 50), "discardable", &second);
 445   SkBitmap third;
 446   CreateBitmap(gfx::Size(50, 50), "discardable", &third);
 447
 448   TestDiscardableShader first_shader;
 449   SkPaint first_paint;
 450   first_paint.setShader(&first_shader);
 451
 452   SkPaint non_discardable_paint;
 453
 454   canvas->save();
 455
 456   // (0, 0, 100, 100).
 457   canvas->drawBitmapRect(
 458       first, SkRect::MakeWH(100, 100), &non_discardable_paint);
 459   canvas->translate(25, 0);
 460   // (75, 50, 10, 10).
 461   canvas->drawBitmapRect(
 462       second, SkRect::MakeXYWH(50, 50, 10, 10), &non_discardable_paint);
 463   canvas->translate(5, 50);
 464   // (0, 30, 100, 100). One from bitmap, one from paint.
 465   canvas->drawBitmapRect(
 466       third, SkRect::MakeXYWH(-30, -20, 100, 100), &first_paint);
 467
 468   canvas->restore();
 469
 470   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 471
 472   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 473   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 474
 475   EXPECT_EQ(4u, pixel_refs.size());
 476   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100),
 477                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 478   EXPECT_FLOAT_RECT_EQ(gfx::RectF(75, 50, 10, 10),
 479                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 480   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 30, 100, 100),
 481                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 482   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 30, 100, 100),
 483                        gfx::SkRectToRectF(pixel_refs[3].pixel_ref_rect));
 484 }
 485
 486 TEST(PixelRefUtilsTest, DrawSprite) {
 487   gfx::Rect layer_rect(0, 0, 256, 256);
 488
 489   SkPictureRecorder recorder;
 490   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 491
 492   SkBitmap first;
 493   CreateBitmap(gfx::Size(50, 50), "discardable", &first);
 494   SkBitmap second;
 495   CreateBitmap(gfx::Size(50, 50), "discardable", &second);
 496   SkBitmap third;
 497   CreateBitmap(gfx::Size(50, 50), "discardable", &third);
 498   SkBitmap fourth;
 499   CreateBitmap(gfx::Size(50, 50), "discardable", &fourth);
 500   SkBitmap fifth;
 501   CreateBitmap(gfx::Size(50, 50), "discardable", &fifth);
 502
 503   canvas->save();
 504
 505   // Sprites aren't affected by the current matrix.
 506
 507   // (0, 0, 50, 50).
 508   canvas->drawSprite(first, 0, 0);
 509   canvas->translate(25, 0);
 510   // (10, 0, 50, 50).
 511   canvas->drawSprite(second, 10, 0);
 512   canvas->translate(0, 50);
 513   // (25, 0, 50, 50).
 514   canvas->drawSprite(third, 25, 0);
 515
 516   canvas->restore();
 517   canvas->save();
 518
 519   canvas->rotate(90);
 520   // (0, 0, 50, 50).
 521   canvas->drawSprite(fourth, 0, 0);
 522
 523   canvas->restore();
 524
 525   TestDiscardableShader first_shader;
 526   SkPaint first_paint;
 527   first_paint.setShader(&first_shader);
 528
 529   canvas->scale(5, 6);
 530   // (100, 100, 50, 50).
 531   canvas->drawSprite(fifth, 100, 100, &first_paint);
 532
 533   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 534
 535   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 536   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 537
 538   EXPECT_EQ(6u, pixel_refs.size());
 539   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 50),
 540                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 541   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 0, 50, 50),
 542                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 543   EXPECT_FLOAT_RECT_EQ(gfx::RectF(25, 0, 50, 50),
 544                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 545   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 50),
 546                        gfx::SkRectToRectF(pixel_refs[3].pixel_ref_rect));
 547   EXPECT_FLOAT_RECT_EQ(gfx::RectF(100, 100, 50, 50),
 548                        gfx::SkRectToRectF(pixel_refs[4].pixel_ref_rect));
 549   EXPECT_FLOAT_RECT_EQ(gfx::RectF(100, 100, 50, 50),
 550                        gfx::SkRectToRectF(pixel_refs[5].pixel_ref_rect));
 551 }
 552
 553 TEST(PixelRefUtilsTest, DrawText) {
 554   gfx::Rect layer_rect(0, 0, 256, 256);
 555
 556   SkPictureRecorder recorder;
 557   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 558
 559   TestDiscardableShader first_shader;
 560   SkPaint first_paint;
 561   first_paint.setShader(&first_shader);
 562
 563   SkPoint points[4];
 564   points[0].set(10, 50);
 565   points[1].set(20, 50);
 566   points[2].set(30, 50);
 567   points[3].set(40, 50);
 568
 569   SkPath path;
 570   path.moveTo(10, 50);
 571   path.lineTo(20, 50);
 572   path.lineTo(30, 50);
 573   path.lineTo(40, 50);
 574   path.lineTo(50, 50);
 575
 576   canvas->drawText("text", 4, 50, 50, first_paint);
 577   canvas->drawPosText("text", 4, points, first_paint);
 578   canvas->drawTextOnPath("text", 4, path, NULL, first_paint);
 579
 580   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 581
 582   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 583   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 584
 585   EXPECT_EQ(3u, pixel_refs.size());
 586 }
 587
 588 TEST(PixelRefUtilsTest, DrawVertices) {
 589   gfx::Rect layer_rect(0, 0, 256, 256);
 590
 591   SkPictureRecorder recorder;
 592   SkCanvas* canvas = StartRecording(&recorder, layer_rect);
 593
 594   TestDiscardableShader first_shader;
 595   SkPaint first_paint;
 596   first_paint.setShader(&first_shader);
 597
 598   TestDiscardableShader second_shader;
 599   SkPaint second_paint;
 600   second_paint.setShader(&second_shader);
 601
 602   TestDiscardableShader third_shader;
 603   SkPaint third_paint;
 604   third_paint.setShader(&third_shader);
 605
 606   SkPoint points[3];
 607   SkColor colors[3];
 608   uint16_t indecies[3] = {0, 1, 2};
 609   points[0].set(10, 10);
 610   points[1].set(100, 20);
 611   points[2].set(50, 100);
 612   // (10, 10, 90, 90).
 613   canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
 614                        3,
 615                        points,
 616                        points,
 617                        colors,
 618                        NULL,
 619                        indecies,
 620                        3,
 621                        first_paint);
 622
 623   canvas->save();
 624
 625   canvas->clipRect(SkRect::MakeWH(50, 50));
 626   // (10, 10, 40, 40).
 627   canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
 628                        3,
 629                        points,
 630                        points,
 631                        colors,
 632                        NULL,
 633                        indecies,
 634                        3,
 635                        second_paint);
 636
 637   canvas->restore();
 638
 639   points[0].set(50, 55);
 640   points[1].set(50, 55);
 641   points[2].set(200, 200);
 642   // (50, 55, 150, 145).
 643   canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
 644                        3,
 645                        points,
 646                        points,
 647                        colors,
 648                        NULL,
 649                        indecies,
 650                        3,
 651                        third_paint);
 652
 653   skia::RefPtr<SkPicture> picture = skia::AdoptRef(StopRecording(&recorder, canvas));
 654
 655   std::vector<skia::PixelRefUtils::PositionPixelRef> pixel_refs;
 656   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture.get(), &pixel_refs);
 657
 658   EXPECT_EQ(3u, pixel_refs.size());
 659   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 10, 90, 90),
 660                        gfx::SkRectToRectF(pixel_refs[0].pixel_ref_rect));
 661   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10, 10, 40, 40),
 662                        gfx::SkRectToRectF(pixel_refs[1].pixel_ref_rect));
 663   EXPECT_FLOAT_RECT_EQ(gfx::RectF(50, 55, 150, 145),
 664                        gfx::SkRectToRectF(pixel_refs[2].pixel_ref_rect));
 665 }
 666
 667 }  // namespace skia