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" | |
9 #include "cc/resources/resource_format.h" | 8 #include "cc/resources/resource_format.h" |
| 9 #include "cc/test/test_tile_task_runner.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
11 #include "third_party/skia/include/core/SkRefCnt.h" | 11 #include "third_party/skia/include/core/SkRefCnt.h" |
12 | 12 |
13 namespace cc { | 13 namespace cc { |
14 namespace { | 14 namespace { |
15 | 15 |
16 size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024; | 16 size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024; |
17 class TestSoftwareImageDecodeController : public SoftwareImageDecodeController { | 17 class TestSoftwareImageDecodeController : public SoftwareImageDecodeController { |
18 public: | 18 public: |
19 TestSoftwareImageDecodeController() | 19 TestSoftwareImageDecodeController() |
(...skipping 482 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
502 | 502 |
503 DrawImage another_draw_image( | 503 DrawImage another_draw_image( |
504 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 504 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
505 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 505 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
506 scoped_refptr<TileTask> another_task; | 506 scoped_refptr<TileTask> another_task; |
507 need_unref = controller.GetTaskForImageAndRef( | 507 need_unref = controller.GetTaskForImageAndRef( |
508 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); | 508 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); |
509 EXPECT_TRUE(need_unref); | 509 EXPECT_TRUE(need_unref); |
510 EXPECT_TRUE(task.get() == another_task.get()); | 510 EXPECT_TRUE(task.get() == another_task.get()); |
511 | 511 |
| 512 TestTileTaskRunner::ProcessTask(task.get()); |
| 513 |
512 controller.UnrefImage(draw_image); | 514 controller.UnrefImage(draw_image); |
513 controller.UnrefImage(draw_image); | 515 controller.UnrefImage(draw_image); |
514 } | 516 } |
515 | 517 |
516 TEST(SoftwareImageDecodeControllerTest, | 518 TEST(SoftwareImageDecodeControllerTest, |
517 GetTaskForImageSameImageDifferentQuality) { | 519 GetTaskForImageSameImageDifferentQuality) { |
518 TestSoftwareImageDecodeController controller; | 520 TestSoftwareImageDecodeController controller; |
519 sk_sp<SkImage> image = CreateImage(100, 100); | 521 sk_sp<SkImage> image = CreateImage(100, 100); |
520 bool is_decomposable = true; | 522 bool is_decomposable = true; |
521 | 523 |
(...skipping 26 matching lines...) Expand all Loading... |
548 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 550 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
549 scoped_refptr<TileTask> low_quality_task; | 551 scoped_refptr<TileTask> low_quality_task; |
550 need_unref = controller.GetTaskForImageAndRef( | 552 need_unref = controller.GetTaskForImageAndRef( |
551 low_quality_draw_image, ImageDecodeController::TracingInfo(), | 553 low_quality_draw_image, ImageDecodeController::TracingInfo(), |
552 &low_quality_task); | 554 &low_quality_task); |
553 EXPECT_TRUE(need_unref); | 555 EXPECT_TRUE(need_unref); |
554 EXPECT_TRUE(low_quality_task); | 556 EXPECT_TRUE(low_quality_task); |
555 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); | 557 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); |
556 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get()); | 558 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get()); |
557 | 559 |
| 560 TestTileTaskRunner::ProcessTask(high_quality_task.get()); |
| 561 TestTileTaskRunner::ProcessTask(medium_quality_task.get()); |
| 562 TestTileTaskRunner::ProcessTask(low_quality_task.get()); |
| 563 |
558 controller.UnrefImage(high_quality_draw_image); | 564 controller.UnrefImage(high_quality_draw_image); |
559 controller.UnrefImage(medium_quality_draw_image); | 565 controller.UnrefImage(medium_quality_draw_image); |
560 controller.UnrefImage(low_quality_draw_image); | 566 controller.UnrefImage(low_quality_draw_image); |
561 } | 567 } |
562 | 568 |
563 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { | 569 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { |
564 TestSoftwareImageDecodeController controller; | 570 TestSoftwareImageDecodeController controller; |
565 sk_sp<SkImage> image = CreateImage(100, 100); | 571 sk_sp<SkImage> image = CreateImage(100, 100); |
566 bool is_decomposable = true; | 572 bool is_decomposable = true; |
567 SkFilterQuality quality = kHigh_SkFilterQuality; | 573 SkFilterQuality quality = kHigh_SkFilterQuality; |
(...skipping 12 matching lines...) Expand all Loading... |
580 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 586 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
581 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 587 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
582 scoped_refptr<TileTask> quarter_size_task; | 588 scoped_refptr<TileTask> quarter_size_task; |
583 need_unref = controller.GetTaskForImageAndRef( | 589 need_unref = controller.GetTaskForImageAndRef( |
584 quarter_size_draw_image, ImageDecodeController::TracingInfo(), | 590 quarter_size_draw_image, ImageDecodeController::TracingInfo(), |
585 &quarter_size_task); | 591 &quarter_size_task); |
586 EXPECT_TRUE(need_unref); | 592 EXPECT_TRUE(need_unref); |
587 EXPECT_TRUE(quarter_size_task); | 593 EXPECT_TRUE(quarter_size_task); |
588 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); | 594 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); |
589 | 595 |
| 596 TestTileTaskRunner::ProcessTask(half_size_task.get()); |
| 597 TestTileTaskRunner::ProcessTask(quarter_size_task.get()); |
| 598 |
590 controller.UnrefImage(half_size_draw_image); | 599 controller.UnrefImage(half_size_draw_image); |
591 controller.UnrefImage(quarter_size_draw_image); | 600 controller.UnrefImage(quarter_size_draw_image); |
592 } | 601 } |
593 | 602 |
594 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { | 603 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
595 TestSoftwareImageDecodeController controller; | 604 TestSoftwareImageDecodeController controller; |
596 bool is_decomposable = true; | 605 bool is_decomposable = true; |
597 SkFilterQuality quality = kHigh_SkFilterQuality; | 606 SkFilterQuality quality = kHigh_SkFilterQuality; |
598 | 607 |
599 sk_sp<SkImage> first_image = CreateImage(100, 100); | 608 sk_sp<SkImage> first_image = CreateImage(100, 100); |
(...skipping 11 matching lines...) Expand all Loading... |
611 second_image, | 620 second_image, |
612 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 621 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
613 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 622 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
614 scoped_refptr<TileTask> second_task; | 623 scoped_refptr<TileTask> second_task; |
615 need_unref = controller.GetTaskForImageAndRef( | 624 need_unref = controller.GetTaskForImageAndRef( |
616 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | 625 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
617 EXPECT_TRUE(need_unref); | 626 EXPECT_TRUE(need_unref); |
618 EXPECT_TRUE(second_task); | 627 EXPECT_TRUE(second_task); |
619 EXPECT_TRUE(first_task.get() != second_task.get()); | 628 EXPECT_TRUE(first_task.get() != second_task.get()); |
620 | 629 |
| 630 TestTileTaskRunner::ProcessTask(first_task.get()); |
| 631 TestTileTaskRunner::ProcessTask(second_task.get()); |
| 632 |
621 controller.UnrefImage(first_draw_image); | 633 controller.UnrefImage(first_draw_image); |
622 controller.UnrefImage(second_draw_image); | 634 controller.UnrefImage(second_draw_image); |
623 } | 635 } |
624 | 636 |
625 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { | 637 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { |
626 TestSoftwareImageDecodeController controller; | 638 TestSoftwareImageDecodeController controller; |
627 bool is_decomposable = true; | 639 bool is_decomposable = true; |
628 SkFilterQuality quality = kHigh_SkFilterQuality; | 640 SkFilterQuality quality = kHigh_SkFilterQuality; |
629 | 641 |
630 sk_sp<SkImage> image = CreateImage(100, 100); | 642 sk_sp<SkImage> image = CreateImage(100, 100); |
631 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 643 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
632 quality, | 644 quality, |
633 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 645 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
634 scoped_refptr<TileTask> task; | 646 scoped_refptr<TileTask> task; |
635 bool need_unref = controller.GetTaskForImageAndRef( | 647 bool need_unref = controller.GetTaskForImageAndRef( |
636 draw_image, ImageDecodeController::TracingInfo(), &task); | 648 draw_image, ImageDecodeController::TracingInfo(), &task); |
637 EXPECT_TRUE(need_unref); | 649 EXPECT_TRUE(need_unref); |
638 EXPECT_TRUE(task); | 650 EXPECT_TRUE(task); |
639 | 651 |
640 // TODO(prashant.n): Implement proper task life cycle. crbug.com/599863. | 652 TestTileTaskRunner::ScheduleTask(task.get()); |
641 task->RunOnWorkerThread(); | 653 TestTileTaskRunner::RunTask(task.get()); |
642 | 654 |
643 scoped_refptr<TileTask> another_task; | 655 scoped_refptr<TileTask> another_task; |
644 need_unref = controller.GetTaskForImageAndRef( | 656 need_unref = controller.GetTaskForImageAndRef( |
645 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 657 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
646 EXPECT_TRUE(need_unref); | 658 EXPECT_TRUE(need_unref); |
647 EXPECT_FALSE(another_task); | 659 EXPECT_FALSE(another_task); |
648 | 660 |
649 task->OnTaskCompleted(); | 661 TestTileTaskRunner::CompleteTask(task.get()); |
650 | 662 |
651 controller.UnrefImage(draw_image); | 663 controller.UnrefImage(draw_image); |
652 controller.UnrefImage(draw_image); | 664 controller.UnrefImage(draw_image); |
653 } | 665 } |
654 | 666 |
655 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { | 667 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { |
656 TestSoftwareImageDecodeController controller; | 668 TestSoftwareImageDecodeController controller; |
657 bool is_decomposable = true; | 669 bool is_decomposable = true; |
658 SkFilterQuality quality = kLow_SkFilterQuality; | 670 SkFilterQuality quality = kLow_SkFilterQuality; |
659 | 671 |
660 sk_sp<SkImage> image = CreateImage(100, 100); | 672 sk_sp<SkImage> image = CreateImage(100, 100); |
661 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 673 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
662 quality, | 674 quality, |
663 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 675 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
664 scoped_refptr<TileTask> task; | 676 scoped_refptr<TileTask> task; |
665 bool need_unref = controller.GetTaskForImageAndRef( | 677 bool need_unref = controller.GetTaskForImageAndRef( |
666 draw_image, ImageDecodeController::TracingInfo(), &task); | 678 draw_image, ImageDecodeController::TracingInfo(), &task); |
667 EXPECT_TRUE(need_unref); | 679 EXPECT_TRUE(need_unref); |
668 EXPECT_TRUE(task); | 680 EXPECT_TRUE(task); |
669 | 681 |
670 task->RunOnWorkerThread(); | 682 TestTileTaskRunner::ScheduleTask(task.get()); |
| 683 TestTileTaskRunner::RunTask(task.get()); |
671 | 684 |
672 scoped_refptr<TileTask> another_task; | 685 scoped_refptr<TileTask> another_task; |
673 need_unref = controller.GetTaskForImageAndRef( | 686 need_unref = controller.GetTaskForImageAndRef( |
674 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 687 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
675 EXPECT_TRUE(need_unref); | 688 EXPECT_TRUE(need_unref); |
676 EXPECT_FALSE(another_task); | 689 EXPECT_FALSE(another_task); |
677 | 690 |
678 task->OnTaskCompleted(); | 691 TestTileTaskRunner::CompleteTask(task.get()); |
679 | 692 |
680 scoped_refptr<TileTask> third_task; | 693 scoped_refptr<TileTask> third_task; |
681 need_unref = controller.GetTaskForImageAndRef( | 694 need_unref = controller.GetTaskForImageAndRef( |
682 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 695 draw_image, ImageDecodeController::TracingInfo(), &third_task); |
683 EXPECT_TRUE(need_unref); | 696 EXPECT_TRUE(need_unref); |
684 EXPECT_FALSE(third_task); | 697 EXPECT_FALSE(third_task); |
685 | 698 |
686 controller.UnrefImage(draw_image); | 699 controller.UnrefImage(draw_image); |
687 controller.UnrefImage(draw_image); | 700 controller.UnrefImage(draw_image); |
688 controller.UnrefImage(draw_image); | 701 controller.UnrefImage(draw_image); |
(...skipping 14 matching lines...) Expand all Loading... |
703 EXPECT_TRUE(need_unref); | 716 EXPECT_TRUE(need_unref); |
704 EXPECT_TRUE(task); | 717 EXPECT_TRUE(task); |
705 | 718 |
706 scoped_refptr<TileTask> another_task; | 719 scoped_refptr<TileTask> another_task; |
707 need_unref = controller.GetTaskForImageAndRef( | 720 need_unref = controller.GetTaskForImageAndRef( |
708 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 721 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
709 EXPECT_TRUE(need_unref); | 722 EXPECT_TRUE(need_unref); |
710 EXPECT_TRUE(another_task.get() == task.get()); | 723 EXPECT_TRUE(another_task.get() == task.get()); |
711 | 724 |
712 // Didn't run the task, complete it (it was canceled). | 725 // Didn't run the task, complete it (it was canceled). |
713 task->OnTaskCompleted(); | 726 TestTileTaskRunner::CancelTask(task.get()); |
| 727 TestTileTaskRunner::CompleteTask(task.get()); |
714 | 728 |
715 // Fully cancel everything (so the raster would unref things). | 729 // Fully cancel everything (so the raster would unref things). |
716 controller.UnrefImage(draw_image); | 730 controller.UnrefImage(draw_image); |
717 controller.UnrefImage(draw_image); | 731 controller.UnrefImage(draw_image); |
718 | 732 |
719 // Here a new task is created. | 733 // Here a new task is created. |
720 scoped_refptr<TileTask> third_task; | 734 scoped_refptr<TileTask> third_task; |
721 need_unref = controller.GetTaskForImageAndRef( | 735 need_unref = controller.GetTaskForImageAndRef( |
722 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 736 draw_image, ImageDecodeController::TracingInfo(), &third_task); |
723 EXPECT_TRUE(need_unref); | 737 EXPECT_TRUE(need_unref); |
724 EXPECT_TRUE(third_task); | 738 EXPECT_TRUE(third_task); |
725 EXPECT_FALSE(third_task.get() == task.get()); | 739 EXPECT_FALSE(third_task.get() == task.get()); |
726 | 740 |
| 741 TestTileTaskRunner::ProcessTask(third_task.get()); |
| 742 |
727 controller.UnrefImage(draw_image); | 743 controller.UnrefImage(draw_image); |
728 } | 744 } |
729 | 745 |
730 TEST(SoftwareImageDecodeControllerTest, | 746 TEST(SoftwareImageDecodeControllerTest, |
731 GetTaskForImageCanceledWhileReffedGetsNewTask) { | 747 GetTaskForImageCanceledWhileReffedGetsNewTask) { |
732 TestSoftwareImageDecodeController controller; | 748 TestSoftwareImageDecodeController controller; |
733 bool is_decomposable = true; | 749 bool is_decomposable = true; |
734 SkFilterQuality quality = kHigh_SkFilterQuality; | 750 SkFilterQuality quality = kHigh_SkFilterQuality; |
735 | 751 |
736 sk_sp<SkImage> image = CreateImage(100, 100); | 752 sk_sp<SkImage> image = CreateImage(100, 100); |
737 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 753 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
738 quality, | 754 quality, |
739 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 755 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
740 scoped_refptr<TileTask> task; | 756 scoped_refptr<TileTask> task; |
741 bool need_unref = controller.GetTaskForImageAndRef( | 757 bool need_unref = controller.GetTaskForImageAndRef( |
742 draw_image, ImageDecodeController::TracingInfo(), &task); | 758 draw_image, ImageDecodeController::TracingInfo(), &task); |
743 EXPECT_TRUE(need_unref); | 759 EXPECT_TRUE(need_unref); |
744 EXPECT_TRUE(task); | 760 EXPECT_TRUE(task); |
745 | 761 |
746 scoped_refptr<TileTask> another_task; | 762 scoped_refptr<TileTask> another_task; |
747 need_unref = controller.GetTaskForImageAndRef( | 763 need_unref = controller.GetTaskForImageAndRef( |
748 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 764 draw_image, ImageDecodeController::TracingInfo(), &another_task); |
749 EXPECT_TRUE(need_unref); | 765 EXPECT_TRUE(need_unref); |
750 EXPECT_TRUE(another_task.get() == task.get()); | 766 EXPECT_TRUE(another_task.get() == task.get()); |
751 | 767 |
752 // Didn't run the task, complete it (it was canceled). | 768 // Didn't run the task, complete it (it was canceled). |
753 task->OnTaskCompleted(); | 769 TestTileTaskRunner::CancelTask(task.get()); |
| 770 TestTileTaskRunner::CompleteTask(task.get()); |
754 | 771 |
755 // Note that here, everything is reffed, but a new task is created. This is | 772 // Note that here, everything is reffed, but a new task is created. This is |
756 // possible with repeated schedule/cancel operations. | 773 // possible with repeated schedule/cancel operations. |
757 scoped_refptr<TileTask> third_task; | 774 scoped_refptr<TileTask> third_task; |
758 need_unref = controller.GetTaskForImageAndRef( | 775 need_unref = controller.GetTaskForImageAndRef( |
759 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 776 draw_image, ImageDecodeController::TracingInfo(), &third_task); |
760 EXPECT_TRUE(need_unref); | 777 EXPECT_TRUE(need_unref); |
761 EXPECT_TRUE(third_task); | 778 EXPECT_TRUE(third_task); |
762 EXPECT_FALSE(third_task.get() == task.get()); | 779 EXPECT_FALSE(third_task.get() == task.get()); |
763 | 780 |
| 781 TestTileTaskRunner::ProcessTask(third_task.get()); |
| 782 |
764 // 3 Unrefs! | 783 // 3 Unrefs! |
765 controller.UnrefImage(draw_image); | 784 controller.UnrefImage(draw_image); |
766 controller.UnrefImage(draw_image); | 785 controller.UnrefImage(draw_image); |
767 controller.UnrefImage(draw_image); | 786 controller.UnrefImage(draw_image); |
768 } | 787 } |
769 | 788 |
770 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { | 789 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { |
771 TestSoftwareImageDecodeController controller; | 790 TestSoftwareImageDecodeController controller; |
772 bool is_decomposable = true; | 791 bool is_decomposable = true; |
773 SkFilterQuality quality = kHigh_SkFilterQuality; | 792 SkFilterQuality quality = kHigh_SkFilterQuality; |
774 | 793 |
775 sk_sp<SkImage> image = CreateImage(100, 100); | 794 sk_sp<SkImage> image = CreateImage(100, 100); |
776 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 795 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
777 quality, | 796 quality, |
778 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 797 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
779 scoped_refptr<TileTask> task; | 798 scoped_refptr<TileTask> task; |
780 bool need_unref = controller.GetTaskForImageAndRef( | 799 bool need_unref = controller.GetTaskForImageAndRef( |
781 draw_image, ImageDecodeController::TracingInfo(), &task); | 800 draw_image, ImageDecodeController::TracingInfo(), &task); |
782 EXPECT_TRUE(need_unref); | 801 EXPECT_TRUE(need_unref); |
783 EXPECT_TRUE(task); | 802 EXPECT_TRUE(task); |
784 | 803 |
785 task->RunOnWorkerThread(); | 804 TestTileTaskRunner::ProcessTask(task.get()); |
786 | |
787 task->OnTaskCompleted(); | |
788 | 805 |
789 DecodedDrawImage decoded_draw_image = | 806 DecodedDrawImage decoded_draw_image = |
790 controller.GetDecodedImageForDraw(draw_image); | 807 controller.GetDecodedImageForDraw(draw_image); |
791 EXPECT_TRUE(decoded_draw_image.image()); | 808 EXPECT_TRUE(decoded_draw_image.image()); |
792 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 809 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
793 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 810 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
794 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 811 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
795 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 812 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
796 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 813 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
797 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 814 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
(...skipping 12 matching lines...) Expand all Loading... |
810 sk_sp<SkImage> image = CreateImage(100, 100); | 827 sk_sp<SkImage> image = CreateImage(100, 100); |
811 DrawImage draw_image( | 828 DrawImage draw_image( |
812 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 829 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), |
813 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 830 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
814 scoped_refptr<TileTask> task; | 831 scoped_refptr<TileTask> task; |
815 bool need_unref = controller.GetTaskForImageAndRef( | 832 bool need_unref = controller.GetTaskForImageAndRef( |
816 draw_image, ImageDecodeController::TracingInfo(), &task); | 833 draw_image, ImageDecodeController::TracingInfo(), &task); |
817 EXPECT_TRUE(need_unref); | 834 EXPECT_TRUE(need_unref); |
818 EXPECT_TRUE(task); | 835 EXPECT_TRUE(task); |
819 | 836 |
820 task->RunOnWorkerThread(); | 837 TestTileTaskRunner::ProcessTask(task.get()); |
821 | |
822 task->OnTaskCompleted(); | |
823 | 838 |
824 DecodedDrawImage decoded_draw_image = | 839 DecodedDrawImage decoded_draw_image = |
825 controller.GetDecodedImageForDraw(draw_image); | 840 controller.GetDecodedImageForDraw(draw_image); |
826 EXPECT_TRUE(decoded_draw_image.image()); | 841 EXPECT_TRUE(decoded_draw_image.image()); |
827 EXPECT_EQ(40, decoded_draw_image.image()->width()); | 842 EXPECT_EQ(40, decoded_draw_image.image()->width()); |
828 EXPECT_EQ(35, decoded_draw_image.image()->height()); | 843 EXPECT_EQ(35, decoded_draw_image.image()->height()); |
829 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 844 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
830 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 845 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
831 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 846 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
832 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 847 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
912 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 927 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
913 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 928 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
914 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 929 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
915 | 930 |
916 scoped_refptr<TileTask> task; | 931 scoped_refptr<TileTask> task; |
917 bool need_unref = controller.GetTaskForImageAndRef( | 932 bool need_unref = controller.GetTaskForImageAndRef( |
918 draw_image, ImageDecodeController::TracingInfo(), &task); | 933 draw_image, ImageDecodeController::TracingInfo(), &task); |
919 EXPECT_TRUE(need_unref); | 934 EXPECT_TRUE(need_unref); |
920 EXPECT_TRUE(task); | 935 EXPECT_TRUE(task); |
921 | 936 |
922 task->RunOnWorkerThread(); | 937 TestTileTaskRunner::ProcessTask(task.get()); |
923 | |
924 task->OnTaskCompleted(); | |
925 | 938 |
926 DecodedDrawImage another_decoded_draw_image = | 939 DecodedDrawImage another_decoded_draw_image = |
927 controller.GetDecodedImageForDraw(draw_image); | 940 controller.GetDecodedImageForDraw(draw_image); |
928 // This should get the new decoded/locked image, not the one we're using at | 941 // This should get the new decoded/locked image, not the one we're using at |
929 // raster. | 942 // raster. |
930 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves | 943 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves |
931 // the image to the right spot. | 944 // the image to the right spot. |
932 EXPECT_NE(decoded_draw_image.image()->uniqueID(), | 945 EXPECT_NE(decoded_draw_image.image()->uniqueID(), |
933 another_decoded_draw_image.image()->uniqueID()); | 946 another_decoded_draw_image.image()->uniqueID()); |
934 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); | 947 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); |
(...skipping 28 matching lines...) Expand all Loading... |
963 scoped_refptr<TileTask> task; | 976 scoped_refptr<TileTask> task; |
964 bool need_unref = controller.GetTaskForImageAndRef( | 977 bool need_unref = controller.GetTaskForImageAndRef( |
965 draw_image, ImageDecodeController::TracingInfo(), &task); | 978 draw_image, ImageDecodeController::TracingInfo(), &task); |
966 EXPECT_TRUE(need_unref); | 979 EXPECT_TRUE(need_unref); |
967 EXPECT_TRUE(task); | 980 EXPECT_TRUE(task); |
968 | 981 |
969 // If we finish the draw here, then we will use it for the locked decode | 982 // If we finish the draw here, then we will use it for the locked decode |
970 // instead of decoding again. | 983 // instead of decoding again. |
971 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 984 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
972 | 985 |
973 task->RunOnWorkerThread(); | 986 TestTileTaskRunner::ProcessTask(task.get()); |
974 | |
975 task->OnTaskCompleted(); | |
976 | 987 |
977 DecodedDrawImage another_decoded_draw_image = | 988 DecodedDrawImage another_decoded_draw_image = |
978 controller.GetDecodedImageForDraw(draw_image); | 989 controller.GetDecodedImageForDraw(draw_image); |
979 // This should get the decoded/locked image which we originally decoded at | 990 // This should get the decoded/locked image which we originally decoded at |
980 // raster time, since it's now in the locked cache. | 991 // raster time, since it's now in the locked cache. |
981 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | 992 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
982 another_decoded_draw_image.image()->uniqueID()); | 993 another_decoded_draw_image.image()->uniqueID()); |
983 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); | 994 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); |
984 | 995 |
985 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 996 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1041 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1052 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1042 quality, | 1053 quality, |
1043 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 1054 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
1044 | 1055 |
1045 scoped_refptr<TileTask> task; | 1056 scoped_refptr<TileTask> task; |
1046 bool need_unref = controller.GetTaskForImageAndRef( | 1057 bool need_unref = controller.GetTaskForImageAndRef( |
1047 draw_image, ImageDecodeController::TracingInfo(), &task); | 1058 draw_image, ImageDecodeController::TracingInfo(), &task); |
1048 EXPECT_TRUE(task); | 1059 EXPECT_TRUE(task); |
1049 EXPECT_TRUE(need_unref); | 1060 EXPECT_TRUE(need_unref); |
1050 | 1061 |
| 1062 TestTileTaskRunner::ProcessTask(task.get()); |
| 1063 |
1051 DecodedDrawImage decoded_draw_image = | 1064 DecodedDrawImage decoded_draw_image = |
1052 controller.GetDecodedImageForDraw(draw_image); | 1065 controller.GetDecodedImageForDraw(draw_image); |
1053 EXPECT_TRUE(decoded_draw_image.image()); | 1066 EXPECT_TRUE(decoded_draw_image.image()); |
1054 // If we decoded the image and cached it, it would be stored in a different | 1067 // If we decoded the image and cached it, it would be stored in a different |
1055 // SkImage object. | 1068 // SkImage object. |
1056 EXPECT_TRUE(decoded_draw_image.image() != image); | 1069 EXPECT_TRUE(decoded_draw_image.image() != image); |
1057 | 1070 |
1058 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1071 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
1059 controller.UnrefImage(draw_image); | 1072 controller.UnrefImage(draw_image); |
1060 } | 1073 } |
1061 | 1074 |
1062 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { | 1075 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { |
1063 TestSoftwareImageDecodeController controller; | 1076 TestSoftwareImageDecodeController controller; |
1064 bool is_decomposable = true; | 1077 bool is_decomposable = true; |
1065 SkFilterQuality quality = kLow_SkFilterQuality; | 1078 SkFilterQuality quality = kLow_SkFilterQuality; |
1066 | 1079 |
1067 sk_sp<SkImage> image = CreateImage(100, 100); | 1080 sk_sp<SkImage> image = CreateImage(100, 100); |
1068 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1081 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
1069 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1082 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1070 | 1083 |
1071 scoped_refptr<TileTask> task; | 1084 scoped_refptr<TileTask> task; |
1072 bool need_unref = controller.GetTaskForImageAndRef( | 1085 bool need_unref = controller.GetTaskForImageAndRef( |
1073 draw_image, ImageDecodeController::TracingInfo(), &task); | 1086 draw_image, ImageDecodeController::TracingInfo(), &task); |
1074 EXPECT_TRUE(task); | 1087 EXPECT_TRUE(task); |
1075 EXPECT_TRUE(need_unref); | 1088 EXPECT_TRUE(need_unref); |
1076 | 1089 |
| 1090 TestTileTaskRunner::ProcessTask(task.get()); |
| 1091 |
1077 DecodedDrawImage decoded_draw_image = | 1092 DecodedDrawImage decoded_draw_image = |
1078 controller.GetDecodedImageForDraw(draw_image); | 1093 controller.GetDecodedImageForDraw(draw_image); |
1079 EXPECT_TRUE(decoded_draw_image.image()); | 1094 EXPECT_TRUE(decoded_draw_image.image()); |
1080 // If we decoded the image and cached it, it would be stored in a different | 1095 // If we decoded the image and cached it, it would be stored in a different |
1081 // SkImage object. | 1096 // SkImage object. |
1082 EXPECT_TRUE(decoded_draw_image.image() != image); | 1097 EXPECT_TRUE(decoded_draw_image.image() != image); |
1083 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1098 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1084 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1099 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
1085 | 1100 |
1086 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1101 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
1087 controller.UnrefImage(draw_image); | 1102 controller.UnrefImage(draw_image); |
1088 } | 1103 } |
1089 | 1104 |
1090 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { | 1105 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { |
1091 TestSoftwareImageDecodeController controller; | 1106 TestSoftwareImageDecodeController controller; |
1092 bool is_decomposable = true; | 1107 bool is_decomposable = true; |
1093 SkFilterQuality quality = kNone_SkFilterQuality; | 1108 SkFilterQuality quality = kNone_SkFilterQuality; |
1094 | 1109 |
1095 sk_sp<SkImage> image = CreateImage(100, 100); | 1110 sk_sp<SkImage> image = CreateImage(100, 100); |
1096 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1111 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
1097 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1112 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1098 | 1113 |
1099 scoped_refptr<TileTask> task; | 1114 scoped_refptr<TileTask> task; |
1100 bool need_unref = controller.GetTaskForImageAndRef( | 1115 bool need_unref = controller.GetTaskForImageAndRef( |
1101 draw_image, ImageDecodeController::TracingInfo(), &task); | 1116 draw_image, ImageDecodeController::TracingInfo(), &task); |
1102 EXPECT_TRUE(task); | 1117 EXPECT_TRUE(task); |
1103 EXPECT_TRUE(need_unref); | 1118 EXPECT_TRUE(need_unref); |
1104 | 1119 |
| 1120 TestTileTaskRunner::ProcessTask(task.get()); |
| 1121 |
1105 DecodedDrawImage decoded_draw_image = | 1122 DecodedDrawImage decoded_draw_image = |
1106 controller.GetDecodedImageForDraw(draw_image); | 1123 controller.GetDecodedImageForDraw(draw_image); |
1107 EXPECT_TRUE(decoded_draw_image.image()); | 1124 EXPECT_TRUE(decoded_draw_image.image()); |
1108 // If we decoded the image and cached it, it would be stored in a different | 1125 // If we decoded the image and cached it, it would be stored in a different |
1109 // SkImage object. | 1126 // SkImage object. |
1110 EXPECT_TRUE(decoded_draw_image.image() != image); | 1127 EXPECT_TRUE(decoded_draw_image.image() != image); |
1111 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); | 1128 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); |
1112 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1129 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
1113 | 1130 |
1114 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1131 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
1115 controller.UnrefImage(draw_image); | 1132 controller.UnrefImage(draw_image); |
1116 } | 1133 } |
1117 | 1134 |
1118 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) { | 1135 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) { |
1119 TestSoftwareImageDecodeController controller; | 1136 TestSoftwareImageDecodeController controller; |
1120 bool is_decomposable = true; | 1137 bool is_decomposable = true; |
1121 SkFilterQuality quality = kMedium_SkFilterQuality; | 1138 SkFilterQuality quality = kMedium_SkFilterQuality; |
1122 | 1139 |
1123 sk_sp<SkImage> image = CreateImage(500, 200); | 1140 sk_sp<SkImage> image = CreateImage(500, 200); |
1124 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1141 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1125 quality, | 1142 quality, |
1126 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | 1143 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
1127 | 1144 |
1128 scoped_refptr<TileTask> task; | 1145 scoped_refptr<TileTask> task; |
1129 bool need_unref = controller.GetTaskForImageAndRef( | 1146 bool need_unref = controller.GetTaskForImageAndRef( |
1130 draw_image, ImageDecodeController::TracingInfo(), &task); | 1147 draw_image, ImageDecodeController::TracingInfo(), &task); |
1131 EXPECT_TRUE(task); | 1148 EXPECT_TRUE(task); |
1132 EXPECT_TRUE(need_unref); | 1149 EXPECT_TRUE(need_unref); |
1133 | 1150 |
| 1151 TestTileTaskRunner::ProcessTask(task.get()); |
| 1152 |
1134 DecodedDrawImage decoded_draw_image = | 1153 DecodedDrawImage decoded_draw_image = |
1135 controller.GetDecodedImageForDraw(draw_image); | 1154 controller.GetDecodedImageForDraw(draw_image); |
1136 EXPECT_TRUE(decoded_draw_image.image()); | 1155 EXPECT_TRUE(decoded_draw_image.image()); |
1137 // If we decoded the image and cached it, it would be stored in a different | 1156 // If we decoded the image and cached it, it would be stored in a different |
1138 // SkImageObject. | 1157 // SkImageObject. |
1139 EXPECT_TRUE(decoded_draw_image.image() != image); | 1158 EXPECT_TRUE(decoded_draw_image.image() != image); |
1140 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1159 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1141 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1160 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1142 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1161 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1143 | 1162 |
(...skipping 10 matching lines...) Expand all Loading... |
1154 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1173 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1155 quality, | 1174 quality, |
1156 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 1175 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
1157 | 1176 |
1158 scoped_refptr<TileTask> task; | 1177 scoped_refptr<TileTask> task; |
1159 bool need_unref = controller.GetTaskForImageAndRef( | 1178 bool need_unref = controller.GetTaskForImageAndRef( |
1160 draw_image, ImageDecodeController::TracingInfo(), &task); | 1179 draw_image, ImageDecodeController::TracingInfo(), &task); |
1161 EXPECT_TRUE(task); | 1180 EXPECT_TRUE(task); |
1162 EXPECT_TRUE(need_unref); | 1181 EXPECT_TRUE(need_unref); |
1163 | 1182 |
| 1183 TestTileTaskRunner::ProcessTask(task.get()); |
| 1184 |
1164 DecodedDrawImage decoded_draw_image = | 1185 DecodedDrawImage decoded_draw_image = |
1165 controller.GetDecodedImageForDraw(draw_image); | 1186 controller.GetDecodedImageForDraw(draw_image); |
1166 EXPECT_TRUE(decoded_draw_image.image()); | 1187 EXPECT_TRUE(decoded_draw_image.image()); |
1167 // If we decoded the image and cached it, it would be stored in a different | 1188 // If we decoded the image and cached it, it would be stored in a different |
1168 // SkImageObject. | 1189 // SkImageObject. |
1169 EXPECT_TRUE(decoded_draw_image.image() != image); | 1190 EXPECT_TRUE(decoded_draw_image.image() != image); |
1170 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1191 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1171 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1192 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1172 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1193 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1173 | 1194 |
(...skipping 10 matching lines...) Expand all Loading... |
1184 DrawImage draw_image( | 1205 DrawImage draw_image( |
1185 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1206 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1186 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable)); | 1207 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable)); |
1187 | 1208 |
1188 scoped_refptr<TileTask> task; | 1209 scoped_refptr<TileTask> task; |
1189 bool need_unref = controller.GetTaskForImageAndRef( | 1210 bool need_unref = controller.GetTaskForImageAndRef( |
1190 draw_image, ImageDecodeController::TracingInfo(), &task); | 1211 draw_image, ImageDecodeController::TracingInfo(), &task); |
1191 EXPECT_TRUE(task); | 1212 EXPECT_TRUE(task); |
1192 EXPECT_TRUE(need_unref); | 1213 EXPECT_TRUE(need_unref); |
1193 | 1214 |
| 1215 TestTileTaskRunner::ProcessTask(task.get()); |
| 1216 |
1194 DecodedDrawImage decoded_draw_image = | 1217 DecodedDrawImage decoded_draw_image = |
1195 controller.GetDecodedImageForDraw(draw_image); | 1218 controller.GetDecodedImageForDraw(draw_image); |
1196 EXPECT_TRUE(decoded_draw_image.image()); | 1219 EXPECT_TRUE(decoded_draw_image.image()); |
1197 // If we decoded the image and cached it, it would be stored in a different | 1220 // If we decoded the image and cached it, it would be stored in a different |
1198 // SkImageObject. | 1221 // SkImageObject. |
1199 EXPECT_TRUE(decoded_draw_image.image() != image); | 1222 EXPECT_TRUE(decoded_draw_image.image() != image); |
1200 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1223 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1201 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1224 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1202 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1225 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1203 | 1226 |
(...skipping 10 matching lines...) Expand all Loading... |
1214 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1237 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1215 quality, | 1238 quality, |
1216 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1239 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1217 | 1240 |
1218 scoped_refptr<TileTask> task; | 1241 scoped_refptr<TileTask> task; |
1219 bool need_unref = controller.GetTaskForImageAndRef( | 1242 bool need_unref = controller.GetTaskForImageAndRef( |
1220 draw_image, ImageDecodeController::TracingInfo(), &task); | 1243 draw_image, ImageDecodeController::TracingInfo(), &task); |
1221 EXPECT_TRUE(task); | 1244 EXPECT_TRUE(task); |
1222 EXPECT_TRUE(need_unref); | 1245 EXPECT_TRUE(need_unref); |
1223 | 1246 |
| 1247 TestTileTaskRunner::ProcessTask(task.get()); |
| 1248 |
1224 DecodedDrawImage decoded_draw_image = | 1249 DecodedDrawImage decoded_draw_image = |
1225 controller.GetDecodedImageForDraw(draw_image); | 1250 controller.GetDecodedImageForDraw(draw_image); |
1226 EXPECT_TRUE(decoded_draw_image.image()); | 1251 EXPECT_TRUE(decoded_draw_image.image()); |
1227 // If we decoded the image and cached it, it would be stored in a different | 1252 // If we decoded the image and cached it, it would be stored in a different |
1228 // SkImageObject. | 1253 // SkImageObject. |
1229 EXPECT_TRUE(decoded_draw_image.image() != image); | 1254 EXPECT_TRUE(decoded_draw_image.image() != image); |
1230 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1255 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1231 EXPECT_EQ(250, decoded_draw_image.image()->width()); | 1256 EXPECT_EQ(250, decoded_draw_image.image()->width()); |
1232 EXPECT_EQ(100, decoded_draw_image.image()->height()); | 1257 EXPECT_EQ(100, decoded_draw_image.image()->height()); |
1233 | 1258 |
(...skipping 10 matching lines...) Expand all Loading... |
1244 DrawImage draw_image( | 1269 DrawImage draw_image( |
1245 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1270 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1246 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); | 1271 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); |
1247 | 1272 |
1248 scoped_refptr<TileTask> task; | 1273 scoped_refptr<TileTask> task; |
1249 bool need_unref = controller.GetTaskForImageAndRef( | 1274 bool need_unref = controller.GetTaskForImageAndRef( |
1250 draw_image, ImageDecodeController::TracingInfo(), &task); | 1275 draw_image, ImageDecodeController::TracingInfo(), &task); |
1251 EXPECT_TRUE(task); | 1276 EXPECT_TRUE(task); |
1252 EXPECT_TRUE(need_unref); | 1277 EXPECT_TRUE(need_unref); |
1253 | 1278 |
| 1279 TestTileTaskRunner::ProcessTask(task.get()); |
| 1280 |
1254 DecodedDrawImage decoded_draw_image = | 1281 DecodedDrawImage decoded_draw_image = |
1255 controller.GetDecodedImageForDraw(draw_image); | 1282 controller.GetDecodedImageForDraw(draw_image); |
1256 EXPECT_TRUE(decoded_draw_image.image()); | 1283 EXPECT_TRUE(decoded_draw_image.image()); |
1257 // If we decoded the image and cached it, it would be stored in a different | 1284 // If we decoded the image and cached it, it would be stored in a different |
1258 // SkImageObject. | 1285 // SkImageObject. |
1259 EXPECT_TRUE(decoded_draw_image.image() != image); | 1286 EXPECT_TRUE(decoded_draw_image.image() != image); |
1260 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1287 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1261 EXPECT_EQ(250, decoded_draw_image.image()->width()); | 1288 EXPECT_EQ(250, decoded_draw_image.image()->width()); |
1262 EXPECT_EQ(100, decoded_draw_image.image()->height()); | 1289 EXPECT_EQ(100, decoded_draw_image.image()->height()); |
1263 | 1290 |
(...skipping 10 matching lines...) Expand all Loading... |
1274 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1301 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1275 quality, | 1302 quality, |
1276 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable)); | 1303 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable)); |
1277 | 1304 |
1278 scoped_refptr<TileTask> task; | 1305 scoped_refptr<TileTask> task; |
1279 bool need_unref = controller.GetTaskForImageAndRef( | 1306 bool need_unref = controller.GetTaskForImageAndRef( |
1280 draw_image, ImageDecodeController::TracingInfo(), &task); | 1307 draw_image, ImageDecodeController::TracingInfo(), &task); |
1281 EXPECT_TRUE(task); | 1308 EXPECT_TRUE(task); |
1282 EXPECT_TRUE(need_unref); | 1309 EXPECT_TRUE(need_unref); |
1283 | 1310 |
| 1311 TestTileTaskRunner::ProcessTask(task.get()); |
| 1312 |
1284 DecodedDrawImage decoded_draw_image = | 1313 DecodedDrawImage decoded_draw_image = |
1285 controller.GetDecodedImageForDraw(draw_image); | 1314 controller.GetDecodedImageForDraw(draw_image); |
1286 EXPECT_TRUE(decoded_draw_image.image()); | 1315 EXPECT_TRUE(decoded_draw_image.image()); |
1287 // If we decoded the image and cached it, it would be stored in a different | 1316 // If we decoded the image and cached it, it would be stored in a different |
1288 // SkImageObject. | 1317 // SkImageObject. |
1289 EXPECT_TRUE(decoded_draw_image.image() != image); | 1318 EXPECT_TRUE(decoded_draw_image.image() != image); |
1290 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1319 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1291 EXPECT_EQ(62, decoded_draw_image.image()->width()); | 1320 EXPECT_EQ(62, decoded_draw_image.image()->width()); |
1292 EXPECT_EQ(25, decoded_draw_image.image()->height()); | 1321 EXPECT_EQ(25, decoded_draw_image.image()->height()); |
1293 | 1322 |
(...skipping 10 matching lines...) Expand all Loading... |
1304 DrawImage draw_image( | 1333 DrawImage draw_image( |
1305 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1334 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1306 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable)); | 1335 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable)); |
1307 | 1336 |
1308 scoped_refptr<TileTask> task; | 1337 scoped_refptr<TileTask> task; |
1309 bool need_unref = controller.GetTaskForImageAndRef( | 1338 bool need_unref = controller.GetTaskForImageAndRef( |
1310 draw_image, ImageDecodeController::TracingInfo(), &task); | 1339 draw_image, ImageDecodeController::TracingInfo(), &task); |
1311 EXPECT_TRUE(task); | 1340 EXPECT_TRUE(task); |
1312 EXPECT_TRUE(need_unref); | 1341 EXPECT_TRUE(need_unref); |
1313 | 1342 |
| 1343 TestTileTaskRunner::ProcessTask(task.get()); |
| 1344 |
1314 DecodedDrawImage decoded_draw_image = | 1345 DecodedDrawImage decoded_draw_image = |
1315 controller.GetDecodedImageForDraw(draw_image); | 1346 controller.GetDecodedImageForDraw(draw_image); |
1316 EXPECT_TRUE(decoded_draw_image.image()); | 1347 EXPECT_TRUE(decoded_draw_image.image()); |
1317 // If we decoded the image and cached it, it would be stored in a different | 1348 // If we decoded the image and cached it, it would be stored in a different |
1318 // SkImageObject. | 1349 // SkImageObject. |
1319 EXPECT_TRUE(decoded_draw_image.image() != image); | 1350 EXPECT_TRUE(decoded_draw_image.image() != image); |
1320 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1351 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1321 EXPECT_EQ(7, decoded_draw_image.image()->width()); | 1352 EXPECT_EQ(7, decoded_draw_image.image()->width()); |
1322 EXPECT_EQ(3, decoded_draw_image.image()->height()); | 1353 EXPECT_EQ(3, decoded_draw_image.image()->height()); |
1323 | 1354 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1366 bool need_unref_50 = controller.GetTaskForImageAndRef( | 1397 bool need_unref_50 = controller.GetTaskForImageAndRef( |
1367 draw_image_50, ImageDecodeController::TracingInfo(), &task_50); | 1398 draw_image_50, ImageDecodeController::TracingInfo(), &task_50); |
1368 EXPECT_TRUE(task_50); | 1399 EXPECT_TRUE(task_50); |
1369 EXPECT_TRUE(need_unref_50); | 1400 EXPECT_TRUE(need_unref_50); |
1370 scoped_refptr<TileTask> task_49; | 1401 scoped_refptr<TileTask> task_49; |
1371 bool need_unref_49 = controller.GetTaskForImageAndRef( | 1402 bool need_unref_49 = controller.GetTaskForImageAndRef( |
1372 draw_image_49, ImageDecodeController::TracingInfo(), &task_49); | 1403 draw_image_49, ImageDecodeController::TracingInfo(), &task_49); |
1373 EXPECT_TRUE(task_49); | 1404 EXPECT_TRUE(task_49); |
1374 EXPECT_TRUE(need_unref_49); | 1405 EXPECT_TRUE(need_unref_49); |
1375 | 1406 |
| 1407 TestTileTaskRunner::ProcessTask(task_49.get()); |
| 1408 |
1376 DecodedDrawImage decoded_draw_image_50 = | 1409 DecodedDrawImage decoded_draw_image_50 = |
1377 controller.GetDecodedImageForDraw(draw_image_50); | 1410 controller.GetDecodedImageForDraw(draw_image_50); |
1378 EXPECT_TRUE(decoded_draw_image_50.image()); | 1411 EXPECT_TRUE(decoded_draw_image_50.image()); |
1379 DecodedDrawImage decoded_draw_image_49 = | 1412 DecodedDrawImage decoded_draw_image_49 = |
1380 controller.GetDecodedImageForDraw(draw_image_49); | 1413 controller.GetDecodedImageForDraw(draw_image_49); |
1381 EXPECT_TRUE(decoded_draw_image_49.image()); | 1414 EXPECT_TRUE(decoded_draw_image_49.image()); |
1382 // If we decoded the image and cached it, it would be stored in a different | 1415 // If we decoded the image and cached it, it would be stored in a different |
1383 // SkImageObject. | 1416 // SkImageObject. |
1384 EXPECT_TRUE(decoded_draw_image_50.image() != image); | 1417 EXPECT_TRUE(decoded_draw_image_50.image() != image); |
1385 EXPECT_TRUE(decoded_draw_image_49.image() != image); | 1418 EXPECT_TRUE(decoded_draw_image_49.image() != image); |
1386 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_50.filter_quality()); | 1419 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_50.filter_quality()); |
1387 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_49.filter_quality()); | 1420 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_49.filter_quality()); |
1388 EXPECT_EQ(250, decoded_draw_image_50.image()->width()); | 1421 EXPECT_EQ(250, decoded_draw_image_50.image()->width()); |
1389 EXPECT_EQ(250, decoded_draw_image_49.image()->width()); | 1422 EXPECT_EQ(250, decoded_draw_image_49.image()->width()); |
1390 EXPECT_EQ(100, decoded_draw_image_50.image()->height()); | 1423 EXPECT_EQ(100, decoded_draw_image_50.image()->height()); |
1391 EXPECT_EQ(100, decoded_draw_image_49.image()->height()); | 1424 EXPECT_EQ(100, decoded_draw_image_49.image()->height()); |
1392 | 1425 |
1393 EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image()); | 1426 EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image()); |
1394 | 1427 |
1395 controller.DrawWithImageFinished(draw_image_50, decoded_draw_image_50); | 1428 controller.DrawWithImageFinished(draw_image_50, decoded_draw_image_50); |
1396 controller.UnrefImage(draw_image_50); | 1429 controller.UnrefImage(draw_image_50); |
1397 controller.DrawWithImageFinished(draw_image_49, decoded_draw_image_49); | 1430 controller.DrawWithImageFinished(draw_image_49, decoded_draw_image_49); |
1398 controller.UnrefImage(draw_image_49); | 1431 controller.UnrefImage(draw_image_49); |
1399 } | 1432 } |
1400 | 1433 |
1401 } // namespace | 1434 } // namespace |
1402 } // namespace cc | 1435 } // namespace cc |
OLD | NEW |