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