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