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_cache.h" | 5 #include "cc/tiles/software_image_decode_cache.h" |
6 | 6 |
7 #include "cc/paint/draw_image.h" | 7 #include "cc/paint/draw_image.h" |
8 #include "cc/resources/resource_format.h" | 8 #include "cc/resources/resource_format.h" |
9 #include "cc/test/test_tile_task_runner.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" |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
49 | 49 |
50 return matrix; | 50 return matrix; |
51 } | 51 } |
52 | 52 |
53 PaintImage::Id s_paint_image_id = PaintImage::GetNextId(); | 53 PaintImage::Id s_paint_image_id = PaintImage::GetNextId(); |
54 | 54 |
55 PaintImage CreatePaintImage(sk_sp<SkImage> image) { | 55 PaintImage CreatePaintImage(sk_sp<SkImage> image) { |
56 return PaintImage(s_paint_image_id, image); | 56 return PaintImage(s_paint_image_id, image); |
57 } | 57 } |
58 | 58 |
59 TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQuality) { | 59 TEST(SoftwareImageDecodeCacheTest, ImageKeyNoneQuality) { |
60 sk_sp<SkImage> image = CreateImage(100, 100); | 60 sk_sp<SkImage> image = CreateImage(100, 100); |
61 bool is_decomposable = true; | 61 bool is_decomposable = true; |
62 SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality}; | 62 DrawImage draw_image(CreatePaintImage(image), |
63 for (auto quality : qualities) { | 63 SkIRect::MakeWH(image->width(), image->height()), |
64 DrawImage draw_image( | 64 kNone_SkFilterQuality, |
65 CreatePaintImage(image), | 65 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
66 SkIRect::MakeWH(image->width(), image->height()), quality, | 66 DefaultColorSpace()); |
67 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | |
68 DefaultColorSpace()); | |
69 | 67 |
70 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 68 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
71 EXPECT_EQ(image->uniqueID(), key.image_id()); | 69 EXPECT_EQ(image->uniqueID(), key.image_id()); |
72 EXPECT_EQ(quality, key.filter_quality()); | 70 EXPECT_EQ(kNone_SkFilterQuality, key.filter_quality()); |
73 EXPECT_EQ(100, key.target_size().width()); | 71 EXPECT_EQ(100, key.target_size().width()); |
74 EXPECT_EQ(100, key.target_size().height()); | 72 EXPECT_EQ(100, key.target_size().height()); |
75 EXPECT_TRUE(key.can_use_original_size_decode()); | 73 EXPECT_TRUE(key.can_use_original_size_decode()); |
76 // Since the original decode will be used, the locked_bytes is that of the | 74 // Since the original decode will be used, the locked_bytes is that of the |
77 // original image. | 75 // original image. |
78 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 76 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
79 } | 77 } |
| 78 |
| 79 TEST(SoftwareImageDecodeCacheTest, |
| 80 ImageKeyLowQualityIncreasedToMediumIfDownscale) { |
| 81 sk_sp<SkImage> image = CreateImage(100, 100); |
| 82 bool is_decomposable = true; |
| 83 DrawImage draw_image(CreatePaintImage(image), |
| 84 SkIRect::MakeWH(image->width(), image->height()), |
| 85 kLow_SkFilterQuality, |
| 86 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
| 87 DefaultColorSpace()); |
| 88 |
| 89 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
| 90 EXPECT_EQ(image->uniqueID(), key.image_id()); |
| 91 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
| 92 EXPECT_EQ(100, key.target_size().width()); |
| 93 EXPECT_EQ(100, key.target_size().height()); |
| 94 EXPECT_FALSE(key.can_use_original_size_decode()); |
| 95 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
| 96 } |
| 97 |
| 98 TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQualityKeptLowIfUpscale) { |
| 99 sk_sp<SkImage> image = CreateImage(100, 100); |
| 100 bool is_decomposable = true; |
| 101 DrawImage draw_image(CreatePaintImage(image), |
| 102 SkIRect::MakeWH(image->width(), image->height()), |
| 103 kLow_SkFilterQuality, |
| 104 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
| 105 DefaultColorSpace()); |
| 106 |
| 107 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
| 108 EXPECT_EQ(image->uniqueID(), key.image_id()); |
| 109 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
| 110 EXPECT_EQ(100, key.target_size().width()); |
| 111 EXPECT_EQ(100, key.target_size().height()); |
| 112 EXPECT_TRUE(key.can_use_original_size_decode()); |
| 113 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
80 } | 114 } |
81 | 115 |
82 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) { | 116 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) { |
83 sk_sp<SkImage> image = CreateImage(100, 100); | 117 sk_sp<SkImage> image = CreateImage(100, 100); |
84 bool is_decomposable = true; | 118 bool is_decomposable = true; |
85 SkFilterQuality quality = kMedium_SkFilterQuality; | 119 SkFilterQuality quality = kMedium_SkFilterQuality; |
86 | 120 |
87 DrawImage draw_image( | 121 DrawImage draw_image( |
88 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), | 122 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
89 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | 123 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
(...skipping 395 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
485 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 519 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
486 EXPECT_EQ(100, key.target_size().width()); | 520 EXPECT_EQ(100, key.target_size().width()); |
487 EXPECT_EQ(100, key.target_size().height()); | 521 EXPECT_EQ(100, key.target_size().height()); |
488 EXPECT_TRUE(key.can_use_original_size_decode()); | 522 EXPECT_TRUE(key.can_use_original_size_decode()); |
489 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 523 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
490 } | 524 } |
491 | 525 |
492 TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) { | 526 TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) { |
493 sk_sp<SkImage> image = CreateImage(100, 100); | 527 sk_sp<SkImage> image = CreateImage(100, 100); |
494 bool is_decomposable = true; | 528 bool is_decomposable = true; |
495 SkFilterQuality quality = kLow_SkFilterQuality; | 529 SkFilterQuality quality = kNone_SkFilterQuality; |
496 | 530 |
497 DrawImage draw_image( | 531 DrawImage draw_image( |
498 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), | 532 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
499 quality, CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable), | 533 quality, CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable), |
500 DefaultColorSpace()); | 534 DefaultColorSpace()); |
501 | 535 |
502 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 536 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
503 EXPECT_EQ(image->uniqueID(), key.image_id()); | 537 EXPECT_EQ(image->uniqueID(), key.image_id()); |
504 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 538 EXPECT_EQ(kNone_SkFilterQuality, key.filter_quality()); |
505 EXPECT_EQ(100, key.target_size().width()); | 539 EXPECT_EQ(100, key.target_size().width()); |
506 EXPECT_EQ(100, key.target_size().height()); | 540 EXPECT_EQ(100, key.target_size().height()); |
507 EXPECT_TRUE(key.can_use_original_size_decode()); | 541 EXPECT_TRUE(key.can_use_original_size_decode()); |
508 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 542 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
509 | 543 |
510 DrawImage another_draw_image( | 544 DrawImage another_draw_image( |
511 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), | 545 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
512 quality, CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable), | 546 quality, CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable), |
513 DefaultColorSpace()); | 547 DefaultColorSpace()); |
514 | 548 |
515 auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image); | 549 auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image); |
516 EXPECT_EQ(image->uniqueID(), another_key.image_id()); | 550 EXPECT_EQ(image->uniqueID(), another_key.image_id()); |
517 EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality()); | 551 EXPECT_EQ(kNone_SkFilterQuality, another_key.filter_quality()); |
518 EXPECT_EQ(100, another_key.target_size().width()); | 552 EXPECT_EQ(100, another_key.target_size().width()); |
519 EXPECT_EQ(100, another_key.target_size().height()); | 553 EXPECT_EQ(100, another_key.target_size().height()); |
520 EXPECT_TRUE(another_key.can_use_original_size_decode()); | 554 EXPECT_TRUE(another_key.can_use_original_size_decode()); |
521 EXPECT_EQ(100u * 100u * 4u, another_key.locked_bytes()); | 555 EXPECT_EQ(100u * 100u * 4u, another_key.locked_bytes()); |
522 | 556 |
523 EXPECT_TRUE(key == another_key); | 557 EXPECT_TRUE(key == another_key); |
524 } | 558 } |
525 | 559 |
526 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) { | 560 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) { |
527 sk_sp<SkImage> image = CreateImage(100, 100); | 561 sk_sp<SkImage> image = CreateImage(100, 100); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
605 kHigh_SkFilterQuality, | 639 kHigh_SkFilterQuality, |
606 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 640 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
607 DefaultColorSpace()); | 641 DefaultColorSpace()); |
608 scoped_refptr<TileTask> high_quality_task; | 642 scoped_refptr<TileTask> high_quality_task; |
609 bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image, | 643 bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image, |
610 ImageDecodeCache::TracingInfo(), | 644 ImageDecodeCache::TracingInfo(), |
611 &high_quality_task); | 645 &high_quality_task); |
612 EXPECT_TRUE(need_unref); | 646 EXPECT_TRUE(need_unref); |
613 EXPECT_TRUE(high_quality_task); | 647 EXPECT_TRUE(high_quality_task); |
614 | 648 |
615 DrawImage low_quality_draw_image( | 649 DrawImage none_quality_draw_image( |
616 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), | 650 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
617 kLow_SkFilterQuality, | 651 kNone_SkFilterQuality, |
618 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 652 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
619 DefaultColorSpace()); | 653 DefaultColorSpace()); |
620 scoped_refptr<TileTask> low_quality_task; | 654 scoped_refptr<TileTask> none_quality_task; |
621 need_unref = cache.GetTaskForImageAndRef(low_quality_draw_image, | 655 need_unref = cache.GetTaskForImageAndRef(none_quality_draw_image, |
622 ImageDecodeCache::TracingInfo(), | 656 ImageDecodeCache::TracingInfo(), |
623 &low_quality_task); | 657 &none_quality_task); |
624 EXPECT_TRUE(need_unref); | 658 EXPECT_TRUE(need_unref); |
625 EXPECT_TRUE(low_quality_task); | 659 EXPECT_TRUE(none_quality_task); |
626 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); | 660 EXPECT_TRUE(high_quality_task.get() != none_quality_task.get()); |
627 | 661 |
628 TestTileTaskRunner::ProcessTask(high_quality_task.get()); | 662 TestTileTaskRunner::ProcessTask(high_quality_task.get()); |
629 TestTileTaskRunner::ProcessTask(low_quality_task.get()); | 663 TestTileTaskRunner::ProcessTask(none_quality_task.get()); |
630 | 664 |
631 cache.UnrefImage(high_quality_draw_image); | 665 cache.UnrefImage(high_quality_draw_image); |
632 cache.UnrefImage(low_quality_draw_image); | 666 cache.UnrefImage(none_quality_draw_image); |
633 } | 667 } |
634 | 668 |
635 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) { | 669 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) { |
636 TestSoftwareImageDecodeCache cache; | 670 TestSoftwareImageDecodeCache cache; |
637 sk_sp<SkImage> image = CreateImage(100, 100); | 671 sk_sp<SkImage> image = CreateImage(100, 100); |
638 bool is_decomposable = true; | 672 bool is_decomposable = true; |
639 SkFilterQuality quality = kHigh_SkFilterQuality; | 673 SkFilterQuality quality = kHigh_SkFilterQuality; |
640 | 674 |
641 DrawImage half_size_draw_image( | 675 DrawImage half_size_draw_image( |
642 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), | 676 CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
(...skipping 593 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1236 | 1270 |
1237 TestTileTaskRunner::ProcessTask(task.get()); | 1271 TestTileTaskRunner::ProcessTask(task.get()); |
1238 | 1272 |
1239 DecodedDrawImage decoded_draw_image = | 1273 DecodedDrawImage decoded_draw_image = |
1240 cache.GetDecodedImageForDraw(draw_image); | 1274 cache.GetDecodedImageForDraw(draw_image); |
1241 EXPECT_TRUE(decoded_draw_image.image()); | 1275 EXPECT_TRUE(decoded_draw_image.image()); |
1242 // If we decoded the image and cached it, it would be stored in a different | 1276 // If we decoded the image and cached it, it would be stored in a different |
1243 // SkImage object. | 1277 // SkImage object. |
1244 EXPECT_TRUE(decoded_draw_image.image() != image); | 1278 EXPECT_TRUE(decoded_draw_image.image() != image); |
1245 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1279 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1246 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1280 // Low quality will be upgraded to medium and mip-mapped. |
| 1281 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
| 1282 EXPECT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
| 1283 EXPECT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
1247 | 1284 |
1248 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1285 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1249 cache.UnrefImage(draw_image); | 1286 cache.UnrefImage(draw_image); |
1250 } | 1287 } |
1251 | 1288 |
1252 TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) { | 1289 TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) { |
1253 TestSoftwareImageDecodeCache cache; | 1290 TestSoftwareImageDecodeCache cache; |
1254 bool is_decomposable = true; | 1291 bool is_decomposable = true; |
1255 SkFilterQuality quality = kNone_SkFilterQuality; | 1292 SkFilterQuality quality = kNone_SkFilterQuality; |
1256 | 1293 |
(...skipping 357 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1614 EXPECT_EQ(10u, cache.GetNumCacheEntriesForTesting()); | 1651 EXPECT_EQ(10u, cache.GetNumCacheEntriesForTesting()); |
1615 | 1652 |
1616 // Tell our cache to clear resources. | 1653 // Tell our cache to clear resources. |
1617 cache.ClearCache(); | 1654 cache.ClearCache(); |
1618 | 1655 |
1619 EXPECT_EQ(0u, cache.GetNumCacheEntriesForTesting()); | 1656 EXPECT_EQ(0u, cache.GetNumCacheEntriesForTesting()); |
1620 } | 1657 } |
1621 | 1658 |
1622 } // namespace | 1659 } // namespace |
1623 } // namespace cc | 1660 } // namespace cc |
OLD | NEW |