OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/tiles/software_image_decode_controller.h" | 5 #include "cc/tiles/software_image_decode_controller.h" |
6 | 6 |
7 #include "cc/playback/draw_image.h" | 7 #include "cc/playback/draw_image.h" |
8 #include "cc/raster/tile_task.h" | 8 #include "cc/test/simple_task_runner.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
10 #include "third_party/skia/include/core/SkRefCnt.h" | 10 #include "third_party/skia/include/core/SkRefCnt.h" |
11 | 11 |
12 namespace cc { | 12 namespace cc { |
13 namespace { | 13 namespace { |
14 | 14 |
15 sk_sp<SkImage> CreateImage(int width, int height) { | 15 sk_sp<SkImage> CreateImage(int width, int height) { |
16 SkBitmap bitmap; | 16 SkBitmap bitmap; |
17 bitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height)); | 17 bitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height)); |
18 return SkImage::MakeFromBitmap(bitmap); | 18 return SkImage::MakeFromBitmap(bitmap); |
(...skipping 348 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
367 | 367 |
368 DrawImage another_draw_image( | 368 DrawImage another_draw_image( |
369 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 369 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
370 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 370 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
371 scoped_refptr<TileTask> another_task; | 371 scoped_refptr<TileTask> another_task; |
372 need_unref = controller.GetTaskForImageAndRef( | 372 need_unref = controller.GetTaskForImageAndRef( |
373 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); | 373 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); |
374 EXPECT_TRUE(need_unref); | 374 EXPECT_TRUE(need_unref); |
375 EXPECT_TRUE(task.get() == another_task.get()); | 375 EXPECT_TRUE(task.get() == another_task.get()); |
376 | 376 |
| 377 SimpleTaskRunner::ProcessTask(task.get()); |
| 378 |
377 controller.UnrefImage(draw_image); | 379 controller.UnrefImage(draw_image); |
378 controller.UnrefImage(draw_image); | 380 controller.UnrefImage(draw_image); |
379 } | 381 } |
380 | 382 |
381 TEST(SoftwareImageDecodeControllerTest, | 383 TEST(SoftwareImageDecodeControllerTest, |
382 GetTaskForImageSameImageDifferentQuality) { | 384 GetTaskForImageSameImageDifferentQuality) { |
383 SoftwareImageDecodeController controller; | 385 SoftwareImageDecodeController controller; |
384 sk_sp<SkImage> image = CreateImage(100, 100); | 386 sk_sp<SkImage> image = CreateImage(100, 100); |
385 bool is_decomposable = true; | 387 bool is_decomposable = true; |
386 | 388 |
(...skipping 29 matching lines...) Expand all Loading... |
416 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 418 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
417 scoped_refptr<TileTask> low_quality_task; | 419 scoped_refptr<TileTask> low_quality_task; |
418 need_unref = controller.GetTaskForImageAndRef( | 420 need_unref = controller.GetTaskForImageAndRef( |
419 low_quality_draw_image, ImageDecodeController::TracingInfo(), | 421 low_quality_draw_image, ImageDecodeController::TracingInfo(), |
420 &low_quality_task); | 422 &low_quality_task); |
421 EXPECT_TRUE(need_unref); | 423 EXPECT_TRUE(need_unref); |
422 EXPECT_TRUE(low_quality_task); | 424 EXPECT_TRUE(low_quality_task); |
423 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); | 425 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); |
424 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get()); | 426 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get()); |
425 | 427 |
| 428 SimpleTaskRunner::ProcessTask(high_quality_task.get()); |
| 429 SimpleTaskRunner::ProcessTask(medium_quality_task.get()); |
| 430 SimpleTaskRunner::ProcessTask(low_quality_task.get()); |
| 431 |
426 controller.UnrefImage(high_quality_draw_image); | 432 controller.UnrefImage(high_quality_draw_image); |
427 controller.UnrefImage(low_quality_draw_image); | 433 controller.UnrefImage(low_quality_draw_image); |
428 } | 434 } |
429 | 435 |
430 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { | 436 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { |
431 SoftwareImageDecodeController controller; | 437 SoftwareImageDecodeController controller; |
432 sk_sp<SkImage> image = CreateImage(100, 100); | 438 sk_sp<SkImage> image = CreateImage(100, 100); |
433 bool is_decomposable = true; | 439 bool is_decomposable = true; |
434 SkFilterQuality quality = kHigh_SkFilterQuality; | 440 SkFilterQuality quality = kHigh_SkFilterQuality; |
435 | 441 |
(...skipping 11 matching lines...) Expand all Loading... |
447 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 453 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
448 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 454 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
449 scoped_refptr<TileTask> quarter_size_task; | 455 scoped_refptr<TileTask> quarter_size_task; |
450 need_unref = controller.GetTaskForImageAndRef( | 456 need_unref = controller.GetTaskForImageAndRef( |
451 quarter_size_draw_image, ImageDecodeController::TracingInfo(), | 457 quarter_size_draw_image, ImageDecodeController::TracingInfo(), |
452 &quarter_size_task); | 458 &quarter_size_task); |
453 EXPECT_TRUE(need_unref); | 459 EXPECT_TRUE(need_unref); |
454 EXPECT_TRUE(quarter_size_task); | 460 EXPECT_TRUE(quarter_size_task); |
455 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); | 461 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); |
456 | 462 |
| 463 SimpleTaskRunner::ProcessTask(half_size_task.get()); |
| 464 SimpleTaskRunner::ProcessTask(quarter_size_task.get()); |
| 465 |
457 controller.UnrefImage(half_size_draw_image); | 466 controller.UnrefImage(half_size_draw_image); |
458 controller.UnrefImage(quarter_size_draw_image); | 467 controller.UnrefImage(quarter_size_draw_image); |
459 } | 468 } |
460 | 469 |
461 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { | 470 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
462 SoftwareImageDecodeController controller; | 471 SoftwareImageDecodeController controller; |
463 bool is_decomposable = true; | 472 bool is_decomposable = true; |
464 SkFilterQuality quality = kHigh_SkFilterQuality; | 473 SkFilterQuality quality = kHigh_SkFilterQuality; |
465 | 474 |
466 sk_sp<SkImage> first_image = CreateImage(100, 100); | 475 sk_sp<SkImage> first_image = CreateImage(100, 100); |
(...skipping 11 matching lines...) Expand all Loading... |
478 second_image, | 487 second_image, |
479 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 488 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
480 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 489 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
481 scoped_refptr<TileTask> second_task; | 490 scoped_refptr<TileTask> second_task; |
482 need_unref = controller.GetTaskForImageAndRef( | 491 need_unref = controller.GetTaskForImageAndRef( |
483 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | 492 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
484 EXPECT_TRUE(need_unref); | 493 EXPECT_TRUE(need_unref); |
485 EXPECT_TRUE(second_task); | 494 EXPECT_TRUE(second_task); |
486 EXPECT_TRUE(first_task.get() != second_task.get()); | 495 EXPECT_TRUE(first_task.get() != second_task.get()); |
487 | 496 |
| 497 SimpleTaskRunner::ProcessTask(first_task.get()); |
| 498 SimpleTaskRunner::ProcessTask(second_task.get()); |
| 499 |
488 controller.UnrefImage(first_draw_image); | 500 controller.UnrefImage(first_draw_image); |
489 controller.UnrefImage(second_draw_image); | 501 controller.UnrefImage(second_draw_image); |
490 } | 502 } |
491 | 503 |
492 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { | 504 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { |
493 SoftwareImageDecodeController controller; | 505 SoftwareImageDecodeController controller; |
494 bool is_decomposable = true; | 506 bool is_decomposable = true; |
495 SkFilterQuality quality = kHigh_SkFilterQuality; | 507 SkFilterQuality quality = kHigh_SkFilterQuality; |
496 | 508 |
497 sk_sp<SkImage> image = CreateImage(100, 100); | 509 sk_sp<SkImage> image = CreateImage(100, 100); |
498 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 510 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
499 quality, | 511 quality, |
500 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 512 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
501 scoped_refptr<TileTask> task; | 513 scoped_refptr<TileTask> task; |
502 bool need_unref = controller.GetTaskForImageAndRef( | 514 bool need_unref = controller.GetTaskForImageAndRef( |
503 draw_image, ImageDecodeController::TracingInfo(), &task); | 515 draw_image, ImageDecodeController::TracingInfo(), &task); |
504 EXPECT_TRUE(need_unref); | 516 EXPECT_TRUE(need_unref); |
505 EXPECT_TRUE(task); | 517 EXPECT_TRUE(task); |
506 | 518 |
507 // TODO(prashant.n): Implement proper task life cycle. crbug.com/599863. | 519 SimpleTaskRunner::ScheduleTask(task.get()); |
508 task->RunOnWorkerThread(); | 520 SimpleTaskRunner::RunTask(task.get()); |
509 | 521 |
510 scoped_refptr<TileTask> another_task; | 522 scoped_refptr<TileTask> another_task; |
511 need_unref = controller.GetTaskForImageAndRef( | 523 need_unref = controller.GetTaskForImageAndRef( |
512 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 524 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
513 EXPECT_TRUE(need_unref); | 525 EXPECT_TRUE(need_unref); |
514 EXPECT_FALSE(another_task); | 526 EXPECT_FALSE(another_task); |
515 | 527 |
516 task->OnTaskCompleted(); | 528 SimpleTaskRunner::CompleteTask(task.get()); |
517 | 529 |
518 controller.UnrefImage(draw_image); | 530 controller.UnrefImage(draw_image); |
519 controller.UnrefImage(draw_image); | 531 controller.UnrefImage(draw_image); |
520 } | 532 } |
521 | 533 |
522 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { | 534 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { |
523 SoftwareImageDecodeController controller; | 535 SoftwareImageDecodeController controller; |
524 bool is_decomposable = true; | 536 bool is_decomposable = true; |
525 SkFilterQuality quality = kLow_SkFilterQuality; | 537 SkFilterQuality quality = kLow_SkFilterQuality; |
526 | 538 |
527 sk_sp<SkImage> image = CreateImage(100, 100); | 539 sk_sp<SkImage> image = CreateImage(100, 100); |
528 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 540 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
529 quality, | 541 quality, |
530 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 542 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
531 scoped_refptr<TileTask> task; | 543 scoped_refptr<TileTask> task; |
532 bool need_unref = controller.GetTaskForImageAndRef( | 544 bool need_unref = controller.GetTaskForImageAndRef( |
533 draw_image, ImageDecodeController::TracingInfo(), &task); | 545 draw_image, ImageDecodeController::TracingInfo(), &task); |
534 EXPECT_TRUE(need_unref); | 546 EXPECT_TRUE(need_unref); |
535 EXPECT_TRUE(task); | 547 EXPECT_TRUE(task); |
536 | 548 |
537 task->RunOnWorkerThread(); | 549 SimpleTaskRunner::ScheduleTask(task.get()); |
| 550 SimpleTaskRunner::RunTask(task.get()); |
538 | 551 |
539 scoped_refptr<TileTask> another_task; | 552 scoped_refptr<TileTask> another_task; |
540 need_unref = controller.GetTaskForImageAndRef( | 553 need_unref = controller.GetTaskForImageAndRef( |
541 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 554 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
542 EXPECT_TRUE(need_unref); | 555 EXPECT_TRUE(need_unref); |
543 EXPECT_FALSE(another_task); | 556 EXPECT_FALSE(another_task); |
544 | 557 |
545 task->OnTaskCompleted(); | 558 SimpleTaskRunner::CompleteTask(task.get()); |
546 | 559 |
547 scoped_refptr<TileTask> third_task; | 560 scoped_refptr<TileTask> third_task; |
548 need_unref = controller.GetTaskForImageAndRef( | 561 need_unref = controller.GetTaskForImageAndRef( |
549 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 562 draw_image, ImageDecodeController::TracingInfo(), &third_task); |
550 EXPECT_TRUE(need_unref); | 563 EXPECT_TRUE(need_unref); |
551 EXPECT_FALSE(third_task); | 564 EXPECT_FALSE(third_task); |
552 | 565 |
553 controller.UnrefImage(draw_image); | 566 controller.UnrefImage(draw_image); |
554 controller.UnrefImage(draw_image); | 567 controller.UnrefImage(draw_image); |
555 controller.UnrefImage(draw_image); | 568 controller.UnrefImage(draw_image); |
(...skipping 14 matching lines...) Expand all Loading... |
570 EXPECT_TRUE(need_unref); | 583 EXPECT_TRUE(need_unref); |
571 EXPECT_TRUE(task); | 584 EXPECT_TRUE(task); |
572 | 585 |
573 scoped_refptr<TileTask> another_task; | 586 scoped_refptr<TileTask> another_task; |
574 need_unref = controller.GetTaskForImageAndRef( | 587 need_unref = controller.GetTaskForImageAndRef( |
575 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 588 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
576 EXPECT_TRUE(need_unref); | 589 EXPECT_TRUE(need_unref); |
577 EXPECT_TRUE(another_task.get() == task.get()); | 590 EXPECT_TRUE(another_task.get() == task.get()); |
578 | 591 |
579 // Didn't run the task, complete it (it was canceled). | 592 // Didn't run the task, complete it (it was canceled). |
580 task->OnTaskCompleted(); | 593 SimpleTaskRunner::CancelTask(task.get()); |
| 594 SimpleTaskRunner::CompleteTask(task.get()); |
581 | 595 |
582 // Fully cancel everything (so the raster would unref things). | 596 // Fully cancel everything (so the raster would unref things). |
583 controller.UnrefImage(draw_image); | 597 controller.UnrefImage(draw_image); |
584 controller.UnrefImage(draw_image); | 598 controller.UnrefImage(draw_image); |
585 | 599 |
586 // Here a new task is created. | 600 // Here a new task is created. |
587 scoped_refptr<TileTask> third_task; | 601 scoped_refptr<TileTask> third_task; |
588 need_unref = controller.GetTaskForImageAndRef( | 602 need_unref = controller.GetTaskForImageAndRef( |
589 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 603 draw_image, ImageDecodeController::TracingInfo(), &third_task); |
590 EXPECT_TRUE(need_unref); | 604 EXPECT_TRUE(need_unref); |
591 EXPECT_TRUE(third_task); | 605 EXPECT_TRUE(third_task); |
592 EXPECT_FALSE(third_task.get() == task.get()); | 606 EXPECT_FALSE(third_task.get() == task.get()); |
593 | 607 |
| 608 SimpleTaskRunner::ProcessTask(third_task.get()); |
| 609 |
594 controller.UnrefImage(draw_image); | 610 controller.UnrefImage(draw_image); |
595 } | 611 } |
596 | 612 |
597 TEST(SoftwareImageDecodeControllerTest, | 613 TEST(SoftwareImageDecodeControllerTest, |
598 GetTaskForImageCanceledWhileReffedGetsNewTask) { | 614 GetTaskForImageCanceledWhileReffedGetsNewTask) { |
599 SoftwareImageDecodeController controller; | 615 SoftwareImageDecodeController controller; |
600 bool is_decomposable = true; | 616 bool is_decomposable = true; |
601 SkFilterQuality quality = kHigh_SkFilterQuality; | 617 SkFilterQuality quality = kHigh_SkFilterQuality; |
602 | 618 |
603 sk_sp<SkImage> image = CreateImage(100, 100); | 619 sk_sp<SkImage> image = CreateImage(100, 100); |
604 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 620 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
605 quality, | 621 quality, |
606 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 622 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
607 scoped_refptr<TileTask> task; | 623 scoped_refptr<TileTask> task; |
608 bool need_unref = controller.GetTaskForImageAndRef( | 624 bool need_unref = controller.GetTaskForImageAndRef( |
609 draw_image, ImageDecodeController::TracingInfo(), &task); | 625 draw_image, ImageDecodeController::TracingInfo(), &task); |
610 EXPECT_TRUE(need_unref); | 626 EXPECT_TRUE(need_unref); |
611 EXPECT_TRUE(task); | 627 EXPECT_TRUE(task); |
612 | 628 |
613 scoped_refptr<TileTask> another_task; | 629 scoped_refptr<TileTask> another_task; |
614 need_unref = controller.GetTaskForImageAndRef( | 630 need_unref = controller.GetTaskForImageAndRef( |
615 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 631 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
616 EXPECT_TRUE(need_unref); | 632 EXPECT_TRUE(need_unref); |
617 EXPECT_TRUE(another_task.get() == task.get()); | 633 EXPECT_TRUE(another_task.get() == task.get()); |
618 | 634 |
619 // Didn't run the task, complete it (it was canceled). | 635 // Didn't run the task, complete it (it was canceled). |
620 task->OnTaskCompleted(); | 636 SimpleTaskRunner::CancelTask(task.get()); |
| 637 SimpleTaskRunner::CompleteTask(task.get()); |
621 | 638 |
622 // Note that here, everything is reffed, but a new task is created. This is | 639 // Note that here, everything is reffed, but a new task is created. This is |
623 // possible with repeated schedule/cancel operations. | 640 // possible with repeated schedule/cancel operations. |
624 scoped_refptr<TileTask> third_task; | 641 scoped_refptr<TileTask> third_task; |
625 need_unref = controller.GetTaskForImageAndRef( | 642 need_unref = controller.GetTaskForImageAndRef( |
626 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 643 draw_image, ImageDecodeController::TracingInfo(), &third_task); |
627 EXPECT_TRUE(need_unref); | 644 EXPECT_TRUE(need_unref); |
628 EXPECT_TRUE(third_task); | 645 EXPECT_TRUE(third_task); |
629 EXPECT_FALSE(third_task.get() == task.get()); | 646 EXPECT_FALSE(third_task.get() == task.get()); |
630 | 647 |
| 648 SimpleTaskRunner::ProcessTask(third_task.get()); |
| 649 |
631 // 3 Unrefs! | 650 // 3 Unrefs! |
632 controller.UnrefImage(draw_image); | 651 controller.UnrefImage(draw_image); |
633 controller.UnrefImage(draw_image); | 652 controller.UnrefImage(draw_image); |
634 controller.UnrefImage(draw_image); | 653 controller.UnrefImage(draw_image); |
635 } | 654 } |
636 | 655 |
637 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { | 656 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { |
638 SoftwareImageDecodeController controller; | 657 SoftwareImageDecodeController controller; |
639 bool is_decomposable = true; | 658 bool is_decomposable = true; |
640 SkFilterQuality quality = kHigh_SkFilterQuality; | 659 SkFilterQuality quality = kHigh_SkFilterQuality; |
641 | 660 |
642 sk_sp<SkImage> image = CreateImage(100, 100); | 661 sk_sp<SkImage> image = CreateImage(100, 100); |
643 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 662 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
644 quality, | 663 quality, |
645 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 664 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
646 scoped_refptr<TileTask> task; | 665 scoped_refptr<TileTask> task; |
647 bool need_unref = controller.GetTaskForImageAndRef( | 666 bool need_unref = controller.GetTaskForImageAndRef( |
648 draw_image, ImageDecodeController::TracingInfo(), &task); | 667 draw_image, ImageDecodeController::TracingInfo(), &task); |
649 EXPECT_TRUE(need_unref); | 668 EXPECT_TRUE(need_unref); |
650 EXPECT_TRUE(task); | 669 EXPECT_TRUE(task); |
651 | 670 |
652 task->RunOnWorkerThread(); | 671 SimpleTaskRunner::ProcessTask(task.get()); |
653 | |
654 task->OnTaskCompleted(); | |
655 | 672 |
656 DecodedDrawImage decoded_draw_image = | 673 DecodedDrawImage decoded_draw_image = |
657 controller.GetDecodedImageForDraw(draw_image); | 674 controller.GetDecodedImageForDraw(draw_image); |
658 EXPECT_TRUE(decoded_draw_image.image()); | 675 EXPECT_TRUE(decoded_draw_image.image()); |
659 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 676 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
660 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 677 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
661 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 678 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
662 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 679 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
663 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 680 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
664 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 681 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
(...skipping 12 matching lines...) Expand all Loading... |
677 sk_sp<SkImage> image = CreateImage(100, 100); | 694 sk_sp<SkImage> image = CreateImage(100, 100); |
678 DrawImage draw_image( | 695 DrawImage draw_image( |
679 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 696 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), |
680 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 697 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
681 scoped_refptr<TileTask> task; | 698 scoped_refptr<TileTask> task; |
682 bool need_unref = controller.GetTaskForImageAndRef( | 699 bool need_unref = controller.GetTaskForImageAndRef( |
683 draw_image, ImageDecodeController::TracingInfo(), &task); | 700 draw_image, ImageDecodeController::TracingInfo(), &task); |
684 EXPECT_TRUE(need_unref); | 701 EXPECT_TRUE(need_unref); |
685 EXPECT_TRUE(task); | 702 EXPECT_TRUE(task); |
686 | 703 |
687 task->RunOnWorkerThread(); | 704 SimpleTaskRunner::ProcessTask(task.get()); |
688 | |
689 task->OnTaskCompleted(); | |
690 | 705 |
691 DecodedDrawImage decoded_draw_image = | 706 DecodedDrawImage decoded_draw_image = |
692 controller.GetDecodedImageForDraw(draw_image); | 707 controller.GetDecodedImageForDraw(draw_image); |
693 EXPECT_TRUE(decoded_draw_image.image()); | 708 EXPECT_TRUE(decoded_draw_image.image()); |
694 EXPECT_EQ(40, decoded_draw_image.image()->width()); | 709 EXPECT_EQ(40, decoded_draw_image.image()->width()); |
695 EXPECT_EQ(35, decoded_draw_image.image()->height()); | 710 EXPECT_EQ(35, decoded_draw_image.image()->height()); |
696 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 711 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
697 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 712 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
698 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 713 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
699 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 714 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
779 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 794 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
780 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 795 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
781 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 796 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
782 | 797 |
783 scoped_refptr<TileTask> task; | 798 scoped_refptr<TileTask> task; |
784 bool need_unref = controller.GetTaskForImageAndRef( | 799 bool need_unref = controller.GetTaskForImageAndRef( |
785 draw_image, ImageDecodeController::TracingInfo(), &task); | 800 draw_image, ImageDecodeController::TracingInfo(), &task); |
786 EXPECT_TRUE(need_unref); | 801 EXPECT_TRUE(need_unref); |
787 EXPECT_TRUE(task); | 802 EXPECT_TRUE(task); |
788 | 803 |
789 task->RunOnWorkerThread(); | 804 SimpleTaskRunner::ProcessTask(task.get()); |
790 | |
791 task->OnTaskCompleted(); | |
792 | 805 |
793 DecodedDrawImage another_decoded_draw_image = | 806 DecodedDrawImage another_decoded_draw_image = |
794 controller.GetDecodedImageForDraw(draw_image); | 807 controller.GetDecodedImageForDraw(draw_image); |
795 // This should get the new decoded/locked image, not the one we're using at | 808 // This should get the new decoded/locked image, not the one we're using at |
796 // raster. | 809 // raster. |
797 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves | 810 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves |
798 // the image to the right spot. | 811 // the image to the right spot. |
799 EXPECT_NE(decoded_draw_image.image()->uniqueID(), | 812 EXPECT_NE(decoded_draw_image.image()->uniqueID(), |
800 another_decoded_draw_image.image()->uniqueID()); | 813 another_decoded_draw_image.image()->uniqueID()); |
801 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); | 814 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); |
(...skipping 28 matching lines...) Expand all Loading... |
830 scoped_refptr<TileTask> task; | 843 scoped_refptr<TileTask> task; |
831 bool need_unref = controller.GetTaskForImageAndRef( | 844 bool need_unref = controller.GetTaskForImageAndRef( |
832 draw_image, ImageDecodeController::TracingInfo(), &task); | 845 draw_image, ImageDecodeController::TracingInfo(), &task); |
833 EXPECT_TRUE(need_unref); | 846 EXPECT_TRUE(need_unref); |
834 EXPECT_TRUE(task); | 847 EXPECT_TRUE(task); |
835 | 848 |
836 // If we finish the draw here, then we will use it for the locked decode | 849 // If we finish the draw here, then we will use it for the locked decode |
837 // instead of decoding again. | 850 // instead of decoding again. |
838 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 851 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
839 | 852 |
840 task->RunOnWorkerThread(); | 853 SimpleTaskRunner::ProcessTask(task.get()); |
841 | |
842 task->OnTaskCompleted(); | |
843 | 854 |
844 DecodedDrawImage another_decoded_draw_image = | 855 DecodedDrawImage another_decoded_draw_image = |
845 controller.GetDecodedImageForDraw(draw_image); | 856 controller.GetDecodedImageForDraw(draw_image); |
846 // This should get the decoded/locked image which we originally decoded at | 857 // This should get the decoded/locked image which we originally decoded at |
847 // raster time, since it's now in the locked cache. | 858 // raster time, since it's now in the locked cache. |
848 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | 859 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
849 another_decoded_draw_image.image()->uniqueID()); | 860 another_decoded_draw_image.image()->uniqueID()); |
850 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); | 861 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); |
851 | 862 |
852 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 863 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
908 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 919 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
909 quality, | 920 quality, |
910 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 921 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
911 | 922 |
912 scoped_refptr<TileTask> task; | 923 scoped_refptr<TileTask> task; |
913 bool need_unref = controller.GetTaskForImageAndRef( | 924 bool need_unref = controller.GetTaskForImageAndRef( |
914 draw_image, ImageDecodeController::TracingInfo(), &task); | 925 draw_image, ImageDecodeController::TracingInfo(), &task); |
915 EXPECT_TRUE(task); | 926 EXPECT_TRUE(task); |
916 EXPECT_TRUE(need_unref); | 927 EXPECT_TRUE(need_unref); |
917 | 928 |
| 929 SimpleTaskRunner::ProcessTask(task.get()); |
| 930 |
918 DecodedDrawImage decoded_draw_image = | 931 DecodedDrawImage decoded_draw_image = |
919 controller.GetDecodedImageForDraw(draw_image); | 932 controller.GetDecodedImageForDraw(draw_image); |
920 EXPECT_TRUE(decoded_draw_image.image()); | 933 EXPECT_TRUE(decoded_draw_image.image()); |
921 // If we decoded the image and cached it, it would be stored in a different | 934 // If we decoded the image and cached it, it would be stored in a different |
922 // SkImage object. | 935 // SkImage object. |
923 EXPECT_TRUE(decoded_draw_image.image() != image); | 936 EXPECT_TRUE(decoded_draw_image.image() != image); |
924 | 937 |
925 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 938 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
926 controller.UnrefImage(draw_image); | 939 controller.UnrefImage(draw_image); |
927 } | 940 } |
928 | 941 |
929 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { | 942 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { |
930 SoftwareImageDecodeController controller; | 943 SoftwareImageDecodeController controller; |
931 bool is_decomposable = true; | 944 bool is_decomposable = true; |
932 SkFilterQuality quality = kLow_SkFilterQuality; | 945 SkFilterQuality quality = kLow_SkFilterQuality; |
933 | 946 |
934 sk_sp<SkImage> image = CreateImage(100, 100); | 947 sk_sp<SkImage> image = CreateImage(100, 100); |
935 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 948 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
936 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 949 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
937 | 950 |
938 scoped_refptr<TileTask> task; | 951 scoped_refptr<TileTask> task; |
939 bool need_unref = controller.GetTaskForImageAndRef( | 952 bool need_unref = controller.GetTaskForImageAndRef( |
940 draw_image, ImageDecodeController::TracingInfo(), &task); | 953 draw_image, ImageDecodeController::TracingInfo(), &task); |
941 EXPECT_TRUE(task); | 954 EXPECT_TRUE(task); |
942 EXPECT_TRUE(need_unref); | 955 EXPECT_TRUE(need_unref); |
943 | 956 |
| 957 SimpleTaskRunner::ProcessTask(task.get()); |
| 958 |
944 DecodedDrawImage decoded_draw_image = | 959 DecodedDrawImage decoded_draw_image = |
945 controller.GetDecodedImageForDraw(draw_image); | 960 controller.GetDecodedImageForDraw(draw_image); |
946 EXPECT_TRUE(decoded_draw_image.image()); | 961 EXPECT_TRUE(decoded_draw_image.image()); |
947 // If we decoded the image and cached it, it would be stored in a different | 962 // If we decoded the image and cached it, it would be stored in a different |
948 // SkImage object. | 963 // SkImage object. |
949 EXPECT_TRUE(decoded_draw_image.image() != image); | 964 EXPECT_TRUE(decoded_draw_image.image() != image); |
950 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 965 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
951 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 966 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
952 | 967 |
953 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 968 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
954 controller.UnrefImage(draw_image); | 969 controller.UnrefImage(draw_image); |
955 } | 970 } |
956 | 971 |
957 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { | 972 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { |
958 SoftwareImageDecodeController controller; | 973 SoftwareImageDecodeController controller; |
959 bool is_decomposable = true; | 974 bool is_decomposable = true; |
960 SkFilterQuality quality = kNone_SkFilterQuality; | 975 SkFilterQuality quality = kNone_SkFilterQuality; |
961 | 976 |
962 sk_sp<SkImage> image = CreateImage(100, 100); | 977 sk_sp<SkImage> image = CreateImage(100, 100); |
963 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 978 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
964 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 979 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
965 | 980 |
966 scoped_refptr<TileTask> task; | 981 scoped_refptr<TileTask> task; |
967 bool need_unref = controller.GetTaskForImageAndRef( | 982 bool need_unref = controller.GetTaskForImageAndRef( |
968 draw_image, ImageDecodeController::TracingInfo(), &task); | 983 draw_image, ImageDecodeController::TracingInfo(), &task); |
969 EXPECT_TRUE(task); | 984 EXPECT_TRUE(task); |
970 EXPECT_TRUE(need_unref); | 985 EXPECT_TRUE(need_unref); |
971 | 986 |
| 987 SimpleTaskRunner::ProcessTask(task.get()); |
| 988 |
972 DecodedDrawImage decoded_draw_image = | 989 DecodedDrawImage decoded_draw_image = |
973 controller.GetDecodedImageForDraw(draw_image); | 990 controller.GetDecodedImageForDraw(draw_image); |
974 EXPECT_TRUE(decoded_draw_image.image()); | 991 EXPECT_TRUE(decoded_draw_image.image()); |
975 // If we decoded the image and cached it, it would be stored in a different | 992 // If we decoded the image and cached it, it would be stored in a different |
976 // SkImage object. | 993 // SkImage object. |
977 EXPECT_TRUE(decoded_draw_image.image() != image); | 994 EXPECT_TRUE(decoded_draw_image.image() != image); |
978 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); | 995 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); |
979 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 996 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
980 | 997 |
981 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 998 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
982 controller.UnrefImage(draw_image); | 999 controller.UnrefImage(draw_image); |
983 } | 1000 } |
984 } // namespace | 1001 } // namespace |
985 } // namespace cc | 1002 } // namespace cc |
OLD | NEW |