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