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