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_cache.h" |
6 | 6 |
7 #include "cc/playback/draw_image.h" | 7 #include "cc/playback/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" |
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 TestSoftwareImageDecodeCache : public SoftwareImageDecodeCache { |
18 public: | 18 public: |
19 TestSoftwareImageDecodeController() | 19 TestSoftwareImageDecodeCache() |
20 : SoftwareImageDecodeController(ResourceFormat::RGBA_8888, | 20 : SoftwareImageDecodeCache(ResourceFormat::RGBA_8888, |
21 kLockedMemoryLimitBytes) {} | 21 kLockedMemoryLimitBytes) {} |
22 }; | 22 }; |
23 | 23 |
24 sk_sp<SkImage> CreateImage(int width, int height) { | 24 sk_sp<SkImage> CreateImage(int width, int height) { |
25 SkBitmap bitmap; | 25 SkBitmap bitmap; |
26 bitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height)); | 26 bitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height)); |
27 return SkImage::MakeFromBitmap(bitmap); | 27 return SkImage::MakeFromBitmap(bitmap); |
28 } | 28 } |
29 | 29 |
30 SkMatrix CreateMatrix(const SkSize& scale, bool is_decomposable) { | 30 SkMatrix CreateMatrix(const SkSize& scale, bool is_decomposable) { |
31 SkMatrix matrix; | 31 SkMatrix matrix; |
32 matrix.setScale(scale.width(), scale.height()); | 32 matrix.setScale(scale.width(), scale.height()); |
33 | 33 |
34 if (!is_decomposable) { | 34 if (!is_decomposable) { |
35 // Perspective is not decomposable, add it. | 35 // Perspective is not decomposable, add it. |
36 matrix[SkMatrix::kMPersp0] = 0.1f; | 36 matrix[SkMatrix::kMPersp0] = 0.1f; |
37 } | 37 } |
38 | 38 |
39 return matrix; | 39 return matrix; |
40 } | 40 } |
41 | 41 |
42 TEST(SoftwareImageDecodeControllerTest, ImageKeyLowQuality) { | 42 TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQuality) { |
43 sk_sp<SkImage> image = CreateImage(100, 100); | 43 sk_sp<SkImage> image = CreateImage(100, 100); |
44 bool is_decomposable = true; | 44 bool is_decomposable = true; |
45 SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality}; | 45 SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality}; |
46 for (auto quality : qualities) { | 46 for (auto quality : qualities) { |
47 DrawImage draw_image( | 47 DrawImage draw_image( |
48 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 48 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
49 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); | 49 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); |
50 | 50 |
51 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 51 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
52 EXPECT_EQ(image->uniqueID(), key.image_id()); | 52 EXPECT_EQ(image->uniqueID(), key.image_id()); |
53 EXPECT_EQ(quality, key.filter_quality()); | 53 EXPECT_EQ(quality, key.filter_quality()); |
54 EXPECT_EQ(100, key.target_size().width()); | 54 EXPECT_EQ(100, key.target_size().width()); |
55 EXPECT_EQ(100, key.target_size().height()); | 55 EXPECT_EQ(100, key.target_size().height()); |
56 EXPECT_TRUE(key.can_use_original_decode()); | 56 EXPECT_TRUE(key.can_use_original_decode()); |
57 // Since the original decode will be used, the locked_bytes is that of the | 57 // Since the original decode will be used, the locked_bytes is that of the |
58 // original image. | 58 // original image. |
59 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 59 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
60 } | 60 } |
61 } | 61 } |
62 | 62 |
63 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQuality) { | 63 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) { |
64 sk_sp<SkImage> image = CreateImage(100, 100); | 64 sk_sp<SkImage> image = CreateImage(100, 100); |
65 bool is_decomposable = true; | 65 bool is_decomposable = true; |
66 SkFilterQuality quality = kMedium_SkFilterQuality; | 66 SkFilterQuality quality = kMedium_SkFilterQuality; |
67 | 67 |
68 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 68 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
69 quality, | 69 quality, |
70 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); | 70 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); |
71 | 71 |
72 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 72 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
73 EXPECT_EQ(image->uniqueID(), key.image_id()); | 73 EXPECT_EQ(image->uniqueID(), key.image_id()); |
74 EXPECT_EQ(quality, key.filter_quality()); | 74 EXPECT_EQ(quality, key.filter_quality()); |
75 EXPECT_EQ(100, key.target_size().width()); | 75 EXPECT_EQ(100, key.target_size().width()); |
76 EXPECT_EQ(100, key.target_size().height()); | 76 EXPECT_EQ(100, key.target_size().height()); |
77 EXPECT_FALSE(key.can_use_original_decode()); | 77 EXPECT_FALSE(key.can_use_original_decode()); |
78 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 78 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
79 } | 79 } |
80 | 80 |
81 TEST(SoftwareImageDecodeControllerTest, | 81 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfEnlarging) { |
82 ImageKeyMediumQualityDropToLowIfEnlarging) { | |
83 sk_sp<SkImage> image = CreateImage(100, 100); | 82 sk_sp<SkImage> image = CreateImage(100, 100); |
84 bool is_decomposable = true; | 83 bool is_decomposable = true; |
85 SkFilterQuality quality = kMedium_SkFilterQuality; | 84 SkFilterQuality quality = kMedium_SkFilterQuality; |
86 | 85 |
87 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 86 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
88 quality, | 87 quality, |
89 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | 88 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
90 | 89 |
91 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 90 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
92 EXPECT_EQ(image->uniqueID(), key.image_id()); | 91 EXPECT_EQ(image->uniqueID(), key.image_id()); |
93 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 92 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
94 EXPECT_EQ(100, key.target_size().width()); | 93 EXPECT_EQ(100, key.target_size().width()); |
95 EXPECT_EQ(100, key.target_size().height()); | 94 EXPECT_EQ(100, key.target_size().height()); |
96 EXPECT_TRUE(key.can_use_original_decode()); | 95 EXPECT_TRUE(key.can_use_original_decode()); |
97 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 96 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
98 } | 97 } |
99 | 98 |
100 TEST(SoftwareImageDecodeControllerTest, | 99 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfIdentity) { |
101 ImageKeyMediumQualityDropToLowIfIdentity) { | |
102 sk_sp<SkImage> image = CreateImage(100, 100); | 100 sk_sp<SkImage> image = CreateImage(100, 100); |
103 bool is_decomposable = true; | 101 bool is_decomposable = true; |
104 SkFilterQuality quality = kMedium_SkFilterQuality; | 102 SkFilterQuality quality = kMedium_SkFilterQuality; |
105 | 103 |
106 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 104 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
107 quality, | 105 quality, |
108 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 106 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
109 | 107 |
110 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 108 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
111 EXPECT_EQ(image->uniqueID(), key.image_id()); | 109 EXPECT_EQ(image->uniqueID(), key.image_id()); |
112 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 110 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
113 EXPECT_EQ(100, key.target_size().width()); | 111 EXPECT_EQ(100, key.target_size().width()); |
114 EXPECT_EQ(100, key.target_size().height()); | 112 EXPECT_EQ(100, key.target_size().height()); |
115 EXPECT_TRUE(key.can_use_original_decode()); | 113 EXPECT_TRUE(key.can_use_original_decode()); |
116 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 114 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
117 } | 115 } |
118 | 116 |
119 TEST(SoftwareImageDecodeControllerTest, | 117 TEST(SoftwareImageDecodeCacheTest, |
120 ImageKeyMediumQualityDropToLowIfNearlyIdentity) { | 118 ImageKeyMediumQualityDropToLowIfNearlyIdentity) { |
121 sk_sp<SkImage> image = CreateImage(100, 100); | 119 sk_sp<SkImage> image = CreateImage(100, 100); |
122 bool is_decomposable = true; | 120 bool is_decomposable = true; |
123 SkFilterQuality quality = kMedium_SkFilterQuality; | 121 SkFilterQuality quality = kMedium_SkFilterQuality; |
124 | 122 |
125 DrawImage draw_image( | 123 DrawImage draw_image( |
126 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 124 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
127 CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable)); | 125 CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable)); |
128 | 126 |
129 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 127 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
130 EXPECT_EQ(image->uniqueID(), key.image_id()); | 128 EXPECT_EQ(image->uniqueID(), key.image_id()); |
131 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 129 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
132 EXPECT_EQ(100, key.target_size().width()); | 130 EXPECT_EQ(100, key.target_size().width()); |
133 EXPECT_EQ(100, key.target_size().height()); | 131 EXPECT_EQ(100, key.target_size().height()); |
134 EXPECT_TRUE(key.can_use_original_decode()); | 132 EXPECT_TRUE(key.can_use_original_decode()); |
135 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 133 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
136 } | 134 } |
137 | 135 |
138 TEST(SoftwareImageDecodeControllerTest, | 136 TEST(SoftwareImageDecodeCacheTest, |
139 ImageKeyMediumQualityDropToLowIfNearlyIdentity2) { | 137 ImageKeyMediumQualityDropToLowIfNearlyIdentity2) { |
140 sk_sp<SkImage> image = CreateImage(100, 100); | 138 sk_sp<SkImage> image = CreateImage(100, 100); |
141 bool is_decomposable = true; | 139 bool is_decomposable = true; |
142 SkFilterQuality quality = kMedium_SkFilterQuality; | 140 SkFilterQuality quality = kMedium_SkFilterQuality; |
143 | 141 |
144 DrawImage draw_image( | 142 DrawImage draw_image( |
145 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 143 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
146 CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable)); | 144 CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable)); |
147 | 145 |
148 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 146 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
149 EXPECT_EQ(image->uniqueID(), key.image_id()); | 147 EXPECT_EQ(image->uniqueID(), key.image_id()); |
150 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 148 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
151 EXPECT_EQ(100, key.target_size().width()); | 149 EXPECT_EQ(100, key.target_size().width()); |
152 EXPECT_EQ(100, key.target_size().height()); | 150 EXPECT_EQ(100, key.target_size().height()); |
153 EXPECT_TRUE(key.can_use_original_decode()); | 151 EXPECT_TRUE(key.can_use_original_decode()); |
154 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 152 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
155 } | 153 } |
156 | 154 |
157 TEST(SoftwareImageDecodeControllerTest, | 155 TEST(SoftwareImageDecodeCacheTest, |
158 ImageKeyMediumQualityDropToLowIfNotDecomposable) { | 156 ImageKeyMediumQualityDropToLowIfNotDecomposable) { |
159 sk_sp<SkImage> image = CreateImage(100, 100); | 157 sk_sp<SkImage> image = CreateImage(100, 100); |
160 bool is_decomposable = false; | 158 bool is_decomposable = false; |
161 SkFilterQuality quality = kMedium_SkFilterQuality; | 159 SkFilterQuality quality = kMedium_SkFilterQuality; |
162 | 160 |
163 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 161 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
164 quality, | 162 quality, |
165 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); | 163 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); |
166 | 164 |
167 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 165 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
168 EXPECT_EQ(image->uniqueID(), key.image_id()); | 166 EXPECT_EQ(image->uniqueID(), key.image_id()); |
169 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 167 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
170 EXPECT_EQ(100, key.target_size().width()); | 168 EXPECT_EQ(100, key.target_size().width()); |
171 EXPECT_EQ(100, key.target_size().height()); | 169 EXPECT_EQ(100, key.target_size().height()); |
172 EXPECT_TRUE(key.can_use_original_decode()); | 170 EXPECT_TRUE(key.can_use_original_decode()); |
173 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 171 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
174 } | 172 } |
175 | 173 |
176 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_5Scale) { | 174 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_5Scale) { |
177 sk_sp<SkImage> image = CreateImage(500, 200); | 175 sk_sp<SkImage> image = CreateImage(500, 200); |
178 bool is_decomposable = true; | 176 bool is_decomposable = true; |
179 SkFilterQuality quality = kMedium_SkFilterQuality; | 177 SkFilterQuality quality = kMedium_SkFilterQuality; |
180 | 178 |
181 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 179 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
182 quality, | 180 quality, |
183 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | 181 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
184 | 182 |
185 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 183 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
186 EXPECT_EQ(image->uniqueID(), key.image_id()); | 184 EXPECT_EQ(image->uniqueID(), key.image_id()); |
187 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 185 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
188 EXPECT_EQ(500, key.target_size().width()); | 186 EXPECT_EQ(500, key.target_size().width()); |
189 EXPECT_EQ(200, key.target_size().height()); | 187 EXPECT_EQ(200, key.target_size().height()); |
190 EXPECT_TRUE(key.can_use_original_decode()); | 188 EXPECT_TRUE(key.can_use_original_decode()); |
191 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); | 189 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); |
192 } | 190 } |
193 | 191 |
194 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_0cale) { | 192 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_0cale) { |
195 sk_sp<SkImage> image = CreateImage(500, 200); | 193 sk_sp<SkImage> image = CreateImage(500, 200); |
196 bool is_decomposable = true; | 194 bool is_decomposable = true; |
197 SkFilterQuality quality = kMedium_SkFilterQuality; | 195 SkFilterQuality quality = kMedium_SkFilterQuality; |
198 | 196 |
199 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 197 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
200 quality, | 198 quality, |
201 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 199 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
202 | 200 |
203 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 201 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
204 EXPECT_EQ(image->uniqueID(), key.image_id()); | 202 EXPECT_EQ(image->uniqueID(), key.image_id()); |
205 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 203 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
206 EXPECT_EQ(500, key.target_size().width()); | 204 EXPECT_EQ(500, key.target_size().width()); |
207 EXPECT_EQ(200, key.target_size().height()); | 205 EXPECT_EQ(200, key.target_size().height()); |
208 EXPECT_TRUE(key.can_use_original_decode()); | 206 EXPECT_TRUE(key.can_use_original_decode()); |
209 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); | 207 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); |
210 } | 208 } |
211 | 209 |
212 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_75Scale) { | 210 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_75Scale) { |
213 sk_sp<SkImage> image = CreateImage(500, 200); | 211 sk_sp<SkImage> image = CreateImage(500, 200); |
214 bool is_decomposable = true; | 212 bool is_decomposable = true; |
215 SkFilterQuality quality = kMedium_SkFilterQuality; | 213 SkFilterQuality quality = kMedium_SkFilterQuality; |
216 | 214 |
217 DrawImage draw_image( | 215 DrawImage draw_image( |
218 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 216 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
219 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable)); | 217 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable)); |
220 | 218 |
221 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 219 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
222 EXPECT_EQ(image->uniqueID(), key.image_id()); | 220 EXPECT_EQ(image->uniqueID(), key.image_id()); |
223 EXPECT_EQ(quality, key.filter_quality()); | 221 EXPECT_EQ(quality, key.filter_quality()); |
224 EXPECT_EQ(500, key.target_size().width()); | 222 EXPECT_EQ(500, key.target_size().width()); |
225 EXPECT_EQ(200, key.target_size().height()); | 223 EXPECT_EQ(200, key.target_size().height()); |
226 EXPECT_FALSE(key.can_use_original_decode()); | 224 EXPECT_FALSE(key.can_use_original_decode()); |
227 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); | 225 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); |
228 } | 226 } |
229 | 227 |
230 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_5Scale) { | 228 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_5Scale) { |
231 sk_sp<SkImage> image = CreateImage(500, 200); | 229 sk_sp<SkImage> image = CreateImage(500, 200); |
232 bool is_decomposable = true; | 230 bool is_decomposable = true; |
233 SkFilterQuality quality = kMedium_SkFilterQuality; | 231 SkFilterQuality quality = kMedium_SkFilterQuality; |
234 | 232 |
235 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 233 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
236 quality, | 234 quality, |
237 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 235 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
238 | 236 |
239 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 237 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
240 EXPECT_EQ(image->uniqueID(), key.image_id()); | 238 EXPECT_EQ(image->uniqueID(), key.image_id()); |
241 EXPECT_EQ(quality, key.filter_quality()); | 239 EXPECT_EQ(quality, key.filter_quality()); |
242 EXPECT_EQ(250, key.target_size().width()); | 240 EXPECT_EQ(250, key.target_size().width()); |
243 EXPECT_EQ(100, key.target_size().height()); | 241 EXPECT_EQ(100, key.target_size().height()); |
244 EXPECT_FALSE(key.can_use_original_decode()); | 242 EXPECT_FALSE(key.can_use_original_decode()); |
245 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); | 243 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); |
246 } | 244 } |
247 | 245 |
248 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_49Scale) { | 246 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_49Scale) { |
249 sk_sp<SkImage> image = CreateImage(500, 200); | 247 sk_sp<SkImage> image = CreateImage(500, 200); |
250 bool is_decomposable = true; | 248 bool is_decomposable = true; |
251 SkFilterQuality quality = kMedium_SkFilterQuality; | 249 SkFilterQuality quality = kMedium_SkFilterQuality; |
252 | 250 |
253 DrawImage draw_image( | 251 DrawImage draw_image( |
254 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 252 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
255 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); | 253 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); |
256 | 254 |
257 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 255 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
258 EXPECT_EQ(image->uniqueID(), key.image_id()); | 256 EXPECT_EQ(image->uniqueID(), key.image_id()); |
259 EXPECT_EQ(quality, key.filter_quality()); | 257 EXPECT_EQ(quality, key.filter_quality()); |
260 EXPECT_EQ(250, key.target_size().width()); | 258 EXPECT_EQ(250, key.target_size().width()); |
261 EXPECT_EQ(100, key.target_size().height()); | 259 EXPECT_EQ(100, key.target_size().height()); |
262 EXPECT_FALSE(key.can_use_original_decode()); | 260 EXPECT_FALSE(key.can_use_original_decode()); |
263 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); | 261 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); |
264 } | 262 } |
265 | 263 |
266 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_1Scale) { | 264 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_1Scale) { |
267 sk_sp<SkImage> image = CreateImage(500, 200); | 265 sk_sp<SkImage> image = CreateImage(500, 200); |
268 bool is_decomposable = true; | 266 bool is_decomposable = true; |
269 SkFilterQuality quality = kMedium_SkFilterQuality; | 267 SkFilterQuality quality = kMedium_SkFilterQuality; |
270 | 268 |
271 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 269 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
272 quality, | 270 quality, |
273 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable)); | 271 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable)); |
274 | 272 |
275 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 273 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
276 EXPECT_EQ(image->uniqueID(), key.image_id()); | 274 EXPECT_EQ(image->uniqueID(), key.image_id()); |
277 EXPECT_EQ(quality, key.filter_quality()); | 275 EXPECT_EQ(quality, key.filter_quality()); |
278 EXPECT_EQ(62, key.target_size().width()); | 276 EXPECT_EQ(62, key.target_size().width()); |
279 EXPECT_EQ(25, key.target_size().height()); | 277 EXPECT_EQ(25, key.target_size().height()); |
280 EXPECT_FALSE(key.can_use_original_decode()); | 278 EXPECT_FALSE(key.can_use_original_decode()); |
281 EXPECT_EQ(62u * 25u * 4u, key.locked_bytes()); | 279 EXPECT_EQ(62u * 25u * 4u, key.locked_bytes()); |
282 } | 280 } |
283 | 281 |
284 TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_01Scale) { | 282 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_01Scale) { |
285 sk_sp<SkImage> image = CreateImage(500, 200); | 283 sk_sp<SkImage> image = CreateImage(500, 200); |
286 bool is_decomposable = true; | 284 bool is_decomposable = true; |
287 SkFilterQuality quality = kMedium_SkFilterQuality; | 285 SkFilterQuality quality = kMedium_SkFilterQuality; |
288 | 286 |
289 DrawImage draw_image( | 287 DrawImage draw_image( |
290 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 288 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
291 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable)); | 289 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable)); |
292 | 290 |
293 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 291 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
294 EXPECT_EQ(image->uniqueID(), key.image_id()); | 292 EXPECT_EQ(image->uniqueID(), key.image_id()); |
295 EXPECT_EQ(quality, key.filter_quality()); | 293 EXPECT_EQ(quality, key.filter_quality()); |
296 EXPECT_EQ(7, key.target_size().width()); | 294 EXPECT_EQ(7, key.target_size().width()); |
297 EXPECT_EQ(3, key.target_size().height()); | 295 EXPECT_EQ(3, key.target_size().height()); |
298 EXPECT_FALSE(key.can_use_original_decode()); | 296 EXPECT_FALSE(key.can_use_original_decode()); |
299 EXPECT_EQ(7u * 3u * 4u, key.locked_bytes()); | 297 EXPECT_EQ(7u * 3u * 4u, key.locked_bytes()); |
300 } | 298 } |
301 | 299 |
302 TEST(SoftwareImageDecodeControllerTest, | 300 TEST(SoftwareImageDecodeCacheTest, |
303 ImageKeyPartialDowscalesDropsHighQualityToMedium) { | 301 ImageKeyPartialDowscalesDropsHighQualityToMedium) { |
304 sk_sp<SkImage> image = CreateImage(100, 100); | 302 sk_sp<SkImage> image = CreateImage(100, 100); |
305 bool is_decomposable = true; | 303 bool is_decomposable = true; |
306 SkFilterQuality quality = kHigh_SkFilterQuality; | 304 SkFilterQuality quality = kHigh_SkFilterQuality; |
307 | 305 |
308 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 306 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
309 quality, | 307 quality, |
310 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); | 308 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); |
311 | 309 |
312 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 310 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
313 EXPECT_EQ(image->uniqueID(), key.image_id()); | 311 EXPECT_EQ(image->uniqueID(), key.image_id()); |
314 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 312 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
315 EXPECT_EQ(100, key.target_size().width()); | 313 EXPECT_EQ(100, key.target_size().width()); |
316 EXPECT_EQ(100, key.target_size().height()); | 314 EXPECT_EQ(100, key.target_size().height()); |
317 EXPECT_FALSE(key.can_use_original_decode()); | 315 EXPECT_FALSE(key.can_use_original_decode()); |
318 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 316 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
319 } | 317 } |
320 | 318 |
321 TEST(SoftwareImageDecodeControllerTest, | 319 TEST(SoftwareImageDecodeCacheTest, |
322 ImageKeyFullDowscalesDropsHighQualityToMedium) { | 320 ImageKeyFullDowscalesDropsHighQualityToMedium) { |
323 sk_sp<SkImage> image = CreateImage(100, 100); | 321 sk_sp<SkImage> image = CreateImage(100, 100); |
324 bool is_decomposable = true; | 322 bool is_decomposable = true; |
325 SkFilterQuality quality = kHigh_SkFilterQuality; | 323 SkFilterQuality quality = kHigh_SkFilterQuality; |
326 | 324 |
327 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 325 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
328 quality, | 326 quality, |
329 CreateMatrix(SkSize::Make(0.5f, 0.2f), is_decomposable)); | 327 CreateMatrix(SkSize::Make(0.5f, 0.2f), is_decomposable)); |
330 | 328 |
331 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 329 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
332 EXPECT_EQ(image->uniqueID(), key.image_id()); | 330 EXPECT_EQ(image->uniqueID(), key.image_id()); |
333 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 331 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
334 EXPECT_EQ(50, key.target_size().width()); | 332 EXPECT_EQ(50, key.target_size().width()); |
335 EXPECT_EQ(50, key.target_size().height()); | 333 EXPECT_EQ(50, key.target_size().height()); |
336 EXPECT_FALSE(key.can_use_original_decode()); | 334 EXPECT_FALSE(key.can_use_original_decode()); |
337 EXPECT_EQ(50u * 50u * 4u, key.locked_bytes()); | 335 EXPECT_EQ(50u * 50u * 4u, key.locked_bytes()); |
338 } | 336 } |
339 | 337 |
340 TEST(SoftwareImageDecodeControllerTest, ImageKeyDowscalesHighQuality) { | 338 TEST(SoftwareImageDecodeCacheTest, ImageKeyDowscalesHighQuality) { |
341 sk_sp<SkImage> image = CreateImage(100, 100); | 339 sk_sp<SkImage> image = CreateImage(100, 100); |
342 bool is_decomposable = true; | 340 bool is_decomposable = true; |
343 SkFilterQuality quality = kHigh_SkFilterQuality; | 341 SkFilterQuality quality = kHigh_SkFilterQuality; |
344 | 342 |
345 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 343 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
346 quality, | 344 quality, |
347 CreateMatrix(SkSize::Make(2.5f, 1.5f), is_decomposable)); | 345 CreateMatrix(SkSize::Make(2.5f, 1.5f), is_decomposable)); |
348 | 346 |
349 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 347 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
350 EXPECT_EQ(image->uniqueID(), key.image_id()); | 348 EXPECT_EQ(image->uniqueID(), key.image_id()); |
351 EXPECT_EQ(quality, key.filter_quality()); | 349 EXPECT_EQ(quality, key.filter_quality()); |
352 EXPECT_EQ(250, key.target_size().width()); | 350 EXPECT_EQ(250, key.target_size().width()); |
353 EXPECT_EQ(150, key.target_size().height()); | 351 EXPECT_EQ(150, key.target_size().height()); |
354 EXPECT_FALSE(key.can_use_original_decode()); | 352 EXPECT_FALSE(key.can_use_original_decode()); |
355 EXPECT_EQ(250u * 150u * 4u, key.locked_bytes()); | 353 EXPECT_EQ(250u * 150u * 4u, key.locked_bytes()); |
356 } | 354 } |
357 | 355 |
358 TEST(SoftwareImageDecodeControllerTest, | 356 TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToMediumIfTooLarge) { |
359 ImageKeyHighQualityDropToMediumIfTooLarge) { | |
360 // Just over 64MB when scaled. | 357 // Just over 64MB when scaled. |
361 sk_sp<SkImage> image = CreateImage(4555, 2048); | 358 sk_sp<SkImage> image = CreateImage(4555, 2048); |
362 bool is_decomposable = true; | 359 bool is_decomposable = true; |
363 SkFilterQuality quality = kHigh_SkFilterQuality; | 360 SkFilterQuality quality = kHigh_SkFilterQuality; |
364 | 361 |
365 // At least one dimension should scale down, so that medium quality doesn't | 362 // At least one dimension should scale down, so that medium quality doesn't |
366 // become low. | 363 // become low. |
367 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 364 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
368 quality, | 365 quality, |
369 CreateMatrix(SkSize::Make(0.9f, 2.f), is_decomposable)); | 366 CreateMatrix(SkSize::Make(0.9f, 2.f), is_decomposable)); |
370 | 367 |
371 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 368 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
372 EXPECT_EQ(image->uniqueID(), key.image_id()); | 369 EXPECT_EQ(image->uniqueID(), key.image_id()); |
373 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 370 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
374 EXPECT_EQ(4555, key.target_size().width()); | 371 EXPECT_EQ(4555, key.target_size().width()); |
375 EXPECT_EQ(2048, key.target_size().height()); | 372 EXPECT_EQ(2048, key.target_size().height()); |
376 EXPECT_FALSE(key.can_use_original_decode()); | 373 EXPECT_FALSE(key.can_use_original_decode()); |
377 EXPECT_EQ(4555u * 2048u * 4u, key.locked_bytes()); | 374 EXPECT_EQ(4555u * 2048u * 4u, key.locked_bytes()); |
378 } | 375 } |
379 | 376 |
380 TEST(SoftwareImageDecodeControllerTest, | 377 TEST(SoftwareImageDecodeCacheTest, |
381 ImageKeyHighQualityDropToLowIfNotDecomposable) { | 378 ImageKeyHighQualityDropToLowIfNotDecomposable) { |
382 sk_sp<SkImage> image = CreateImage(100, 100); | 379 sk_sp<SkImage> image = CreateImage(100, 100); |
383 bool is_decomposable = false; | 380 bool is_decomposable = false; |
384 SkFilterQuality quality = kHigh_SkFilterQuality; | 381 SkFilterQuality quality = kHigh_SkFilterQuality; |
385 | 382 |
386 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 383 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
387 quality, | 384 quality, |
388 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); | 385 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable)); |
389 | 386 |
390 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 387 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
391 EXPECT_EQ(image->uniqueID(), key.image_id()); | 388 EXPECT_EQ(image->uniqueID(), key.image_id()); |
392 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 389 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
393 EXPECT_EQ(100, key.target_size().width()); | 390 EXPECT_EQ(100, key.target_size().width()); |
394 EXPECT_EQ(100, key.target_size().height()); | 391 EXPECT_EQ(100, key.target_size().height()); |
395 EXPECT_TRUE(key.can_use_original_decode()); | 392 EXPECT_TRUE(key.can_use_original_decode()); |
396 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 393 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
397 } | 394 } |
398 | 395 |
399 TEST(SoftwareImageDecodeControllerTest, | 396 TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToLowIfIdentity) { |
400 ImageKeyHighQualityDropToLowIfIdentity) { | |
401 sk_sp<SkImage> image = CreateImage(100, 100); | 397 sk_sp<SkImage> image = CreateImage(100, 100); |
402 bool is_decomposable = true; | 398 bool is_decomposable = true; |
403 SkFilterQuality quality = kHigh_SkFilterQuality; | 399 SkFilterQuality quality = kHigh_SkFilterQuality; |
404 | 400 |
405 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 401 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
406 quality, | 402 quality, |
407 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 403 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
408 | 404 |
409 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 405 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
410 EXPECT_EQ(image->uniqueID(), key.image_id()); | 406 EXPECT_EQ(image->uniqueID(), key.image_id()); |
411 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 407 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
412 EXPECT_EQ(100, key.target_size().width()); | 408 EXPECT_EQ(100, key.target_size().width()); |
413 EXPECT_EQ(100, key.target_size().height()); | 409 EXPECT_EQ(100, key.target_size().height()); |
414 EXPECT_TRUE(key.can_use_original_decode()); | 410 EXPECT_TRUE(key.can_use_original_decode()); |
415 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 411 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
416 } | 412 } |
417 | 413 |
418 TEST(SoftwareImageDecodeControllerTest, | 414 TEST(SoftwareImageDecodeCacheTest, |
419 ImageKeyHighQualityDropToLowIfNearlyIdentity) { | 415 ImageKeyHighQualityDropToLowIfNearlyIdentity) { |
420 sk_sp<SkImage> image = CreateImage(100, 100); | 416 sk_sp<SkImage> image = CreateImage(100, 100); |
421 bool is_decomposable = true; | 417 bool is_decomposable = true; |
422 SkFilterQuality quality = kHigh_SkFilterQuality; | 418 SkFilterQuality quality = kHigh_SkFilterQuality; |
423 | 419 |
424 DrawImage draw_image( | 420 DrawImage draw_image( |
425 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 421 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
426 CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable)); | 422 CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable)); |
427 | 423 |
428 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 424 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
429 EXPECT_EQ(image->uniqueID(), key.image_id()); | 425 EXPECT_EQ(image->uniqueID(), key.image_id()); |
430 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 426 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
431 EXPECT_EQ(100, key.target_size().width()); | 427 EXPECT_EQ(100, key.target_size().width()); |
432 EXPECT_EQ(100, key.target_size().height()); | 428 EXPECT_EQ(100, key.target_size().height()); |
433 EXPECT_TRUE(key.can_use_original_decode()); | 429 EXPECT_TRUE(key.can_use_original_decode()); |
434 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 430 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
435 } | 431 } |
436 | 432 |
437 TEST(SoftwareImageDecodeControllerTest, | 433 TEST(SoftwareImageDecodeCacheTest, |
438 ImageKeyHighQualityDropToLowIfNearlyIdentity2) { | 434 ImageKeyHighQualityDropToLowIfNearlyIdentity2) { |
439 sk_sp<SkImage> image = CreateImage(100, 100); | 435 sk_sp<SkImage> image = CreateImage(100, 100); |
440 bool is_decomposable = true; | 436 bool is_decomposable = true; |
441 SkFilterQuality quality = kHigh_SkFilterQuality; | 437 SkFilterQuality quality = kHigh_SkFilterQuality; |
442 | 438 |
443 DrawImage draw_image( | 439 DrawImage draw_image( |
444 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 440 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
445 CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable)); | 441 CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable)); |
446 | 442 |
447 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 443 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
448 EXPECT_EQ(image->uniqueID(), key.image_id()); | 444 EXPECT_EQ(image->uniqueID(), key.image_id()); |
449 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 445 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
450 EXPECT_EQ(100, key.target_size().width()); | 446 EXPECT_EQ(100, key.target_size().width()); |
451 EXPECT_EQ(100, key.target_size().height()); | 447 EXPECT_EQ(100, key.target_size().height()); |
452 EXPECT_TRUE(key.can_use_original_decode()); | 448 EXPECT_TRUE(key.can_use_original_decode()); |
453 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 449 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
454 } | 450 } |
455 | 451 |
456 TEST(SoftwareImageDecodeControllerTest, OriginalDecodesAreEqual) { | 452 TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) { |
457 sk_sp<SkImage> image = CreateImage(100, 100); | 453 sk_sp<SkImage> image = CreateImage(100, 100); |
458 bool is_decomposable = true; | 454 bool is_decomposable = true; |
459 SkFilterQuality quality = kLow_SkFilterQuality; | 455 SkFilterQuality quality = kLow_SkFilterQuality; |
460 | 456 |
461 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 457 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
462 quality, | 458 quality, |
463 CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable)); | 459 CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable)); |
464 | 460 |
465 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 461 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
466 EXPECT_EQ(image->uniqueID(), key.image_id()); | 462 EXPECT_EQ(image->uniqueID(), key.image_id()); |
467 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 463 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
468 EXPECT_EQ(100, key.target_size().width()); | 464 EXPECT_EQ(100, key.target_size().width()); |
469 EXPECT_EQ(100, key.target_size().height()); | 465 EXPECT_EQ(100, key.target_size().height()); |
470 EXPECT_TRUE(key.can_use_original_decode()); | 466 EXPECT_TRUE(key.can_use_original_decode()); |
471 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 467 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
472 | 468 |
473 DrawImage another_draw_image( | 469 DrawImage another_draw_image( |
474 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 470 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
475 CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable)); | 471 CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable)); |
476 | 472 |
477 auto another_key = | 473 auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image); |
478 ImageDecodeControllerKey::FromDrawImage(another_draw_image); | |
479 EXPECT_EQ(image->uniqueID(), another_key.image_id()); | 474 EXPECT_EQ(image->uniqueID(), another_key.image_id()); |
480 EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality()); | 475 EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality()); |
481 EXPECT_EQ(100, another_key.target_size().width()); | 476 EXPECT_EQ(100, another_key.target_size().width()); |
482 EXPECT_EQ(100, another_key.target_size().height()); | 477 EXPECT_EQ(100, another_key.target_size().height()); |
483 EXPECT_TRUE(another_key.can_use_original_decode()); | 478 EXPECT_TRUE(another_key.can_use_original_decode()); |
484 EXPECT_EQ(100u * 100u * 4u, another_key.locked_bytes()); | 479 EXPECT_EQ(100u * 100u * 4u, another_key.locked_bytes()); |
485 | 480 |
486 EXPECT_TRUE(key == another_key); | 481 EXPECT_TRUE(key == another_key); |
487 } | 482 } |
488 | 483 |
489 TEST(SoftwareImageDecodeControllerTest, ImageRectDoesNotContainSrcRect) { | 484 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) { |
490 sk_sp<SkImage> image = CreateImage(100, 100); | 485 sk_sp<SkImage> image = CreateImage(100, 100); |
491 bool is_decomposable = true; | 486 bool is_decomposable = true; |
492 SkFilterQuality quality = kHigh_SkFilterQuality; | 487 SkFilterQuality quality = kHigh_SkFilterQuality; |
493 | 488 |
494 DrawImage draw_image( | 489 DrawImage draw_image( |
495 image, SkIRect::MakeXYWH(25, 35, image->width(), image->height()), | 490 image, SkIRect::MakeXYWH(25, 35, image->width(), image->height()), |
496 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 491 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
497 | 492 |
498 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 493 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
499 EXPECT_EQ(image->uniqueID(), key.image_id()); | 494 EXPECT_EQ(image->uniqueID(), key.image_id()); |
500 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 495 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
501 EXPECT_EQ(100, key.target_size().width()); | 496 EXPECT_EQ(100, key.target_size().width()); |
502 EXPECT_EQ(100, key.target_size().height()); | 497 EXPECT_EQ(100, key.target_size().height()); |
503 EXPECT_EQ(gfx::Rect(25, 35, 75, 65), key.src_rect()); | 498 EXPECT_EQ(gfx::Rect(25, 35, 75, 65), key.src_rect()); |
504 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 499 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
505 } | 500 } |
506 | 501 |
507 TEST(SoftwareImageDecodeControllerTest, | 502 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRectWithScale) { |
508 ImageRectDoesNotContainSrcRectWithScale) { | |
509 sk_sp<SkImage> image = CreateImage(100, 100); | 503 sk_sp<SkImage> image = CreateImage(100, 100); |
510 bool is_decomposable = true; | 504 bool is_decomposable = true; |
511 SkFilterQuality quality = kHigh_SkFilterQuality; | 505 SkFilterQuality quality = kHigh_SkFilterQuality; |
512 | 506 |
513 DrawImage draw_image( | 507 DrawImage draw_image( |
514 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 508 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), |
515 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 509 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
516 | 510 |
517 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image); | 511 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
518 EXPECT_EQ(image->uniqueID(), key.image_id()); | 512 EXPECT_EQ(image->uniqueID(), key.image_id()); |
519 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 513 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
520 EXPECT_EQ(40, key.target_size().width()); | 514 EXPECT_EQ(40, key.target_size().width()); |
521 EXPECT_EQ(35, key.target_size().height()); | 515 EXPECT_EQ(35, key.target_size().height()); |
522 EXPECT_EQ(gfx::Rect(20, 30, 80, 70), key.src_rect()); | 516 EXPECT_EQ(gfx::Rect(20, 30, 80, 70), key.src_rect()); |
523 EXPECT_EQ(40u * 35u * 4u, key.locked_bytes()); | 517 EXPECT_EQ(40u * 35u * 4u, key.locked_bytes()); |
524 } | 518 } |
525 | 519 |
526 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) { | 520 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImage) { |
527 TestSoftwareImageDecodeController controller; | 521 TestSoftwareImageDecodeCache cache; |
528 sk_sp<SkImage> image = CreateImage(100, 100); | 522 sk_sp<SkImage> image = CreateImage(100, 100); |
529 bool is_decomposable = true; | 523 bool is_decomposable = true; |
530 SkFilterQuality quality = kHigh_SkFilterQuality; | 524 SkFilterQuality quality = kHigh_SkFilterQuality; |
531 | 525 |
532 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 526 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
533 quality, | 527 quality, |
534 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 528 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
535 scoped_refptr<TileTask> task; | 529 scoped_refptr<TileTask> task; |
536 bool need_unref = controller.GetTaskForImageAndRef( | 530 bool need_unref = cache.GetTaskForImageAndRef( |
537 draw_image, ImageDecodeController::TracingInfo(), &task); | 531 draw_image, ImageDecodeCache::TracingInfo(), &task); |
538 EXPECT_TRUE(need_unref); | 532 EXPECT_TRUE(need_unref); |
539 EXPECT_TRUE(task); | 533 EXPECT_TRUE(task); |
540 | 534 |
541 DrawImage another_draw_image( | 535 DrawImage another_draw_image( |
542 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 536 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
543 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 537 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
544 scoped_refptr<TileTask> another_task; | 538 scoped_refptr<TileTask> another_task; |
545 need_unref = controller.GetTaskForImageAndRef( | 539 need_unref = cache.GetTaskForImageAndRef( |
546 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); | 540 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
547 EXPECT_TRUE(need_unref); | 541 EXPECT_TRUE(need_unref); |
548 EXPECT_TRUE(task.get() == another_task.get()); | 542 EXPECT_TRUE(task.get() == another_task.get()); |
549 | 543 |
550 TestTileTaskRunner::ProcessTask(task.get()); | 544 TestTileTaskRunner::ProcessTask(task.get()); |
551 | 545 |
552 controller.UnrefImage(draw_image); | 546 cache.UnrefImage(draw_image); |
553 controller.UnrefImage(draw_image); | 547 cache.UnrefImage(draw_image); |
554 } | 548 } |
555 | 549 |
556 TEST(SoftwareImageDecodeControllerTest, | 550 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentQuality) { |
557 GetTaskForImageSameImageDifferentQuality) { | 551 TestSoftwareImageDecodeCache cache; |
558 TestSoftwareImageDecodeController controller; | |
559 sk_sp<SkImage> image = CreateImage(100, 100); | 552 sk_sp<SkImage> image = CreateImage(100, 100); |
560 bool is_decomposable = true; | 553 bool is_decomposable = true; |
561 | 554 |
562 DrawImage high_quality_draw_image( | 555 DrawImage high_quality_draw_image( |
563 image, SkIRect::MakeWH(image->width(), image->height()), | 556 image, SkIRect::MakeWH(image->width(), image->height()), |
564 kHigh_SkFilterQuality, | 557 kHigh_SkFilterQuality, |
565 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 558 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
566 scoped_refptr<TileTask> high_quality_task; | 559 scoped_refptr<TileTask> high_quality_task; |
567 bool need_unref = controller.GetTaskForImageAndRef( | 560 bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image, |
568 high_quality_draw_image, ImageDecodeController::TracingInfo(), | 561 ImageDecodeCache::TracingInfo(), |
569 &high_quality_task); | 562 &high_quality_task); |
570 EXPECT_TRUE(need_unref); | 563 EXPECT_TRUE(need_unref); |
571 EXPECT_TRUE(high_quality_task); | 564 EXPECT_TRUE(high_quality_task); |
572 | 565 |
573 DrawImage low_quality_draw_image( | 566 DrawImage low_quality_draw_image( |
574 image, SkIRect::MakeWH(image->width(), image->height()), | 567 image, SkIRect::MakeWH(image->width(), image->height()), |
575 kLow_SkFilterQuality, | 568 kLow_SkFilterQuality, |
576 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 569 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
577 scoped_refptr<TileTask> low_quality_task; | 570 scoped_refptr<TileTask> low_quality_task; |
578 need_unref = controller.GetTaskForImageAndRef( | 571 need_unref = cache.GetTaskForImageAndRef(low_quality_draw_image, |
579 low_quality_draw_image, ImageDecodeController::TracingInfo(), | 572 ImageDecodeCache::TracingInfo(), |
580 &low_quality_task); | 573 &low_quality_task); |
581 EXPECT_TRUE(need_unref); | 574 EXPECT_TRUE(need_unref); |
582 EXPECT_TRUE(low_quality_task); | 575 EXPECT_TRUE(low_quality_task); |
583 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); | 576 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); |
584 | 577 |
585 TestTileTaskRunner::ProcessTask(high_quality_task.get()); | 578 TestTileTaskRunner::ProcessTask(high_quality_task.get()); |
586 TestTileTaskRunner::ProcessTask(low_quality_task.get()); | 579 TestTileTaskRunner::ProcessTask(low_quality_task.get()); |
587 | 580 |
588 controller.UnrefImage(high_quality_draw_image); | 581 cache.UnrefImage(high_quality_draw_image); |
589 controller.UnrefImage(low_quality_draw_image); | 582 cache.UnrefImage(low_quality_draw_image); |
590 } | 583 } |
591 | 584 |
592 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { | 585 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) { |
593 TestSoftwareImageDecodeController controller; | 586 TestSoftwareImageDecodeCache cache; |
594 sk_sp<SkImage> image = CreateImage(100, 100); | 587 sk_sp<SkImage> image = CreateImage(100, 100); |
595 bool is_decomposable = true; | 588 bool is_decomposable = true; |
596 SkFilterQuality quality = kHigh_SkFilterQuality; | 589 SkFilterQuality quality = kHigh_SkFilterQuality; |
597 | 590 |
598 DrawImage half_size_draw_image( | 591 DrawImage half_size_draw_image( |
599 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 592 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
600 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 593 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
601 scoped_refptr<TileTask> half_size_task; | 594 scoped_refptr<TileTask> half_size_task; |
602 bool need_unref = controller.GetTaskForImageAndRef( | 595 bool need_unref = cache.GetTaskForImageAndRef( |
603 half_size_draw_image, ImageDecodeController::TracingInfo(), | 596 half_size_draw_image, ImageDecodeCache::TracingInfo(), &half_size_task); |
604 &half_size_task); | |
605 EXPECT_TRUE(need_unref); | 597 EXPECT_TRUE(need_unref); |
606 EXPECT_TRUE(half_size_task); | 598 EXPECT_TRUE(half_size_task); |
607 | 599 |
608 DrawImage quarter_size_draw_image( | 600 DrawImage quarter_size_draw_image( |
609 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 601 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
610 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 602 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
611 scoped_refptr<TileTask> quarter_size_task; | 603 scoped_refptr<TileTask> quarter_size_task; |
612 need_unref = controller.GetTaskForImageAndRef( | 604 need_unref = cache.GetTaskForImageAndRef(quarter_size_draw_image, |
613 quarter_size_draw_image, ImageDecodeController::TracingInfo(), | 605 ImageDecodeCache::TracingInfo(), |
614 &quarter_size_task); | 606 &quarter_size_task); |
615 EXPECT_TRUE(need_unref); | 607 EXPECT_TRUE(need_unref); |
616 EXPECT_TRUE(quarter_size_task); | 608 EXPECT_TRUE(quarter_size_task); |
617 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); | 609 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); |
618 | 610 |
619 TestTileTaskRunner::ProcessTask(half_size_task.get()); | 611 TestTileTaskRunner::ProcessTask(half_size_task.get()); |
620 TestTileTaskRunner::ProcessTask(quarter_size_task.get()); | 612 TestTileTaskRunner::ProcessTask(quarter_size_task.get()); |
621 | 613 |
622 controller.UnrefImage(half_size_draw_image); | 614 cache.UnrefImage(half_size_draw_image); |
623 controller.UnrefImage(quarter_size_draw_image); | 615 cache.UnrefImage(quarter_size_draw_image); |
624 } | 616 } |
625 | 617 |
626 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { | 618 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageDifferentImage) { |
627 TestSoftwareImageDecodeController controller; | 619 TestSoftwareImageDecodeCache cache; |
628 bool is_decomposable = true; | 620 bool is_decomposable = true; |
629 SkFilterQuality quality = kHigh_SkFilterQuality; | 621 SkFilterQuality quality = kHigh_SkFilterQuality; |
630 | 622 |
631 sk_sp<SkImage> first_image = CreateImage(100, 100); | 623 sk_sp<SkImage> first_image = CreateImage(100, 100); |
632 DrawImage first_draw_image( | 624 DrawImage first_draw_image( |
633 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 625 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
634 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 626 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
635 scoped_refptr<TileTask> first_task; | 627 scoped_refptr<TileTask> first_task; |
636 bool need_unref = controller.GetTaskForImageAndRef( | 628 bool need_unref = cache.GetTaskForImageAndRef( |
637 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | 629 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
638 EXPECT_TRUE(need_unref); | 630 EXPECT_TRUE(need_unref); |
639 EXPECT_TRUE(first_task); | 631 EXPECT_TRUE(first_task); |
640 | 632 |
641 sk_sp<SkImage> second_image = CreateImage(100, 100); | 633 sk_sp<SkImage> second_image = CreateImage(100, 100); |
642 DrawImage second_draw_image( | 634 DrawImage second_draw_image( |
643 second_image, | 635 second_image, |
644 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 636 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
645 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 637 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
646 scoped_refptr<TileTask> second_task; | 638 scoped_refptr<TileTask> second_task; |
647 need_unref = controller.GetTaskForImageAndRef( | 639 need_unref = cache.GetTaskForImageAndRef( |
648 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | 640 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
649 EXPECT_TRUE(need_unref); | 641 EXPECT_TRUE(need_unref); |
650 EXPECT_TRUE(second_task); | 642 EXPECT_TRUE(second_task); |
651 EXPECT_TRUE(first_task.get() != second_task.get()); | 643 EXPECT_TRUE(first_task.get() != second_task.get()); |
652 | 644 |
653 TestTileTaskRunner::ProcessTask(first_task.get()); | 645 TestTileTaskRunner::ProcessTask(first_task.get()); |
654 TestTileTaskRunner::ProcessTask(second_task.get()); | 646 TestTileTaskRunner::ProcessTask(second_task.get()); |
655 | 647 |
656 controller.UnrefImage(first_draw_image); | 648 cache.UnrefImage(first_draw_image); |
657 controller.UnrefImage(second_draw_image); | 649 cache.UnrefImage(second_draw_image); |
658 } | 650 } |
659 | 651 |
660 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { | 652 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyDecoded) { |
661 TestSoftwareImageDecodeController controller; | 653 TestSoftwareImageDecodeCache cache; |
662 bool is_decomposable = true; | 654 bool is_decomposable = true; |
663 SkFilterQuality quality = kHigh_SkFilterQuality; | 655 SkFilterQuality quality = kHigh_SkFilterQuality; |
664 | 656 |
665 sk_sp<SkImage> image = CreateImage(100, 100); | 657 sk_sp<SkImage> image = CreateImage(100, 100); |
666 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 658 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
667 quality, | 659 quality, |
668 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 660 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
669 scoped_refptr<TileTask> task; | 661 scoped_refptr<TileTask> task; |
670 bool need_unref = controller.GetTaskForImageAndRef( | 662 bool need_unref = cache.GetTaskForImageAndRef( |
671 draw_image, ImageDecodeController::TracingInfo(), &task); | 663 draw_image, ImageDecodeCache::TracingInfo(), &task); |
672 EXPECT_TRUE(need_unref); | 664 EXPECT_TRUE(need_unref); |
673 EXPECT_TRUE(task); | 665 EXPECT_TRUE(task); |
674 | 666 |
675 TestTileTaskRunner::ScheduleTask(task.get()); | 667 TestTileTaskRunner::ScheduleTask(task.get()); |
676 TestTileTaskRunner::RunTask(task.get()); | 668 TestTileTaskRunner::RunTask(task.get()); |
677 | 669 |
678 scoped_refptr<TileTask> another_task; | 670 scoped_refptr<TileTask> another_task; |
679 need_unref = controller.GetTaskForImageAndRef( | 671 need_unref = cache.GetTaskForImageAndRef( |
680 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 672 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
681 EXPECT_TRUE(need_unref); | 673 EXPECT_TRUE(need_unref); |
682 EXPECT_FALSE(another_task); | 674 EXPECT_FALSE(another_task); |
683 | 675 |
684 TestTileTaskRunner::CompleteTask(task.get()); | 676 TestTileTaskRunner::CompleteTask(task.get()); |
685 | 677 |
686 controller.UnrefImage(draw_image); | 678 cache.UnrefImage(draw_image); |
687 controller.UnrefImage(draw_image); | 679 cache.UnrefImage(draw_image); |
688 } | 680 } |
689 | 681 |
690 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { | 682 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyPrerolled) { |
691 TestSoftwareImageDecodeController controller; | 683 TestSoftwareImageDecodeCache cache; |
692 bool is_decomposable = true; | 684 bool is_decomposable = true; |
693 SkFilterQuality quality = kLow_SkFilterQuality; | 685 SkFilterQuality quality = kLow_SkFilterQuality; |
694 | 686 |
695 sk_sp<SkImage> image = CreateImage(100, 100); | 687 sk_sp<SkImage> image = CreateImage(100, 100); |
696 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 688 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
697 quality, | 689 quality, |
698 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 690 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
699 scoped_refptr<TileTask> task; | 691 scoped_refptr<TileTask> task; |
700 bool need_unref = controller.GetTaskForImageAndRef( | 692 bool need_unref = cache.GetTaskForImageAndRef( |
701 draw_image, ImageDecodeController::TracingInfo(), &task); | 693 draw_image, ImageDecodeCache::TracingInfo(), &task); |
702 EXPECT_TRUE(need_unref); | 694 EXPECT_TRUE(need_unref); |
703 EXPECT_TRUE(task); | 695 EXPECT_TRUE(task); |
704 | 696 |
705 TestTileTaskRunner::ScheduleTask(task.get()); | 697 TestTileTaskRunner::ScheduleTask(task.get()); |
706 TestTileTaskRunner::RunTask(task.get()); | 698 TestTileTaskRunner::RunTask(task.get()); |
707 | 699 |
708 scoped_refptr<TileTask> another_task; | 700 scoped_refptr<TileTask> another_task; |
709 need_unref = controller.GetTaskForImageAndRef( | 701 need_unref = cache.GetTaskForImageAndRef( |
710 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 702 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
711 EXPECT_TRUE(need_unref); | 703 EXPECT_TRUE(need_unref); |
712 EXPECT_FALSE(another_task); | 704 EXPECT_FALSE(another_task); |
713 | 705 |
714 TestTileTaskRunner::CompleteTask(task.get()); | 706 TestTileTaskRunner::CompleteTask(task.get()); |
715 | 707 |
716 scoped_refptr<TileTask> third_task; | 708 scoped_refptr<TileTask> third_task; |
717 need_unref = controller.GetTaskForImageAndRef( | 709 need_unref = cache.GetTaskForImageAndRef( |
718 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 710 draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
719 EXPECT_TRUE(need_unref); | 711 EXPECT_TRUE(need_unref); |
720 EXPECT_FALSE(third_task); | 712 EXPECT_FALSE(third_task); |
721 | 713 |
722 controller.UnrefImage(draw_image); | 714 cache.UnrefImage(draw_image); |
723 controller.UnrefImage(draw_image); | 715 cache.UnrefImage(draw_image); |
724 controller.UnrefImage(draw_image); | 716 cache.UnrefImage(draw_image); |
725 } | 717 } |
726 | 718 |
727 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { | 719 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) { |
728 TestSoftwareImageDecodeController controller; | 720 TestSoftwareImageDecodeCache cache; |
729 bool is_decomposable = true; | 721 bool is_decomposable = true; |
730 SkFilterQuality quality = kHigh_SkFilterQuality; | 722 SkFilterQuality quality = kHigh_SkFilterQuality; |
731 | 723 |
732 sk_sp<SkImage> image = CreateImage(100, 100); | 724 sk_sp<SkImage> image = CreateImage(100, 100); |
733 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 725 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
734 quality, | 726 quality, |
735 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 727 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
736 scoped_refptr<TileTask> task; | 728 scoped_refptr<TileTask> task; |
737 bool need_unref = controller.GetTaskForImageAndRef( | 729 bool need_unref = cache.GetTaskForImageAndRef( |
738 draw_image, ImageDecodeController::TracingInfo(), &task); | 730 draw_image, ImageDecodeCache::TracingInfo(), &task); |
739 EXPECT_TRUE(need_unref); | 731 EXPECT_TRUE(need_unref); |
740 EXPECT_TRUE(task); | 732 EXPECT_TRUE(task); |
741 | 733 |
742 scoped_refptr<TileTask> another_task; | 734 scoped_refptr<TileTask> another_task; |
743 need_unref = controller.GetTaskForImageAndRef( | 735 need_unref = cache.GetTaskForImageAndRef( |
744 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 736 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
745 EXPECT_TRUE(need_unref); | 737 EXPECT_TRUE(need_unref); |
746 EXPECT_TRUE(another_task.get() == task.get()); | 738 EXPECT_TRUE(another_task.get() == task.get()); |
747 | 739 |
748 // Didn't run the task, complete it (it was canceled). | 740 // Didn't run the task, complete it (it was canceled). |
749 TestTileTaskRunner::CancelTask(task.get()); | 741 TestTileTaskRunner::CancelTask(task.get()); |
750 TestTileTaskRunner::CompleteTask(task.get()); | 742 TestTileTaskRunner::CompleteTask(task.get()); |
751 | 743 |
752 // Fully cancel everything (so the raster would unref things). | 744 // Fully cancel everything (so the raster would unref things). |
753 controller.UnrefImage(draw_image); | 745 cache.UnrefImage(draw_image); |
754 controller.UnrefImage(draw_image); | 746 cache.UnrefImage(draw_image); |
755 | 747 |
756 // Here a new task is created. | 748 // Here a new task is created. |
757 scoped_refptr<TileTask> third_task; | 749 scoped_refptr<TileTask> third_task; |
758 need_unref = controller.GetTaskForImageAndRef( | 750 need_unref = cache.GetTaskForImageAndRef( |
759 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 751 draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
760 EXPECT_TRUE(need_unref); | 752 EXPECT_TRUE(need_unref); |
761 EXPECT_TRUE(third_task); | 753 EXPECT_TRUE(third_task); |
762 EXPECT_FALSE(third_task.get() == task.get()); | 754 EXPECT_FALSE(third_task.get() == task.get()); |
763 | 755 |
764 TestTileTaskRunner::ProcessTask(third_task.get()); | 756 TestTileTaskRunner::ProcessTask(third_task.get()); |
765 | 757 |
766 controller.UnrefImage(draw_image); | 758 cache.UnrefImage(draw_image); |
767 } | 759 } |
768 | 760 |
769 TEST(SoftwareImageDecodeControllerTest, | 761 TEST(SoftwareImageDecodeCacheTest, |
770 GetTaskForImageCanceledWhileReffedGetsNewTask) { | 762 GetTaskForImageCanceledWhileReffedGetsNewTask) { |
771 TestSoftwareImageDecodeController controller; | 763 TestSoftwareImageDecodeCache cache; |
772 bool is_decomposable = true; | 764 bool is_decomposable = true; |
773 SkFilterQuality quality = kHigh_SkFilterQuality; | 765 SkFilterQuality quality = kHigh_SkFilterQuality; |
774 | 766 |
775 sk_sp<SkImage> image = CreateImage(100, 100); | 767 sk_sp<SkImage> image = CreateImage(100, 100); |
776 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 768 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
777 quality, | 769 quality, |
778 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 770 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
779 scoped_refptr<TileTask> task; | 771 scoped_refptr<TileTask> task; |
780 bool need_unref = controller.GetTaskForImageAndRef( | 772 bool need_unref = cache.GetTaskForImageAndRef( |
781 draw_image, ImageDecodeController::TracingInfo(), &task); | 773 draw_image, ImageDecodeCache::TracingInfo(), &task); |
782 EXPECT_TRUE(need_unref); | 774 EXPECT_TRUE(need_unref); |
783 EXPECT_TRUE(task); | 775 EXPECT_TRUE(task); |
784 | 776 |
785 scoped_refptr<TileTask> another_task; | 777 scoped_refptr<TileTask> another_task; |
786 need_unref = controller.GetTaskForImageAndRef( | 778 need_unref = cache.GetTaskForImageAndRef( |
787 draw_image, ImageDecodeController::TracingInfo(), &another_task); | 779 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
788 EXPECT_TRUE(need_unref); | 780 EXPECT_TRUE(need_unref); |
789 EXPECT_TRUE(another_task.get() == task.get()); | 781 EXPECT_TRUE(another_task.get() == task.get()); |
790 | 782 |
791 // Didn't run the task, complete it (it was canceled). | 783 // Didn't run the task, complete it (it was canceled). |
792 TestTileTaskRunner::CancelTask(task.get()); | 784 TestTileTaskRunner::CancelTask(task.get()); |
793 TestTileTaskRunner::CompleteTask(task.get()); | 785 TestTileTaskRunner::CompleteTask(task.get()); |
794 | 786 |
795 // Note that here, everything is reffed, but a new task is created. This is | 787 // Note that here, everything is reffed, but a new task is created. This is |
796 // possible with repeated schedule/cancel operations. | 788 // possible with repeated schedule/cancel operations. |
797 scoped_refptr<TileTask> third_task; | 789 scoped_refptr<TileTask> third_task; |
798 need_unref = controller.GetTaskForImageAndRef( | 790 need_unref = cache.GetTaskForImageAndRef( |
799 draw_image, ImageDecodeController::TracingInfo(), &third_task); | 791 draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
800 EXPECT_TRUE(need_unref); | 792 EXPECT_TRUE(need_unref); |
801 EXPECT_TRUE(third_task); | 793 EXPECT_TRUE(third_task); |
802 EXPECT_FALSE(third_task.get() == task.get()); | 794 EXPECT_FALSE(third_task.get() == task.get()); |
803 | 795 |
804 TestTileTaskRunner::ProcessTask(third_task.get()); | 796 TestTileTaskRunner::ProcessTask(third_task.get()); |
805 | 797 |
806 // 3 Unrefs! | 798 // 3 Unrefs! |
807 controller.UnrefImage(draw_image); | 799 cache.UnrefImage(draw_image); |
808 controller.UnrefImage(draw_image); | 800 cache.UnrefImage(draw_image); |
809 controller.UnrefImage(draw_image); | 801 cache.UnrefImage(draw_image); |
810 } | 802 } |
811 | 803 |
812 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { | 804 TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDraw) { |
813 TestSoftwareImageDecodeController controller; | 805 TestSoftwareImageDecodeCache cache; |
814 bool is_decomposable = true; | 806 bool is_decomposable = true; |
815 SkFilterQuality quality = kHigh_SkFilterQuality; | 807 SkFilterQuality quality = kHigh_SkFilterQuality; |
816 | 808 |
817 sk_sp<SkImage> image = CreateImage(100, 100); | 809 sk_sp<SkImage> image = CreateImage(100, 100); |
818 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 810 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
819 quality, | 811 quality, |
820 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 812 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
821 scoped_refptr<TileTask> task; | 813 scoped_refptr<TileTask> task; |
822 bool need_unref = controller.GetTaskForImageAndRef( | 814 bool need_unref = cache.GetTaskForImageAndRef( |
823 draw_image, ImageDecodeController::TracingInfo(), &task); | 815 draw_image, ImageDecodeCache::TracingInfo(), &task); |
824 EXPECT_TRUE(need_unref); | 816 EXPECT_TRUE(need_unref); |
825 EXPECT_TRUE(task); | 817 EXPECT_TRUE(task); |
826 | 818 |
827 TestTileTaskRunner::ProcessTask(task.get()); | 819 TestTileTaskRunner::ProcessTask(task.get()); |
828 | 820 |
829 DecodedDrawImage decoded_draw_image = | 821 DecodedDrawImage decoded_draw_image = |
830 controller.GetDecodedImageForDraw(draw_image); | 822 cache.GetDecodedImageForDraw(draw_image); |
831 EXPECT_TRUE(decoded_draw_image.image()); | 823 EXPECT_TRUE(decoded_draw_image.image()); |
832 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 824 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
833 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 825 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
834 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 826 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
835 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 827 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
836 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 828 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
837 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 829 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
838 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | 830 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); |
839 | 831 |
840 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 832 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
841 controller.UnrefImage(draw_image); | 833 cache.UnrefImage(draw_image); |
842 } | 834 } |
843 | 835 |
844 TEST(SoftwareImageDecodeControllerTest, | 836 TEST(SoftwareImageDecodeCacheTest, |
845 GetDecodedImageForDrawWithNonContainedSrcRect) { | 837 GetDecodedImageForDrawWithNonContainedSrcRect) { |
846 TestSoftwareImageDecodeController controller; | 838 TestSoftwareImageDecodeCache cache; |
847 bool is_decomposable = true; | 839 bool is_decomposable = true; |
848 SkFilterQuality quality = kHigh_SkFilterQuality; | 840 SkFilterQuality quality = kHigh_SkFilterQuality; |
849 | 841 |
850 sk_sp<SkImage> image = CreateImage(100, 100); | 842 sk_sp<SkImage> image = CreateImage(100, 100); |
851 DrawImage draw_image( | 843 DrawImage draw_image( |
852 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 844 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), |
853 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 845 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
854 scoped_refptr<TileTask> task; | 846 scoped_refptr<TileTask> task; |
855 bool need_unref = controller.GetTaskForImageAndRef( | 847 bool need_unref = cache.GetTaskForImageAndRef( |
856 draw_image, ImageDecodeController::TracingInfo(), &task); | 848 draw_image, ImageDecodeCache::TracingInfo(), &task); |
857 EXPECT_TRUE(need_unref); | 849 EXPECT_TRUE(need_unref); |
858 EXPECT_TRUE(task); | 850 EXPECT_TRUE(task); |
859 | 851 |
860 TestTileTaskRunner::ProcessTask(task.get()); | 852 TestTileTaskRunner::ProcessTask(task.get()); |
861 | 853 |
862 DecodedDrawImage decoded_draw_image = | 854 DecodedDrawImage decoded_draw_image = |
863 controller.GetDecodedImageForDraw(draw_image); | 855 cache.GetDecodedImageForDraw(draw_image); |
864 EXPECT_TRUE(decoded_draw_image.image()); | 856 EXPECT_TRUE(decoded_draw_image.image()); |
865 EXPECT_EQ(40, decoded_draw_image.image()->width()); | 857 EXPECT_EQ(40, decoded_draw_image.image()->width()); |
866 EXPECT_EQ(35, decoded_draw_image.image()->height()); | 858 EXPECT_EQ(35, decoded_draw_image.image()->height()); |
867 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 859 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
868 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 860 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
869 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 861 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
870 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 862 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
871 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | 863 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); |
872 | 864 |
873 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 865 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
874 controller.UnrefImage(draw_image); | 866 cache.UnrefImage(draw_image); |
875 } | 867 } |
876 | 868 |
877 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) { | 869 TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) { |
878 TestSoftwareImageDecodeController controller; | 870 TestSoftwareImageDecodeCache cache; |
879 bool is_decomposable = true; | 871 bool is_decomposable = true; |
880 SkFilterQuality quality = kHigh_SkFilterQuality; | 872 SkFilterQuality quality = kHigh_SkFilterQuality; |
881 | 873 |
882 sk_sp<SkImage> image = CreateImage(100, 100); | 874 sk_sp<SkImage> image = CreateImage(100, 100); |
883 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 875 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
884 quality, | 876 quality, |
885 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 877 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
886 | 878 |
887 DecodedDrawImage decoded_draw_image = | 879 DecodedDrawImage decoded_draw_image = |
888 controller.GetDecodedImageForDraw(draw_image); | 880 cache.GetDecodedImageForDraw(draw_image); |
889 EXPECT_TRUE(decoded_draw_image.image()); | 881 EXPECT_TRUE(decoded_draw_image.image()); |
890 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 882 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
891 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 883 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
892 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 884 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
893 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 885 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
894 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 886 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
895 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 887 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
896 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 888 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
897 | 889 |
898 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 890 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
899 } | 891 } |
900 | 892 |
901 TEST(SoftwareImageDecodeControllerTest, | 893 TEST(SoftwareImageDecodeCacheTest, |
902 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { | 894 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
903 TestSoftwareImageDecodeController controller; | 895 TestSoftwareImageDecodeCache cache; |
904 bool is_decomposable = true; | 896 bool is_decomposable = true; |
905 SkFilterQuality quality = kHigh_SkFilterQuality; | 897 SkFilterQuality quality = kHigh_SkFilterQuality; |
906 | 898 |
907 sk_sp<SkImage> image = CreateImage(100, 100); | 899 sk_sp<SkImage> image = CreateImage(100, 100); |
908 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 900 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
909 quality, | 901 quality, |
910 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 902 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
911 | 903 |
912 DecodedDrawImage decoded_draw_image = | 904 DecodedDrawImage decoded_draw_image = |
913 controller.GetDecodedImageForDraw(draw_image); | 905 cache.GetDecodedImageForDraw(draw_image); |
914 EXPECT_TRUE(decoded_draw_image.image()); | 906 EXPECT_TRUE(decoded_draw_image.image()); |
915 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 907 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
916 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 908 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
917 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 909 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
918 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 910 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
919 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 911 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
920 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 912 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
921 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 913 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
922 | 914 |
923 DecodedDrawImage another_decoded_draw_image = | 915 DecodedDrawImage another_decoded_draw_image = |
924 controller.GetDecodedImageForDraw(draw_image); | 916 cache.GetDecodedImageForDraw(draw_image); |
925 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | 917 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
926 another_decoded_draw_image.image()->uniqueID()); | 918 another_decoded_draw_image.image()->uniqueID()); |
927 | 919 |
928 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 920 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
929 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 921 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
930 } | 922 } |
931 | 923 |
932 TEST(SoftwareImageDecodeControllerTest, | 924 TEST(SoftwareImageDecodeCacheTest, |
933 GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) { | 925 GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) { |
934 TestSoftwareImageDecodeController controller; | 926 TestSoftwareImageDecodeCache cache; |
935 bool is_decomposable = true; | 927 bool is_decomposable = true; |
936 SkFilterQuality quality = kHigh_SkFilterQuality; | 928 SkFilterQuality quality = kHigh_SkFilterQuality; |
937 | 929 |
938 sk_sp<SkImage> image = CreateImage(100, 100); | 930 sk_sp<SkImage> image = CreateImage(100, 100); |
939 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 931 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
940 quality, | 932 quality, |
941 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 933 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
942 | 934 |
943 DecodedDrawImage decoded_draw_image = | 935 DecodedDrawImage decoded_draw_image = |
944 controller.GetDecodedImageForDraw(draw_image); | 936 cache.GetDecodedImageForDraw(draw_image); |
945 EXPECT_TRUE(decoded_draw_image.image()); | 937 EXPECT_TRUE(decoded_draw_image.image()); |
946 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 938 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
947 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 939 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
948 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 940 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
949 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 941 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
950 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 942 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
951 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 943 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
952 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 944 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
953 | 945 |
954 scoped_refptr<TileTask> task; | 946 scoped_refptr<TileTask> task; |
955 bool need_unref = controller.GetTaskForImageAndRef( | 947 bool need_unref = cache.GetTaskForImageAndRef( |
956 draw_image, ImageDecodeController::TracingInfo(), &task); | 948 draw_image, ImageDecodeCache::TracingInfo(), &task); |
957 EXPECT_TRUE(need_unref); | 949 EXPECT_TRUE(need_unref); |
958 EXPECT_TRUE(task); | 950 EXPECT_TRUE(task); |
959 | 951 |
960 TestTileTaskRunner::ProcessTask(task.get()); | 952 TestTileTaskRunner::ProcessTask(task.get()); |
961 | 953 |
962 DecodedDrawImage another_decoded_draw_image = | 954 DecodedDrawImage another_decoded_draw_image = |
963 controller.GetDecodedImageForDraw(draw_image); | 955 cache.GetDecodedImageForDraw(draw_image); |
964 // This should get the new decoded/locked image, not the one we're using at | 956 // This should get the new decoded/locked image, not the one we're using at |
965 // raster. | 957 // raster. |
966 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves | 958 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves |
967 // the image to the right spot. | 959 // the image to the right spot. |
968 EXPECT_NE(decoded_draw_image.image()->uniqueID(), | 960 EXPECT_NE(decoded_draw_image.image()->uniqueID(), |
969 another_decoded_draw_image.image()->uniqueID()); | 961 another_decoded_draw_image.image()->uniqueID()); |
970 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); | 962 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); |
971 | 963 |
972 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 964 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
973 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 965 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
974 controller.UnrefImage(draw_image); | 966 cache.UnrefImage(draw_image); |
975 } | 967 } |
976 | 968 |
977 TEST(SoftwareImageDecodeControllerTest, | 969 TEST(SoftwareImageDecodeCacheTest, |
978 GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) { | 970 GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) { |
979 TestSoftwareImageDecodeController controller; | 971 TestSoftwareImageDecodeCache cache; |
980 bool is_decomposable = true; | 972 bool is_decomposable = true; |
981 SkFilterQuality quality = kHigh_SkFilterQuality; | 973 SkFilterQuality quality = kHigh_SkFilterQuality; |
982 | 974 |
983 sk_sp<SkImage> image = CreateImage(100, 100); | 975 sk_sp<SkImage> image = CreateImage(100, 100); |
984 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 976 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
985 quality, | 977 quality, |
986 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 978 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
987 | 979 |
988 DecodedDrawImage decoded_draw_image = | 980 DecodedDrawImage decoded_draw_image = |
989 controller.GetDecodedImageForDraw(draw_image); | 981 cache.GetDecodedImageForDraw(draw_image); |
990 EXPECT_TRUE(decoded_draw_image.image()); | 982 EXPECT_TRUE(decoded_draw_image.image()); |
991 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 983 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
992 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 984 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
993 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 985 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
994 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 986 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
995 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 987 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
996 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 988 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
997 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 989 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
998 | 990 |
999 scoped_refptr<TileTask> task; | 991 scoped_refptr<TileTask> task; |
1000 bool need_unref = controller.GetTaskForImageAndRef( | 992 bool need_unref = cache.GetTaskForImageAndRef( |
1001 draw_image, ImageDecodeController::TracingInfo(), &task); | 993 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1002 EXPECT_TRUE(need_unref); | 994 EXPECT_TRUE(need_unref); |
1003 EXPECT_TRUE(task); | 995 EXPECT_TRUE(task); |
1004 | 996 |
1005 // If we finish the draw here, then we will use it for the locked decode | 997 // If we finish the draw here, then we will use it for the locked decode |
1006 // instead of decoding again. | 998 // instead of decoding again. |
1007 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 999 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1008 | 1000 |
1009 TestTileTaskRunner::ProcessTask(task.get()); | 1001 TestTileTaskRunner::ProcessTask(task.get()); |
1010 | 1002 |
1011 DecodedDrawImage another_decoded_draw_image = | 1003 DecodedDrawImage another_decoded_draw_image = |
1012 controller.GetDecodedImageForDraw(draw_image); | 1004 cache.GetDecodedImageForDraw(draw_image); |
1013 // This should get the decoded/locked image which we originally decoded at | 1005 // This should get the decoded/locked image which we originally decoded at |
1014 // raster time, since it's now in the locked cache. | 1006 // raster time, since it's now in the locked cache. |
1015 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | 1007 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
1016 another_decoded_draw_image.image()->uniqueID()); | 1008 another_decoded_draw_image.image()->uniqueID()); |
1017 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); | 1009 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode()); |
1018 | 1010 |
1019 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 1011 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
1020 controller.UnrefImage(draw_image); | 1012 cache.UnrefImage(draw_image); |
1021 } | 1013 } |
1022 | 1014 |
1023 TEST(SoftwareImageDecodeControllerTest, ZeroSizedImagesAreSkipped) { | 1015 TEST(SoftwareImageDecodeCacheTest, ZeroSizedImagesAreSkipped) { |
1024 TestSoftwareImageDecodeController controller; | 1016 TestSoftwareImageDecodeCache cache; |
1025 bool is_decomposable = true; | 1017 bool is_decomposable = true; |
1026 SkFilterQuality quality = kHigh_SkFilterQuality; | 1018 SkFilterQuality quality = kHigh_SkFilterQuality; |
1027 | 1019 |
1028 sk_sp<SkImage> image = CreateImage(100, 100); | 1020 sk_sp<SkImage> image = CreateImage(100, 100); |
1029 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1021 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1030 quality, | 1022 quality, |
1031 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); | 1023 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); |
1032 | 1024 |
1033 scoped_refptr<TileTask> task; | 1025 scoped_refptr<TileTask> task; |
1034 bool need_unref = controller.GetTaskForImageAndRef( | 1026 bool need_unref = cache.GetTaskForImageAndRef( |
1035 draw_image, ImageDecodeController::TracingInfo(), &task); | 1027 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1036 EXPECT_FALSE(task); | 1028 EXPECT_FALSE(task); |
1037 EXPECT_FALSE(need_unref); | 1029 EXPECT_FALSE(need_unref); |
1038 | 1030 |
1039 DecodedDrawImage decoded_draw_image = | 1031 DecodedDrawImage decoded_draw_image = |
1040 controller.GetDecodedImageForDraw(draw_image); | 1032 cache.GetDecodedImageForDraw(draw_image); |
1041 EXPECT_FALSE(decoded_draw_image.image()); | 1033 EXPECT_FALSE(decoded_draw_image.image()); |
1042 | 1034 |
1043 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1035 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1044 } | 1036 } |
1045 | 1037 |
1046 TEST(SoftwareImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { | 1038 TEST(SoftwareImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) { |
1047 TestSoftwareImageDecodeController controller; | 1039 TestSoftwareImageDecodeCache cache; |
1048 bool is_decomposable = true; | 1040 bool is_decomposable = true; |
1049 SkFilterQuality quality = kHigh_SkFilterQuality; | 1041 SkFilterQuality quality = kHigh_SkFilterQuality; |
1050 | 1042 |
1051 sk_sp<SkImage> image = CreateImage(100, 100); | 1043 sk_sp<SkImage> image = CreateImage(100, 100); |
1052 DrawImage draw_image( | 1044 DrawImage draw_image( |
1053 image, SkIRect::MakeXYWH(150, 150, image->width(), image->height()), | 1045 image, SkIRect::MakeXYWH(150, 150, image->width(), image->height()), |
1054 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 1046 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
1055 | 1047 |
1056 scoped_refptr<TileTask> task; | 1048 scoped_refptr<TileTask> task; |
1057 bool need_unref = controller.GetTaskForImageAndRef( | 1049 bool need_unref = cache.GetTaskForImageAndRef( |
1058 draw_image, ImageDecodeController::TracingInfo(), &task); | 1050 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1059 EXPECT_FALSE(task); | 1051 EXPECT_FALSE(task); |
1060 EXPECT_FALSE(need_unref); | 1052 EXPECT_FALSE(need_unref); |
1061 | 1053 |
1062 DecodedDrawImage decoded_draw_image = | 1054 DecodedDrawImage decoded_draw_image = |
1063 controller.GetDecodedImageForDraw(draw_image); | 1055 cache.GetDecodedImageForDraw(draw_image); |
1064 EXPECT_FALSE(decoded_draw_image.image()); | 1056 EXPECT_FALSE(decoded_draw_image.image()); |
1065 | 1057 |
1066 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1058 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1067 } | 1059 } |
1068 | 1060 |
1069 TEST(SoftwareImageDecodeControllerTest, LowQualityFilterIsHandled) { | 1061 TEST(SoftwareImageDecodeCacheTest, LowQualityFilterIsHandled) { |
1070 TestSoftwareImageDecodeController controller; | 1062 TestSoftwareImageDecodeCache cache; |
1071 bool is_decomposable = true; | 1063 bool is_decomposable = true; |
1072 SkFilterQuality quality = kLow_SkFilterQuality; | 1064 SkFilterQuality quality = kLow_SkFilterQuality; |
1073 | 1065 |
1074 sk_sp<SkImage> image = CreateImage(100, 100); | 1066 sk_sp<SkImage> image = CreateImage(100, 100); |
1075 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1067 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1076 quality, | 1068 quality, |
1077 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 1069 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
1078 | 1070 |
1079 scoped_refptr<TileTask> task; | 1071 scoped_refptr<TileTask> task; |
1080 bool need_unref = controller.GetTaskForImageAndRef( | 1072 bool need_unref = cache.GetTaskForImageAndRef( |
1081 draw_image, ImageDecodeController::TracingInfo(), &task); | 1073 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1082 EXPECT_TRUE(task); | 1074 EXPECT_TRUE(task); |
1083 EXPECT_TRUE(need_unref); | 1075 EXPECT_TRUE(need_unref); |
1084 | 1076 |
1085 TestTileTaskRunner::ProcessTask(task.get()); | 1077 TestTileTaskRunner::ProcessTask(task.get()); |
1086 | 1078 |
1087 DecodedDrawImage decoded_draw_image = | 1079 DecodedDrawImage decoded_draw_image = |
1088 controller.GetDecodedImageForDraw(draw_image); | 1080 cache.GetDecodedImageForDraw(draw_image); |
1089 EXPECT_TRUE(decoded_draw_image.image()); | 1081 EXPECT_TRUE(decoded_draw_image.image()); |
1090 // If we decoded the image and cached it, it would be stored in a different | 1082 // If we decoded the image and cached it, it would be stored in a different |
1091 // SkImage object. | 1083 // SkImage object. |
1092 EXPECT_TRUE(decoded_draw_image.image() != image); | 1084 EXPECT_TRUE(decoded_draw_image.image() != image); |
1093 | 1085 |
1094 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1086 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1095 controller.UnrefImage(draw_image); | 1087 cache.UnrefImage(draw_image); |
1096 } | 1088 } |
1097 | 1089 |
1098 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { | 1090 TEST(SoftwareImageDecodeCacheTest, LowQualityScaledSubrectIsHandled) { |
1099 TestSoftwareImageDecodeController controller; | 1091 TestSoftwareImageDecodeCache cache; |
1100 bool is_decomposable = true; | 1092 bool is_decomposable = true; |
1101 SkFilterQuality quality = kLow_SkFilterQuality; | 1093 SkFilterQuality quality = kLow_SkFilterQuality; |
1102 | 1094 |
1103 sk_sp<SkImage> image = CreateImage(100, 100); | 1095 sk_sp<SkImage> image = CreateImage(100, 100); |
1104 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1096 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
1105 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1097 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1106 | 1098 |
1107 scoped_refptr<TileTask> task; | 1099 scoped_refptr<TileTask> task; |
1108 bool need_unref = controller.GetTaskForImageAndRef( | 1100 bool need_unref = cache.GetTaskForImageAndRef( |
1109 draw_image, ImageDecodeController::TracingInfo(), &task); | 1101 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1110 EXPECT_TRUE(task); | 1102 EXPECT_TRUE(task); |
1111 EXPECT_TRUE(need_unref); | 1103 EXPECT_TRUE(need_unref); |
1112 | 1104 |
1113 TestTileTaskRunner::ProcessTask(task.get()); | 1105 TestTileTaskRunner::ProcessTask(task.get()); |
1114 | 1106 |
1115 DecodedDrawImage decoded_draw_image = | 1107 DecodedDrawImage decoded_draw_image = |
1116 controller.GetDecodedImageForDraw(draw_image); | 1108 cache.GetDecodedImageForDraw(draw_image); |
1117 EXPECT_TRUE(decoded_draw_image.image()); | 1109 EXPECT_TRUE(decoded_draw_image.image()); |
1118 // If we decoded the image and cached it, it would be stored in a different | 1110 // If we decoded the image and cached it, it would be stored in a different |
1119 // SkImage object. | 1111 // SkImage object. |
1120 EXPECT_TRUE(decoded_draw_image.image() != image); | 1112 EXPECT_TRUE(decoded_draw_image.image() != image); |
1121 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1113 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1122 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1114 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
1123 | 1115 |
1124 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1116 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1125 controller.UnrefImage(draw_image); | 1117 cache.UnrefImage(draw_image); |
1126 } | 1118 } |
1127 | 1119 |
1128 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { | 1120 TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) { |
1129 TestSoftwareImageDecodeController controller; | 1121 TestSoftwareImageDecodeCache cache; |
1130 bool is_decomposable = true; | 1122 bool is_decomposable = true; |
1131 SkFilterQuality quality = kNone_SkFilterQuality; | 1123 SkFilterQuality quality = kNone_SkFilterQuality; |
1132 | 1124 |
1133 sk_sp<SkImage> image = CreateImage(100, 100); | 1125 sk_sp<SkImage> image = CreateImage(100, 100); |
1134 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1126 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
1135 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1127 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1136 | 1128 |
1137 scoped_refptr<TileTask> task; | 1129 scoped_refptr<TileTask> task; |
1138 bool need_unref = controller.GetTaskForImageAndRef( | 1130 bool need_unref = cache.GetTaskForImageAndRef( |
1139 draw_image, ImageDecodeController::TracingInfo(), &task); | 1131 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1140 EXPECT_TRUE(task); | 1132 EXPECT_TRUE(task); |
1141 EXPECT_TRUE(need_unref); | 1133 EXPECT_TRUE(need_unref); |
1142 | 1134 |
1143 TestTileTaskRunner::ProcessTask(task.get()); | 1135 TestTileTaskRunner::ProcessTask(task.get()); |
1144 | 1136 |
1145 DecodedDrawImage decoded_draw_image = | 1137 DecodedDrawImage decoded_draw_image = |
1146 controller.GetDecodedImageForDraw(draw_image); | 1138 cache.GetDecodedImageForDraw(draw_image); |
1147 EXPECT_TRUE(decoded_draw_image.image()); | 1139 EXPECT_TRUE(decoded_draw_image.image()); |
1148 // If we decoded the image and cached it, it would be stored in a different | 1140 // If we decoded the image and cached it, it would be stored in a different |
1149 // SkImage object. | 1141 // SkImage object. |
1150 EXPECT_TRUE(decoded_draw_image.image() != image); | 1142 EXPECT_TRUE(decoded_draw_image.image() != image); |
1151 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); | 1143 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); |
1152 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1144 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
1153 | 1145 |
1154 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1146 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1155 controller.UnrefImage(draw_image); | 1147 cache.UnrefImage(draw_image); |
1156 } | 1148 } |
1157 | 1149 |
1158 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) { | 1150 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt01_5ScaleIsHandled) { |
1159 TestSoftwareImageDecodeController controller; | 1151 TestSoftwareImageDecodeCache cache; |
1160 bool is_decomposable = true; | 1152 bool is_decomposable = true; |
1161 SkFilterQuality quality = kMedium_SkFilterQuality; | 1153 SkFilterQuality quality = kMedium_SkFilterQuality; |
1162 | 1154 |
1163 sk_sp<SkImage> image = CreateImage(500, 200); | 1155 sk_sp<SkImage> image = CreateImage(500, 200); |
1164 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1156 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1165 quality, | 1157 quality, |
1166 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | 1158 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
1167 | 1159 |
1168 scoped_refptr<TileTask> task; | 1160 scoped_refptr<TileTask> task; |
1169 bool need_unref = controller.GetTaskForImageAndRef( | 1161 bool need_unref = cache.GetTaskForImageAndRef( |
1170 draw_image, ImageDecodeController::TracingInfo(), &task); | 1162 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1171 EXPECT_TRUE(task); | 1163 EXPECT_TRUE(task); |
1172 EXPECT_TRUE(need_unref); | 1164 EXPECT_TRUE(need_unref); |
1173 | 1165 |
1174 TestTileTaskRunner::ProcessTask(task.get()); | 1166 TestTileTaskRunner::ProcessTask(task.get()); |
1175 | 1167 |
1176 DecodedDrawImage decoded_draw_image = | 1168 DecodedDrawImage decoded_draw_image = |
1177 controller.GetDecodedImageForDraw(draw_image); | 1169 cache.GetDecodedImageForDraw(draw_image); |
1178 EXPECT_TRUE(decoded_draw_image.image()); | 1170 EXPECT_TRUE(decoded_draw_image.image()); |
1179 // If we decoded the image and cached it, it would be stored in a different | 1171 // If we decoded the image and cached it, it would be stored in a different |
1180 // SkImageObject. | 1172 // SkImageObject. |
1181 EXPECT_TRUE(decoded_draw_image.image() != image); | 1173 EXPECT_TRUE(decoded_draw_image.image() != image); |
1182 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1174 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1183 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1175 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1184 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1176 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1185 | 1177 |
1186 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1178 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1187 controller.UnrefImage(draw_image); | 1179 cache.UnrefImage(draw_image); |
1188 } | 1180 } |
1189 | 1181 |
1190 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt1_0ScaleIsHandled) { | 1182 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt1_0ScaleIsHandled) { |
1191 TestSoftwareImageDecodeController controller; | 1183 TestSoftwareImageDecodeCache cache; |
1192 bool is_decomposable = true; | 1184 bool is_decomposable = true; |
1193 SkFilterQuality quality = kMedium_SkFilterQuality; | 1185 SkFilterQuality quality = kMedium_SkFilterQuality; |
1194 | 1186 |
1195 sk_sp<SkImage> image = CreateImage(500, 200); | 1187 sk_sp<SkImage> image = CreateImage(500, 200); |
1196 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1188 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1197 quality, | 1189 quality, |
1198 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 1190 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
1199 | 1191 |
1200 scoped_refptr<TileTask> task; | 1192 scoped_refptr<TileTask> task; |
1201 bool need_unref = controller.GetTaskForImageAndRef( | 1193 bool need_unref = cache.GetTaskForImageAndRef( |
1202 draw_image, ImageDecodeController::TracingInfo(), &task); | 1194 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1203 EXPECT_TRUE(task); | 1195 EXPECT_TRUE(task); |
1204 EXPECT_TRUE(need_unref); | 1196 EXPECT_TRUE(need_unref); |
1205 | 1197 |
1206 TestTileTaskRunner::ProcessTask(task.get()); | 1198 TestTileTaskRunner::ProcessTask(task.get()); |
1207 | 1199 |
1208 DecodedDrawImage decoded_draw_image = | 1200 DecodedDrawImage decoded_draw_image = |
1209 controller.GetDecodedImageForDraw(draw_image); | 1201 cache.GetDecodedImageForDraw(draw_image); |
1210 EXPECT_TRUE(decoded_draw_image.image()); | 1202 EXPECT_TRUE(decoded_draw_image.image()); |
1211 // If we decoded the image and cached it, it would be stored in a different | 1203 // If we decoded the image and cached it, it would be stored in a different |
1212 // SkImageObject. | 1204 // SkImageObject. |
1213 EXPECT_TRUE(decoded_draw_image.image() != image); | 1205 EXPECT_TRUE(decoded_draw_image.image() != image); |
1214 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1206 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1215 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1207 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1216 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1208 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1217 | 1209 |
1218 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1210 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1219 controller.UnrefImage(draw_image); | 1211 cache.UnrefImage(draw_image); |
1220 } | 1212 } |
1221 | 1213 |
1222 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_75ScaleIsHandled) { | 1214 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_75ScaleIsHandled) { |
1223 TestSoftwareImageDecodeController controller; | 1215 TestSoftwareImageDecodeCache cache; |
1224 bool is_decomposable = true; | 1216 bool is_decomposable = true; |
1225 SkFilterQuality quality = kMedium_SkFilterQuality; | 1217 SkFilterQuality quality = kMedium_SkFilterQuality; |
1226 | 1218 |
1227 sk_sp<SkImage> image = CreateImage(500, 200); | 1219 sk_sp<SkImage> image = CreateImage(500, 200); |
1228 DrawImage draw_image( | 1220 DrawImage draw_image( |
1229 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1221 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1230 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable)); | 1222 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable)); |
1231 | 1223 |
1232 scoped_refptr<TileTask> task; | 1224 scoped_refptr<TileTask> task; |
1233 bool need_unref = controller.GetTaskForImageAndRef( | 1225 bool need_unref = cache.GetTaskForImageAndRef( |
1234 draw_image, ImageDecodeController::TracingInfo(), &task); | 1226 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1235 EXPECT_TRUE(task); | 1227 EXPECT_TRUE(task); |
1236 EXPECT_TRUE(need_unref); | 1228 EXPECT_TRUE(need_unref); |
1237 | 1229 |
1238 TestTileTaskRunner::ProcessTask(task.get()); | 1230 TestTileTaskRunner::ProcessTask(task.get()); |
1239 | 1231 |
1240 DecodedDrawImage decoded_draw_image = | 1232 DecodedDrawImage decoded_draw_image = |
1241 controller.GetDecodedImageForDraw(draw_image); | 1233 cache.GetDecodedImageForDraw(draw_image); |
1242 EXPECT_TRUE(decoded_draw_image.image()); | 1234 EXPECT_TRUE(decoded_draw_image.image()); |
1243 // If we decoded the image and cached it, it would be stored in a different | 1235 // If we decoded the image and cached it, it would be stored in a different |
1244 // SkImageObject. | 1236 // SkImageObject. |
1245 EXPECT_TRUE(decoded_draw_image.image() != image); | 1237 EXPECT_TRUE(decoded_draw_image.image() != image); |
1246 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1238 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1247 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1239 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1248 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1240 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1249 | 1241 |
1250 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1242 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1251 controller.UnrefImage(draw_image); | 1243 cache.UnrefImage(draw_image); |
1252 } | 1244 } |
1253 | 1245 |
1254 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_5ScaleIsHandled) { | 1246 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_5ScaleIsHandled) { |
1255 TestSoftwareImageDecodeController controller; | 1247 TestSoftwareImageDecodeCache cache; |
1256 bool is_decomposable = true; | 1248 bool is_decomposable = true; |
1257 SkFilterQuality quality = kMedium_SkFilterQuality; | 1249 SkFilterQuality quality = kMedium_SkFilterQuality; |
1258 | 1250 |
1259 sk_sp<SkImage> image = CreateImage(500, 200); | 1251 sk_sp<SkImage> image = CreateImage(500, 200); |
1260 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1252 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1261 quality, | 1253 quality, |
1262 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1254 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1263 | 1255 |
1264 scoped_refptr<TileTask> task; | 1256 scoped_refptr<TileTask> task; |
1265 bool need_unref = controller.GetTaskForImageAndRef( | 1257 bool need_unref = cache.GetTaskForImageAndRef( |
1266 draw_image, ImageDecodeController::TracingInfo(), &task); | 1258 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1267 EXPECT_TRUE(task); | 1259 EXPECT_TRUE(task); |
1268 EXPECT_TRUE(need_unref); | 1260 EXPECT_TRUE(need_unref); |
1269 | 1261 |
1270 TestTileTaskRunner::ProcessTask(task.get()); | 1262 TestTileTaskRunner::ProcessTask(task.get()); |
1271 | 1263 |
1272 DecodedDrawImage decoded_draw_image = | 1264 DecodedDrawImage decoded_draw_image = |
1273 controller.GetDecodedImageForDraw(draw_image); | 1265 cache.GetDecodedImageForDraw(draw_image); |
1274 EXPECT_TRUE(decoded_draw_image.image()); | 1266 EXPECT_TRUE(decoded_draw_image.image()); |
1275 // If we decoded the image and cached it, it would be stored in a different | 1267 // If we decoded the image and cached it, it would be stored in a different |
1276 // SkImageObject. | 1268 // SkImageObject. |
1277 EXPECT_TRUE(decoded_draw_image.image() != image); | 1269 EXPECT_TRUE(decoded_draw_image.image() != image); |
1278 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1270 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1279 EXPECT_EQ(250, decoded_draw_image.image()->width()); | 1271 EXPECT_EQ(250, decoded_draw_image.image()->width()); |
1280 EXPECT_EQ(100, decoded_draw_image.image()->height()); | 1272 EXPECT_EQ(100, decoded_draw_image.image()->height()); |
1281 | 1273 |
1282 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1274 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1283 controller.UnrefImage(draw_image); | 1275 cache.UnrefImage(draw_image); |
1284 } | 1276 } |
1285 | 1277 |
1286 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_49ScaleIsHandled) { | 1278 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_49ScaleIsHandled) { |
1287 TestSoftwareImageDecodeController controller; | 1279 TestSoftwareImageDecodeCache cache; |
1288 bool is_decomposable = true; | 1280 bool is_decomposable = true; |
1289 SkFilterQuality quality = kMedium_SkFilterQuality; | 1281 SkFilterQuality quality = kMedium_SkFilterQuality; |
1290 | 1282 |
1291 sk_sp<SkImage> image = CreateImage(500, 200); | 1283 sk_sp<SkImage> image = CreateImage(500, 200); |
1292 DrawImage draw_image( | 1284 DrawImage draw_image( |
1293 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1285 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1294 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); | 1286 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); |
1295 | 1287 |
1296 scoped_refptr<TileTask> task; | 1288 scoped_refptr<TileTask> task; |
1297 bool need_unref = controller.GetTaskForImageAndRef( | 1289 bool need_unref = cache.GetTaskForImageAndRef( |
1298 draw_image, ImageDecodeController::TracingInfo(), &task); | 1290 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1299 EXPECT_TRUE(task); | 1291 EXPECT_TRUE(task); |
1300 EXPECT_TRUE(need_unref); | 1292 EXPECT_TRUE(need_unref); |
1301 | 1293 |
1302 TestTileTaskRunner::ProcessTask(task.get()); | 1294 TestTileTaskRunner::ProcessTask(task.get()); |
1303 | 1295 |
1304 DecodedDrawImage decoded_draw_image = | 1296 DecodedDrawImage decoded_draw_image = |
1305 controller.GetDecodedImageForDraw(draw_image); | 1297 cache.GetDecodedImageForDraw(draw_image); |
1306 EXPECT_TRUE(decoded_draw_image.image()); | 1298 EXPECT_TRUE(decoded_draw_image.image()); |
1307 // If we decoded the image and cached it, it would be stored in a different | 1299 // If we decoded the image and cached it, it would be stored in a different |
1308 // SkImageObject. | 1300 // SkImageObject. |
1309 EXPECT_TRUE(decoded_draw_image.image() != image); | 1301 EXPECT_TRUE(decoded_draw_image.image() != image); |
1310 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1302 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1311 EXPECT_EQ(250, decoded_draw_image.image()->width()); | 1303 EXPECT_EQ(250, decoded_draw_image.image()->width()); |
1312 EXPECT_EQ(100, decoded_draw_image.image()->height()); | 1304 EXPECT_EQ(100, decoded_draw_image.image()->height()); |
1313 | 1305 |
1314 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1306 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1315 controller.UnrefImage(draw_image); | 1307 cache.UnrefImage(draw_image); |
1316 } | 1308 } |
1317 | 1309 |
1318 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_1ScaleIsHandled) { | 1310 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_1ScaleIsHandled) { |
1319 TestSoftwareImageDecodeController controller; | 1311 TestSoftwareImageDecodeCache cache; |
1320 bool is_decomposable = true; | 1312 bool is_decomposable = true; |
1321 SkFilterQuality quality = kMedium_SkFilterQuality; | 1313 SkFilterQuality quality = kMedium_SkFilterQuality; |
1322 | 1314 |
1323 sk_sp<SkImage> image = CreateImage(500, 200); | 1315 sk_sp<SkImage> image = CreateImage(500, 200); |
1324 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1316 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
1325 quality, | 1317 quality, |
1326 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable)); | 1318 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable)); |
1327 | 1319 |
1328 scoped_refptr<TileTask> task; | 1320 scoped_refptr<TileTask> task; |
1329 bool need_unref = controller.GetTaskForImageAndRef( | 1321 bool need_unref = cache.GetTaskForImageAndRef( |
1330 draw_image, ImageDecodeController::TracingInfo(), &task); | 1322 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1331 EXPECT_TRUE(task); | 1323 EXPECT_TRUE(task); |
1332 EXPECT_TRUE(need_unref); | 1324 EXPECT_TRUE(need_unref); |
1333 | 1325 |
1334 TestTileTaskRunner::ProcessTask(task.get()); | 1326 TestTileTaskRunner::ProcessTask(task.get()); |
1335 | 1327 |
1336 DecodedDrawImage decoded_draw_image = | 1328 DecodedDrawImage decoded_draw_image = |
1337 controller.GetDecodedImageForDraw(draw_image); | 1329 cache.GetDecodedImageForDraw(draw_image); |
1338 EXPECT_TRUE(decoded_draw_image.image()); | 1330 EXPECT_TRUE(decoded_draw_image.image()); |
1339 // If we decoded the image and cached it, it would be stored in a different | 1331 // If we decoded the image and cached it, it would be stored in a different |
1340 // SkImageObject. | 1332 // SkImageObject. |
1341 EXPECT_TRUE(decoded_draw_image.image() != image); | 1333 EXPECT_TRUE(decoded_draw_image.image() != image); |
1342 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1334 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1343 EXPECT_EQ(62, decoded_draw_image.image()->width()); | 1335 EXPECT_EQ(62, decoded_draw_image.image()->width()); |
1344 EXPECT_EQ(25, decoded_draw_image.image()->height()); | 1336 EXPECT_EQ(25, decoded_draw_image.image()->height()); |
1345 | 1337 |
1346 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1338 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1347 controller.UnrefImage(draw_image); | 1339 cache.UnrefImage(draw_image); |
1348 } | 1340 } |
1349 | 1341 |
1350 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_01ScaleIsHandled) { | 1342 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_01ScaleIsHandled) { |
1351 TestSoftwareImageDecodeController controller; | 1343 TestSoftwareImageDecodeCache cache; |
1352 bool is_decomposable = true; | 1344 bool is_decomposable = true; |
1353 SkFilterQuality quality = kMedium_SkFilterQuality; | 1345 SkFilterQuality quality = kMedium_SkFilterQuality; |
1354 | 1346 |
1355 sk_sp<SkImage> image = CreateImage(500, 200); | 1347 sk_sp<SkImage> image = CreateImage(500, 200); |
1356 DrawImage draw_image( | 1348 DrawImage draw_image( |
1357 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1349 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1358 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable)); | 1350 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable)); |
1359 | 1351 |
1360 scoped_refptr<TileTask> task; | 1352 scoped_refptr<TileTask> task; |
1361 bool need_unref = controller.GetTaskForImageAndRef( | 1353 bool need_unref = cache.GetTaskForImageAndRef( |
1362 draw_image, ImageDecodeController::TracingInfo(), &task); | 1354 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1363 EXPECT_TRUE(task); | 1355 EXPECT_TRUE(task); |
1364 EXPECT_TRUE(need_unref); | 1356 EXPECT_TRUE(need_unref); |
1365 | 1357 |
1366 TestTileTaskRunner::ProcessTask(task.get()); | 1358 TestTileTaskRunner::ProcessTask(task.get()); |
1367 | 1359 |
1368 DecodedDrawImage decoded_draw_image = | 1360 DecodedDrawImage decoded_draw_image = |
1369 controller.GetDecodedImageForDraw(draw_image); | 1361 cache.GetDecodedImageForDraw(draw_image); |
1370 EXPECT_TRUE(decoded_draw_image.image()); | 1362 EXPECT_TRUE(decoded_draw_image.image()); |
1371 // If we decoded the image and cached it, it would be stored in a different | 1363 // If we decoded the image and cached it, it would be stored in a different |
1372 // SkImageObject. | 1364 // SkImageObject. |
1373 EXPECT_TRUE(decoded_draw_image.image() != image); | 1365 EXPECT_TRUE(decoded_draw_image.image() != image); |
1374 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1366 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1375 EXPECT_EQ(7, decoded_draw_image.image()->width()); | 1367 EXPECT_EQ(7, decoded_draw_image.image()->width()); |
1376 EXPECT_EQ(3, decoded_draw_image.image()->height()); | 1368 EXPECT_EQ(3, decoded_draw_image.image()->height()); |
1377 | 1369 |
1378 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1370 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1379 controller.UnrefImage(draw_image); | 1371 cache.UnrefImage(draw_image); |
1380 } | 1372 } |
1381 | 1373 |
1382 TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_001ScaleIsHandled) { | 1374 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_001ScaleIsHandled) { |
1383 TestSoftwareImageDecodeController controller; | 1375 TestSoftwareImageDecodeCache cache; |
1384 bool is_decomposable = true; | 1376 bool is_decomposable = true; |
1385 SkFilterQuality quality = kMedium_SkFilterQuality; | 1377 SkFilterQuality quality = kMedium_SkFilterQuality; |
1386 | 1378 |
1387 sk_sp<SkImage> image = CreateImage(500, 200); | 1379 sk_sp<SkImage> image = CreateImage(500, 200); |
1388 DrawImage draw_image( | 1380 DrawImage draw_image( |
1389 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1381 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1390 CreateMatrix(SkSize::Make(0.001f, 0.001f), is_decomposable)); | 1382 CreateMatrix(SkSize::Make(0.001f, 0.001f), is_decomposable)); |
1391 | 1383 |
1392 scoped_refptr<TileTask> task; | 1384 scoped_refptr<TileTask> task; |
1393 bool need_unref = controller.GetTaskForImageAndRef( | 1385 bool need_unref = cache.GetTaskForImageAndRef( |
1394 draw_image, ImageDecodeController::TracingInfo(), &task); | 1386 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1395 EXPECT_FALSE(task); | 1387 EXPECT_FALSE(task); |
1396 EXPECT_FALSE(need_unref); | 1388 EXPECT_FALSE(need_unref); |
1397 | 1389 |
1398 DecodedDrawImage decoded_draw_image = | 1390 DecodedDrawImage decoded_draw_image = |
1399 controller.GetDecodedImageForDraw(draw_image); | 1391 cache.GetDecodedImageForDraw(draw_image); |
1400 EXPECT_FALSE(decoded_draw_image.image()); | 1392 EXPECT_FALSE(decoded_draw_image.image()); |
1401 | 1393 |
1402 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1394 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1403 } | 1395 } |
1404 | 1396 |
1405 TEST(SoftwareImageDecodeControllerTest, | 1397 TEST(SoftwareImageDecodeCacheTest, |
1406 MediumQualityImagesAreTheSameAt0_5And0_49Scale) { | 1398 MediumQualityImagesAreTheSameAt0_5And0_49Scale) { |
1407 TestSoftwareImageDecodeController controller; | 1399 TestSoftwareImageDecodeCache cache; |
1408 bool is_decomposable = true; | 1400 bool is_decomposable = true; |
1409 SkFilterQuality quality = kMedium_SkFilterQuality; | 1401 SkFilterQuality quality = kMedium_SkFilterQuality; |
1410 | 1402 |
1411 sk_sp<SkImage> image = CreateImage(500, 200); | 1403 sk_sp<SkImage> image = CreateImage(500, 200); |
1412 DrawImage draw_image_50( | 1404 DrawImage draw_image_50( |
1413 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1405 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1414 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1406 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1415 DrawImage draw_image_49( | 1407 DrawImage draw_image_49( |
1416 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1408 image, SkIRect::MakeWH(image->width(), image->height()), quality, |
1417 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); | 1409 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable)); |
1418 | 1410 |
1419 scoped_refptr<TileTask> task_50; | 1411 scoped_refptr<TileTask> task_50; |
1420 bool need_unref_50 = controller.GetTaskForImageAndRef( | 1412 bool need_unref_50 = cache.GetTaskForImageAndRef( |
1421 draw_image_50, ImageDecodeController::TracingInfo(), &task_50); | 1413 draw_image_50, ImageDecodeCache::TracingInfo(), &task_50); |
1422 EXPECT_TRUE(task_50); | 1414 EXPECT_TRUE(task_50); |
1423 EXPECT_TRUE(need_unref_50); | 1415 EXPECT_TRUE(need_unref_50); |
1424 scoped_refptr<TileTask> task_49; | 1416 scoped_refptr<TileTask> task_49; |
1425 bool need_unref_49 = controller.GetTaskForImageAndRef( | 1417 bool need_unref_49 = cache.GetTaskForImageAndRef( |
1426 draw_image_49, ImageDecodeController::TracingInfo(), &task_49); | 1418 draw_image_49, ImageDecodeCache::TracingInfo(), &task_49); |
1427 EXPECT_TRUE(task_49); | 1419 EXPECT_TRUE(task_49); |
1428 EXPECT_TRUE(need_unref_49); | 1420 EXPECT_TRUE(need_unref_49); |
1429 | 1421 |
1430 TestTileTaskRunner::ProcessTask(task_49.get()); | 1422 TestTileTaskRunner::ProcessTask(task_49.get()); |
1431 | 1423 |
1432 DecodedDrawImage decoded_draw_image_50 = | 1424 DecodedDrawImage decoded_draw_image_50 = |
1433 controller.GetDecodedImageForDraw(draw_image_50); | 1425 cache.GetDecodedImageForDraw(draw_image_50); |
1434 EXPECT_TRUE(decoded_draw_image_50.image()); | 1426 EXPECT_TRUE(decoded_draw_image_50.image()); |
1435 DecodedDrawImage decoded_draw_image_49 = | 1427 DecodedDrawImage decoded_draw_image_49 = |
1436 controller.GetDecodedImageForDraw(draw_image_49); | 1428 cache.GetDecodedImageForDraw(draw_image_49); |
1437 EXPECT_TRUE(decoded_draw_image_49.image()); | 1429 EXPECT_TRUE(decoded_draw_image_49.image()); |
1438 // If we decoded the image and cached it, it would be stored in a different | 1430 // If we decoded the image and cached it, it would be stored in a different |
1439 // SkImageObject. | 1431 // SkImageObject. |
1440 EXPECT_TRUE(decoded_draw_image_50.image() != image); | 1432 EXPECT_TRUE(decoded_draw_image_50.image() != image); |
1441 EXPECT_TRUE(decoded_draw_image_49.image() != image); | 1433 EXPECT_TRUE(decoded_draw_image_49.image() != image); |
1442 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_50.filter_quality()); | 1434 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_50.filter_quality()); |
1443 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_49.filter_quality()); | 1435 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image_49.filter_quality()); |
1444 EXPECT_EQ(250, decoded_draw_image_50.image()->width()); | 1436 EXPECT_EQ(250, decoded_draw_image_50.image()->width()); |
1445 EXPECT_EQ(250, decoded_draw_image_49.image()->width()); | 1437 EXPECT_EQ(250, decoded_draw_image_49.image()->width()); |
1446 EXPECT_EQ(100, decoded_draw_image_50.image()->height()); | 1438 EXPECT_EQ(100, decoded_draw_image_50.image()->height()); |
1447 EXPECT_EQ(100, decoded_draw_image_49.image()->height()); | 1439 EXPECT_EQ(100, decoded_draw_image_49.image()->height()); |
1448 | 1440 |
1449 EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image()); | 1441 EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image()); |
1450 | 1442 |
1451 controller.DrawWithImageFinished(draw_image_50, decoded_draw_image_50); | 1443 cache.DrawWithImageFinished(draw_image_50, decoded_draw_image_50); |
1452 controller.UnrefImage(draw_image_50); | 1444 cache.UnrefImage(draw_image_50); |
1453 controller.DrawWithImageFinished(draw_image_49, decoded_draw_image_49); | 1445 cache.DrawWithImageFinished(draw_image_49, decoded_draw_image_49); |
1454 controller.UnrefImage(draw_image_49); | 1446 cache.UnrefImage(draw_image_49); |
1455 } | 1447 } |
1456 | 1448 |
1457 } // namespace | 1449 } // namespace |
1458 } // namespace cc | 1450 } // namespace cc |
OLD | NEW |