Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(223)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/tiles/software_image_decode_cache_unittest.cc

Issue 2541183002: cc: Rename ImageDecodeController to ImageDecodeCache. (Closed)
Patch Set: rename: update Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/tiles/software_image_decode_cache.cc ('k') | cc/tiles/software_image_decode_controller.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/tiles/software_image_decode_cache_unittest.cc
diff --git a/cc/tiles/software_image_decode_controller_unittest.cc b/cc/tiles/software_image_decode_cache_unittest.cc
similarity index 72%
rename from cc/tiles/software_image_decode_controller_unittest.cc
rename to cc/tiles/software_image_decode_cache_unittest.cc
index cb5ef74739800ed93ca8ecefae0f632a41fd4a25..67855fbd19a1abe03d8ee4d44d49c15569771594 100644
--- a/cc/tiles/software_image_decode_controller_unittest.cc
+++ b/cc/tiles/software_image_decode_cache_unittest.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
#include "cc/playback/draw_image.h"
#include "cc/resources/resource_format.h"
@@ -14,11 +14,11 @@ namespace cc {
namespace {
size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024;
-class TestSoftwareImageDecodeController : public SoftwareImageDecodeController {
+class TestSoftwareImageDecodeCache : public SoftwareImageDecodeCache {
public:
- TestSoftwareImageDecodeController()
- : SoftwareImageDecodeController(ResourceFormat::RGBA_8888,
- kLockedMemoryLimitBytes) {}
+ TestSoftwareImageDecodeCache()
+ : SoftwareImageDecodeCache(ResourceFormat::RGBA_8888,
+ kLockedMemoryLimitBytes) {}
};
sk_sp<SkImage> CreateImage(int width, int height) {
@@ -39,7 +39,7 @@ SkMatrix CreateMatrix(const SkSize& scale, bool is_decomposable) {
return matrix;
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyLowQuality) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQuality) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality};
@@ -48,7 +48,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyLowQuality) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -60,7 +60,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyLowQuality) {
}
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQuality) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -69,7 +69,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQuality) {
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -78,8 +78,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQuality) {
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyMediumQualityDropToLowIfEnlarging) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfEnlarging) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -88,7 +87,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -97,8 +96,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyMediumQualityDropToLowIfIdentity) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -107,7 +105,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -116,7 +114,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyMediumQualityDropToLowIfNearlyIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -126,7 +124,7 @@ TEST(SoftwareImageDecodeControllerTest,
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -135,7 +133,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyMediumQualityDropToLowIfNearlyIdentity2) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -145,7 +143,7 @@ TEST(SoftwareImageDecodeControllerTest,
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -154,7 +152,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyMediumQualityDropToLowIfNotDecomposable) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = false;
@@ -164,7 +162,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -173,7 +171,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_5Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_5Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -182,7 +180,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_5Scale) {
quality,
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(500, key.target_size().width());
@@ -191,7 +189,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_5Scale) {
EXPECT_EQ(500u * 200u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_0cale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_0cale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -200,7 +198,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_0cale) {
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(500, key.target_size().width());
@@ -209,7 +207,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_0cale) {
EXPECT_EQ(500u * 200u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_75Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_75Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -218,7 +216,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_75Scale) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(500, key.target_size().width());
@@ -227,7 +225,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_75Scale) {
EXPECT_EQ(500u * 200u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_5Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_5Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -236,7 +234,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_5Scale) {
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(250, key.target_size().width());
@@ -245,7 +243,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_5Scale) {
EXPECT_EQ(250u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_49Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_49Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -254,7 +252,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_49Scale) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(250, key.target_size().width());
@@ -263,7 +261,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_49Scale) {
EXPECT_EQ(250u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_1Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_1Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -272,7 +270,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_1Scale) {
quality,
CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(62, key.target_size().width());
@@ -281,7 +279,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_1Scale) {
EXPECT_EQ(62u * 25u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_01Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_01Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -290,7 +288,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_01Scale) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(7, key.target_size().width());
@@ -299,7 +297,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_01Scale) {
EXPECT_EQ(7u * 3u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyPartialDowscalesDropsHighQualityToMedium) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -309,7 +307,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -318,7 +316,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyFullDowscalesDropsHighQualityToMedium) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -328,7 +326,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(0.5f, 0.2f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(50, key.target_size().width());
@@ -337,7 +335,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(50u * 50u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyDowscalesHighQuality) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyDowscalesHighQuality) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -346,7 +344,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyDowscalesHighQuality) {
quality,
CreateMatrix(SkSize::Make(2.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(250, key.target_size().width());
@@ -355,8 +353,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageKeyDowscalesHighQuality) {
EXPECT_EQ(250u * 150u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyHighQualityDropToMediumIfTooLarge) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToMediumIfTooLarge) {
// Just over 64MB when scaled.
sk_sp<SkImage> image = CreateImage(4555, 2048);
bool is_decomposable = true;
@@ -368,7 +365,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(0.9f, 2.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(4555, key.target_size().width());
@@ -377,7 +374,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(4555u * 2048u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyHighQualityDropToLowIfNotDecomposable) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = false;
@@ -387,7 +384,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -396,8 +393,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyHighQualityDropToLowIfIdentity) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToLowIfIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -406,7 +402,7 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -415,7 +411,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyHighQualityDropToLowIfNearlyIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -425,7 +421,7 @@ TEST(SoftwareImageDecodeControllerTest,
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -434,7 +430,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyHighQualityDropToLowIfNearlyIdentity2) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -444,7 +440,7 @@ TEST(SoftwareImageDecodeControllerTest,
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -453,7 +449,7 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, OriginalDecodesAreEqual) {
+TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -462,7 +458,7 @@ TEST(SoftwareImageDecodeControllerTest, OriginalDecodesAreEqual) {
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -474,8 +470,7 @@ TEST(SoftwareImageDecodeControllerTest, OriginalDecodesAreEqual) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable));
- auto another_key =
- ImageDecodeControllerKey::FromDrawImage(another_draw_image);
+ auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image);
EXPECT_EQ(image->uniqueID(), another_key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality());
EXPECT_EQ(100, another_key.target_size().width());
@@ -486,7 +481,7 @@ TEST(SoftwareImageDecodeControllerTest, OriginalDecodesAreEqual) {
EXPECT_TRUE(key == another_key);
}
-TEST(SoftwareImageDecodeControllerTest, ImageRectDoesNotContainSrcRect) {
+TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -495,7 +490,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageRectDoesNotContainSrcRect) {
image, SkIRect::MakeXYWH(25, 35, image->width(), image->height()),
quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -504,8 +499,7 @@ TEST(SoftwareImageDecodeControllerTest, ImageRectDoesNotContainSrcRect) {
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageRectDoesNotContainSrcRectWithScale) {
+TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRectWithScale) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -514,7 +508,7 @@ TEST(SoftwareImageDecodeControllerTest,
image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()),
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(40, key.target_size().width());
@@ -523,8 +517,8 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(40u * 35u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImage) {
+ TestSoftwareImageDecodeCache cache;
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -533,8 +527,8 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) {
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
@@ -542,20 +536,19 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> another_task;
- need_unref = controller.GetTaskForImageAndRef(
- another_draw_image, ImageDecodeController::TracingInfo(), &another_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ another_draw_image, ImageDecodeCache::TracingInfo(), &another_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task.get() == another_task.get());
TestTileTaskRunner::ProcessTask(task.get());
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
- GetTaskForImageSameImageDifferentQuality) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentQuality) {
+ TestSoftwareImageDecodeCache cache;
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -564,9 +557,9 @@ TEST(SoftwareImageDecodeControllerTest,
kHigh_SkFilterQuality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> high_quality_task;
- bool need_unref = controller.GetTaskForImageAndRef(
- high_quality_draw_image, ImageDecodeController::TracingInfo(),
- &high_quality_task);
+ bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image,
+ ImageDecodeCache::TracingInfo(),
+ &high_quality_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(high_quality_task);
@@ -575,9 +568,9 @@ TEST(SoftwareImageDecodeControllerTest,
kLow_SkFilterQuality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> low_quality_task;
- need_unref = controller.GetTaskForImageAndRef(
- low_quality_draw_image, ImageDecodeController::TracingInfo(),
- &low_quality_task);
+ need_unref = cache.GetTaskForImageAndRef(low_quality_draw_image,
+ ImageDecodeCache::TracingInfo(),
+ &low_quality_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(low_quality_task);
EXPECT_TRUE(high_quality_task.get() != low_quality_task.get());
@@ -585,12 +578,12 @@ TEST(SoftwareImageDecodeControllerTest,
TestTileTaskRunner::ProcessTask(high_quality_task.get());
TestTileTaskRunner::ProcessTask(low_quality_task.get());
- controller.UnrefImage(high_quality_draw_image);
- controller.UnrefImage(low_quality_draw_image);
+ cache.UnrefImage(high_quality_draw_image);
+ cache.UnrefImage(low_quality_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) {
+ TestSoftwareImageDecodeCache cache;
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -599,9 +592,8 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> half_size_task;
- bool need_unref = controller.GetTaskForImageAndRef(
- half_size_draw_image, ImageDecodeController::TracingInfo(),
- &half_size_task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ half_size_draw_image, ImageDecodeCache::TracingInfo(), &half_size_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(half_size_task);
@@ -609,9 +601,9 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable));
scoped_refptr<TileTask> quarter_size_task;
- need_unref = controller.GetTaskForImageAndRef(
- quarter_size_draw_image, ImageDecodeController::TracingInfo(),
- &quarter_size_task);
+ need_unref = cache.GetTaskForImageAndRef(quarter_size_draw_image,
+ ImageDecodeCache::TracingInfo(),
+ &quarter_size_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(quarter_size_task);
EXPECT_TRUE(half_size_task.get() != quarter_size_task.get());
@@ -619,12 +611,12 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
TestTileTaskRunner::ProcessTask(half_size_task.get());
TestTileTaskRunner::ProcessTask(quarter_size_task.get());
- controller.UnrefImage(half_size_draw_image);
- controller.UnrefImage(quarter_size_draw_image);
+ cache.UnrefImage(half_size_draw_image);
+ cache.UnrefImage(quarter_size_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageDifferentImage) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -633,8 +625,8 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) {
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> first_task;
- bool need_unref = controller.GetTaskForImageAndRef(
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(first_task);
@@ -644,8 +636,8 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) {
SkIRect::MakeWH(second_image->width(), second_image->height()), quality,
CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable));
scoped_refptr<TileTask> second_task;
- need_unref = controller.GetTaskForImageAndRef(
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(second_task);
EXPECT_TRUE(first_task.get() != second_task.get());
@@ -653,12 +645,12 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) {
TestTileTaskRunner::ProcessTask(first_task.get());
TestTileTaskRunner::ProcessTask(second_task.get());
- controller.UnrefImage(first_draw_image);
- controller.UnrefImage(second_draw_image);
+ cache.UnrefImage(first_draw_image);
+ cache.UnrefImage(second_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyDecoded) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -667,8 +659,8 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) {
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
@@ -676,19 +668,19 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) {
TestTileTaskRunner::RunTask(task.get());
scoped_refptr<TileTask> another_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &another_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task);
EXPECT_TRUE(need_unref);
EXPECT_FALSE(another_task);
TestTileTaskRunner::CompleteTask(task.get());
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyPrerolled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -697,8 +689,8 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) {
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
@@ -706,26 +698,26 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) {
TestTileTaskRunner::RunTask(task.get());
scoped_refptr<TileTask> another_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &another_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task);
EXPECT_TRUE(need_unref);
EXPECT_FALSE(another_task);
TestTileTaskRunner::CompleteTask(task.get());
scoped_refptr<TileTask> third_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &third_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &third_task);
EXPECT_TRUE(need_unref);
EXPECT_FALSE(third_task);
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -734,14 +726,14 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) {
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
scoped_refptr<TileTask> another_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &another_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(another_task.get() == task.get());
@@ -750,25 +742,25 @@ TEST(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) {
TestTileTaskRunner::CompleteTask(task.get());
// Fully cancel everything (so the raster would unref things).
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
// Here a new task is created.
scoped_refptr<TileTask> third_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &third_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &third_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(third_task);
EXPECT_FALSE(third_task.get() == task.get());
TestTileTaskRunner::ProcessTask(third_task.get());
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetTaskForImageCanceledWhileReffedGetsNewTask) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -777,14 +769,14 @@ TEST(SoftwareImageDecodeControllerTest,
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
scoped_refptr<TileTask> another_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &another_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(another_task.get() == task.get());
@@ -795,8 +787,8 @@ TEST(SoftwareImageDecodeControllerTest,
// Note that here, everything is reffed, but a new task is created. This is
// possible with repeated schedule/cancel operations.
scoped_refptr<TileTask> third_task;
- need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &third_task);
+ need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &third_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(third_task);
EXPECT_FALSE(third_task.get() == task.get());
@@ -804,13 +796,13 @@ TEST(SoftwareImageDecodeControllerTest,
TestTileTaskRunner::ProcessTask(third_task.get());
// 3 Unrefs!
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDraw) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -819,15 +811,15 @@ TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) {
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -837,13 +829,13 @@ TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) {
EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawWithNonContainedSrcRect) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -852,15 +844,15 @@ TEST(SoftwareImageDecodeControllerTest,
image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()),
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(40, decoded_draw_image.image()->width());
EXPECT_EQ(35, decoded_draw_image.image()->height());
@@ -870,12 +862,12 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -885,7 +877,7 @@ TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) {
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -895,12 +887,12 @@ TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) {
EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -910,7 +902,7 @@ TEST(SoftwareImageDecodeControllerTest,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -921,17 +913,17 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
DecodedDrawImage another_decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_EQ(decoded_draw_image.image()->uniqueID(),
another_decoded_draw_image.image()->uniqueID());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, another_decoded_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -941,7 +933,7 @@ TEST(SoftwareImageDecodeControllerTest,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -952,15 +944,15 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage another_decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
// This should get the new decoded/locked image, not the one we're using at
// raster.
// TODO(vmpstr): We can possibly optimize this so that the decode simply moves
@@ -969,14 +961,14 @@ TEST(SoftwareImageDecodeControllerTest,
another_decoded_draw_image.image()->uniqueID());
EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, another_decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -986,7 +978,7 @@ TEST(SoftwareImageDecodeControllerTest,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -997,31 +989,31 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(task);
// If we finish the draw here, then we will use it for the locked decode
// instead of decoding again.
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage another_decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
// This should get the decoded/locked image which we originally decoded at
// raster time, since it's now in the locked cache.
EXPECT_EQ(decoded_draw_image.image()->uniqueID(),
another_decoded_draw_image.image()->uniqueID());
EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, another_decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, ZeroSizedImagesAreSkipped) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, ZeroSizedImagesAreSkipped) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -1031,20 +1023,20 @@ TEST(SoftwareImageDecodeControllerTest, ZeroSizedImagesAreSkipped) {
CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_FALSE(task);
EXPECT_FALSE(need_unref);
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_FALSE(decoded_draw_image.image());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -1054,20 +1046,20 @@ TEST(SoftwareImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) {
quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_FALSE(task);
EXPECT_FALSE(need_unref);
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_FALSE(decoded_draw_image.image());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, LowQualityFilterIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, LowQualityFilterIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -1077,26 +1069,26 @@ TEST(SoftwareImageDecodeControllerTest, LowQualityFilterIsHandled) {
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImage object.
EXPECT_TRUE(decoded_draw_image.image() != image);
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, LowQualityScaledSubrectIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -1105,15 +1097,15 @@ TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) {
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImage object.
@@ -1121,12 +1113,12 @@ TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) {
EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kNone_SkFilterQuality;
@@ -1135,15 +1127,15 @@ TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) {
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImage object.
@@ -1151,12 +1143,12 @@ TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) {
EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality());
EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt01_5ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1166,15 +1158,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) {
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1183,12 +1175,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) {
EXPECT_EQ(500, decoded_draw_image.image()->width());
EXPECT_EQ(200, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt1_0ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt1_0ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1198,15 +1190,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt1_0ScaleIsHandled) {
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1215,12 +1207,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt1_0ScaleIsHandled) {
EXPECT_EQ(500, decoded_draw_image.image()->width());
EXPECT_EQ(200, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_75ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_75ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1230,15 +1222,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_75ScaleIsHandled) {
CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1247,12 +1239,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_75ScaleIsHandled) {
EXPECT_EQ(500, decoded_draw_image.image()->width());
EXPECT_EQ(200, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_5ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_5ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1262,15 +1254,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_5ScaleIsHandled) {
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1279,12 +1271,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_5ScaleIsHandled) {
EXPECT_EQ(250, decoded_draw_image.image()->width());
EXPECT_EQ(100, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_49ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_49ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1294,15 +1286,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_49ScaleIsHandled) {
CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1311,12 +1303,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_49ScaleIsHandled) {
EXPECT_EQ(250, decoded_draw_image.image()->width());
EXPECT_EQ(100, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_1ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_1ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1326,15 +1318,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_1ScaleIsHandled) {
CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1343,12 +1335,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_1ScaleIsHandled) {
EXPECT_EQ(62, decoded_draw_image.image()->width());
EXPECT_EQ(25, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_01ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_01ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1358,15 +1350,15 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_01ScaleIsHandled) {
CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1375,12 +1367,12 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_01ScaleIsHandled) {
EXPECT_EQ(7, decoded_draw_image.image()->width());
EXPECT_EQ(3, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_001ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_001ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1390,21 +1382,21 @@ TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_001ScaleIsHandled) {
CreateMatrix(SkSize::Make(0.001f, 0.001f), is_decomposable));
scoped_refptr<TileTask> task;
- bool need_unref = controller.GetTaskForImageAndRef(
- draw_image, ImageDecodeController::TracingInfo(), &task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ draw_image, ImageDecodeCache::TracingInfo(), &task);
EXPECT_FALSE(task);
EXPECT_FALSE(need_unref);
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_FALSE(decoded_draw_image.image());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
MediumQualityImagesAreTheSameAt0_5And0_49Scale) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1417,23 +1409,23 @@ TEST(SoftwareImageDecodeControllerTest,
CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable));
scoped_refptr<TileTask> task_50;
- bool need_unref_50 = controller.GetTaskForImageAndRef(
- draw_image_50, ImageDecodeController::TracingInfo(), &task_50);
+ bool need_unref_50 = cache.GetTaskForImageAndRef(
+ draw_image_50, ImageDecodeCache::TracingInfo(), &task_50);
EXPECT_TRUE(task_50);
EXPECT_TRUE(need_unref_50);
scoped_refptr<TileTask> task_49;
- bool need_unref_49 = controller.GetTaskForImageAndRef(
- draw_image_49, ImageDecodeController::TracingInfo(), &task_49);
+ bool need_unref_49 = cache.GetTaskForImageAndRef(
+ draw_image_49, ImageDecodeCache::TracingInfo(), &task_49);
EXPECT_TRUE(task_49);
EXPECT_TRUE(need_unref_49);
TestTileTaskRunner::ProcessTask(task_49.get());
DecodedDrawImage decoded_draw_image_50 =
- controller.GetDecodedImageForDraw(draw_image_50);
+ cache.GetDecodedImageForDraw(draw_image_50);
EXPECT_TRUE(decoded_draw_image_50.image());
DecodedDrawImage decoded_draw_image_49 =
- controller.GetDecodedImageForDraw(draw_image_49);
+ cache.GetDecodedImageForDraw(draw_image_49);
EXPECT_TRUE(decoded_draw_image_49.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1448,10 +1440,10 @@ TEST(SoftwareImageDecodeControllerTest,
EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image());
- controller.DrawWithImageFinished(draw_image_50, decoded_draw_image_50);
- controller.UnrefImage(draw_image_50);
- controller.DrawWithImageFinished(draw_image_49, decoded_draw_image_49);
- controller.UnrefImage(draw_image_49);
+ cache.DrawWithImageFinished(draw_image_50, decoded_draw_image_50);
+ cache.UnrefImage(draw_image_50);
+ cache.DrawWithImageFinished(draw_image_49, decoded_draw_image_49);
+ cache.UnrefImage(draw_image_49);
}
} // namespace
« no previous file with comments | « cc/tiles/software_image_decode_cache.cc ('k') | cc/tiles/software_image_decode_controller.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698