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