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

Side by Side Diff: cc/tiles/image_decode_controller_unittest.cc

Issue 1418573002: cc: Add image decode control in the compositor. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: update Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(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/image_decode_controller.h"
6
7 #include "cc/playback/draw_image.h"
8 #include "testing/gtest/include/gtest/gtest.h"
9
10 namespace cc {
11 namespace {
12
13 skia::RefPtr<SkImage> CreateImage(int width, int height) {
14 SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
15 SkBitmap bitmap;
16 bitmap.allocPixels(info);
17 return skia::AdoptRef(SkImage::NewFromBitmap(bitmap));
18 }
19
20 TEST(ImageDecodeControllerTest, ImageKeyLowQuality) {
21 skia::RefPtr<SkImage> image = CreateImage(100, 100);
22 bool has_perspective = false;
23 bool is_decomposable = true;
24 SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality};
25 for (auto quality : qualities) {
26 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
27 has_perspective, is_decomposable);
28
29 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
30 EXPECT_EQ(image->uniqueID(), key.image_id());
31 EXPECT_EQ(quality, key.filter_quality());
32 EXPECT_EQ(50, key.target_size().width());
33 EXPECT_EQ(150, key.target_size().height());
34 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
35 }
36 }
37
38 TEST(ImageDecodeControllerTest, ImageKeyMediumQuality) {
39 skia::RefPtr<SkImage> image = CreateImage(100, 100);
40 bool has_perspective = false;
41 bool is_decomposable = true;
42 SkFilterQuality quality = kMedium_SkFilterQuality;
43
44 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
45 has_perspective, is_decomposable);
46
47 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
48 EXPECT_EQ(image->uniqueID(), key.image_id());
49 EXPECT_EQ(quality, key.filter_quality());
50 EXPECT_EQ(50, key.target_size().width());
51 EXPECT_EQ(150, key.target_size().height());
52 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
53 }
54
55 TEST(ImageDecodeControllerTest, ImageKeyMediumQualityEvenWithPerspective) {
56 skia::RefPtr<SkImage> image = CreateImage(100, 100);
57 bool has_perspective = true;
58 bool is_decomposable = true;
59 SkFilterQuality quality = kMedium_SkFilterQuality;
60
61 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
62 has_perspective, is_decomposable);
63
64 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
65 EXPECT_EQ(image->uniqueID(), key.image_id());
66 EXPECT_EQ(quality, key.filter_quality());
67 EXPECT_EQ(50, key.target_size().width());
68 EXPECT_EQ(150, key.target_size().height());
69 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
70 }
71
72 TEST(ImageDecodeControllerTest, ImageKeyMediumQualityDropToLowIfEnlarging) {
73 skia::RefPtr<SkImage> image = CreateImage(100, 100);
74 bool has_perspective = false;
75 bool is_decomposable = true;
76 SkFilterQuality quality = kMedium_SkFilterQuality;
77
78 DrawImage draw_image(image.get(), SkSize::Make(1.5f, 1.5f), quality,
79 has_perspective, is_decomposable);
80
81 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
82 EXPECT_EQ(image->uniqueID(), key.image_id());
83 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
84 EXPECT_EQ(150, key.target_size().width());
85 EXPECT_EQ(150, key.target_size().height());
86 EXPECT_EQ(150u * 150u * 4u, key.target_bytes());
87 }
88
89 TEST(ImageDecodeControllerTest, ImageKeyMediumQualityDropToLowIfIdentity) {
90 skia::RefPtr<SkImage> image = CreateImage(100, 100);
91 bool has_perspective = false;
92 bool is_decomposable = true;
93 SkFilterQuality quality = kMedium_SkFilterQuality;
94
95 DrawImage draw_image(image.get(), SkSize::Make(1.f, 1.f), quality,
96 has_perspective, is_decomposable);
97
98 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
99 EXPECT_EQ(image->uniqueID(), key.image_id());
100 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
101 EXPECT_EQ(100, key.target_size().width());
102 EXPECT_EQ(100, key.target_size().height());
103 EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
104 }
105
106 TEST(ImageDecodeControllerTest,
107 ImageKeyMediumQualityDropToLowIfNearlyIdentity) {
108 skia::RefPtr<SkImage> image = CreateImage(100, 100);
109 bool has_perspective = false;
110 bool is_decomposable = true;
111 SkFilterQuality quality = kMedium_SkFilterQuality;
112
113 DrawImage draw_image(image.get(), SkSize::Make(1.001f, 1.001f), quality,
114 has_perspective, is_decomposable);
115
116 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
117 EXPECT_EQ(image->uniqueID(), key.image_id());
118 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
119 EXPECT_EQ(100, key.target_size().width());
120 EXPECT_EQ(100, key.target_size().height());
121 EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
122 }
123
124 TEST(ImageDecodeControllerTest,
125 ImageKeyMediumQualityDropToLowIfNearlyIdentity2) {
126 skia::RefPtr<SkImage> image = CreateImage(100, 100);
127 bool has_perspective = false;
128 bool is_decomposable = true;
129 SkFilterQuality quality = kMedium_SkFilterQuality;
130
131 DrawImage draw_image(image.get(), SkSize::Make(0.999f, 0.999f), quality,
132 has_perspective, is_decomposable);
133
134 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
135 EXPECT_EQ(image->uniqueID(), key.image_id());
136 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
137 EXPECT_EQ(100, key.target_size().width());
138 EXPECT_EQ(100, key.target_size().height());
139 EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
140 }
141
142 TEST(ImageDecodeControllerTest,
143 ImageKeyMediumQualityDropToLowIfNotDecomposable) {
144 skia::RefPtr<SkImage> image = CreateImage(100, 100);
145 bool has_perspective = false;
146 bool is_decomposable = false;
147 SkFilterQuality quality = kMedium_SkFilterQuality;
148
149 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
150 has_perspective, is_decomposable);
151
152 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
153 EXPECT_EQ(image->uniqueID(), key.image_id());
154 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
155 EXPECT_EQ(50, key.target_size().width());
156 EXPECT_EQ(150, key.target_size().height());
157 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
158 }
159
160 TEST(ImageDecodeControllerTest, ImageKeyHighQuality) {
161 skia::RefPtr<SkImage> image = CreateImage(100, 100);
162 bool has_perspective = false;
163 bool is_decomposable = true;
164 SkFilterQuality quality = kHigh_SkFilterQuality;
165
166 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
167 has_perspective, is_decomposable);
168
169 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
170 EXPECT_EQ(image->uniqueID(), key.image_id());
171 EXPECT_EQ(quality, key.filter_quality());
172 EXPECT_EQ(50, key.target_size().width());
173 EXPECT_EQ(150, key.target_size().height());
174 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
175 }
176
177 TEST(ImageDecodeControllerTest,
178 ImageKeyHighQualityDropToMediumWithPerspective) {
179 skia::RefPtr<SkImage> image = CreateImage(100, 100);
180 bool has_perspective = true;
181 bool is_decomposable = true;
182 SkFilterQuality quality = kHigh_SkFilterQuality;
183
184 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
185 has_perspective, is_decomposable);
186
187 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
188 EXPECT_EQ(image->uniqueID(), key.image_id());
189 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
190 EXPECT_EQ(50, key.target_size().width());
191 EXPECT_EQ(150, key.target_size().height());
192 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
193 }
194
195 TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToMediumIfTooLarge) {
196 // Just over 64MB when scaled.
197 skia::RefPtr<SkImage> image = CreateImage(4555, 2048);
198 bool has_perspective = false;
199 bool is_decomposable = true;
200 SkFilterQuality quality = kHigh_SkFilterQuality;
201
202 // At least one dimension should scale down, so that medium quality doesn't
203 // become low.
204 DrawImage draw_image(image.get(), SkSize::Make(0.9f, 2.f), quality,
205 has_perspective, is_decomposable);
206
207 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
208 EXPECT_EQ(image->uniqueID(), key.image_id());
209 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
210 EXPECT_EQ(4100, key.target_size().width());
211 EXPECT_EQ(4096, key.target_size().height());
212 EXPECT_EQ(4100u * 4096u * 4u, key.target_bytes());
213 }
214
215 TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToLowIfNotDecomposable) {
216 skia::RefPtr<SkImage> image = CreateImage(100, 100);
217 bool has_perspective = false;
218 bool is_decomposable = false;
219 SkFilterQuality quality = kHigh_SkFilterQuality;
220
221 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 1.5f), quality,
222 has_perspective, is_decomposable);
223
224 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
225 EXPECT_EQ(image->uniqueID(), key.image_id());
226 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
227 EXPECT_EQ(50, key.target_size().width());
228 EXPECT_EQ(150, key.target_size().height());
229 EXPECT_EQ(50u * 150u * 4u, key.target_bytes());
230 }
231
232 TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToLowIfIdentity) {
233 skia::RefPtr<SkImage> image = CreateImage(100, 100);
234 bool has_perspective = false;
235 bool is_decomposable = true;
236 SkFilterQuality quality = kHigh_SkFilterQuality;
237
238 DrawImage draw_image(image.get(), SkSize::Make(1.f, 1.f), quality,
239 has_perspective, is_decomposable);
240
241 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
242 EXPECT_EQ(image->uniqueID(), key.image_id());
243 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
244 EXPECT_EQ(100, key.target_size().width());
245 EXPECT_EQ(100, key.target_size().height());
246 EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
247 }
248
249 TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToLowIfNearlyIdentity) {
250 skia::RefPtr<SkImage> image = CreateImage(100, 100);
251 bool has_perspective = false;
252 bool is_decomposable = true;
253 SkFilterQuality quality = kHigh_SkFilterQuality;
254
255 DrawImage draw_image(image.get(), SkSize::Make(1.001f, 1.001f), quality,
256 has_perspective, is_decomposable);
257
258 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
259 EXPECT_EQ(image->uniqueID(), key.image_id());
260 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
261 EXPECT_EQ(100, key.target_size().width());
262 EXPECT_EQ(100, key.target_size().height());
263 EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
264 }
265
266 TEST(ImageDecodeControllerTest, ImageKeyHighQualityDropToLowIfNearlyIdentity2) {
267 skia::RefPtr<SkImage> image = CreateImage(100, 100);
268 bool has_perspective = false;
269 bool is_decomposable = true;
270 SkFilterQuality quality = kHigh_SkFilterQuality;
271
272 DrawImage draw_image(image.get(), SkSize::Make(0.999f, 0.999f), quality,
273 has_perspective, is_decomposable);
274
275 auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
276 EXPECT_EQ(image->uniqueID(), key.image_id());
277 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
278 EXPECT_EQ(100, key.target_size().width());
279 EXPECT_EQ(100, key.target_size().height());
280 EXPECT_EQ(100u * 100u * 4u, key.target_bytes());
281 }
282
283 TEST(ImageDecodeControllerTest, GetTaskForImageSameImage) {
284 ImageDecodeController controller;
285 skia::RefPtr<SkImage> image = CreateImage(100, 100);
286 bool has_perspective = false;
287 bool is_decomposable = true;
288 SkFilterQuality quality = kHigh_SkFilterQuality;
289 uint64_t prepare_tiles_id = 1;
290
291 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
292 has_perspective, is_decomposable);
293 scoped_refptr<ImageDecodeTask> task;
294 bool need_unref =
295 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
296 EXPECT_TRUE(need_unref);
297 EXPECT_TRUE(task);
298
299 DrawImage another_draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
300 has_perspective, is_decomposable);
301 scoped_refptr<ImageDecodeTask> another_task;
302 need_unref = controller.GetTaskForImageAndRef(
303 another_draw_image, prepare_tiles_id, &another_task);
304 EXPECT_TRUE(need_unref);
305 EXPECT_TRUE(task.get() == another_task.get());
306
307 controller.UnrefImage(draw_image);
308 controller.UnrefImage(draw_image);
309 }
310
311 TEST(ImageDecodeControllerTest, GetTaskForImageSameImageDifferentQuality) {
312 ImageDecodeController controller;
313 skia::RefPtr<SkImage> image = CreateImage(100, 100);
314 bool has_perspective = false;
315 bool is_decomposable = true;
316 uint64_t prepare_tiles_id = 1;
317
318 DrawImage high_quality_draw_image(image.get(), SkSize::Make(0.5f, 0.5f),
319 kHigh_SkFilterQuality, has_perspective,
320 is_decomposable);
321 scoped_refptr<ImageDecodeTask> high_quality_task;
322 bool need_unref = controller.GetTaskForImageAndRef(
323 high_quality_draw_image, prepare_tiles_id, &high_quality_task);
324 EXPECT_TRUE(need_unref);
325 EXPECT_TRUE(high_quality_task);
326
327 DrawImage medium_quality_draw_image(image.get(), SkSize::Make(0.5f, 0.5f),
328 kMedium_SkFilterQuality, has_perspective,
329 is_decomposable);
330 scoped_refptr<ImageDecodeTask> medium_quality_task;
331 need_unref = controller.GetTaskForImageAndRef(
332 medium_quality_draw_image, prepare_tiles_id, &medium_quality_task);
333 // Medium quality isn't handled by the controller, so it won't ref it. Note
334 // that this will change when medium quality is handled and will need to be
335 // updated.
336 EXPECT_FALSE(need_unref);
337 EXPECT_TRUE(medium_quality_task);
338 EXPECT_TRUE(high_quality_task.get() != medium_quality_task.get());
339
340 DrawImage low_quality_draw_image(image.get(), SkSize::Make(0.5f, 0.5f),
341 kLow_SkFilterQuality, has_perspective,
342 is_decomposable);
343 scoped_refptr<ImageDecodeTask> low_quality_task;
344 need_unref = controller.GetTaskForImageAndRef(
345 low_quality_draw_image, prepare_tiles_id, &low_quality_task);
346 // Note that when we pin the original decode, we might ref low quality images
347 // too, but we don't support that right now.
348 EXPECT_FALSE(need_unref);
349 EXPECT_TRUE(low_quality_task);
350 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get());
351 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get());
352
353 controller.UnrefImage(high_quality_draw_image);
354 }
355
356 TEST(ImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
357 ImageDecodeController controller;
358 skia::RefPtr<SkImage> image = CreateImage(100, 100);
359 bool has_perspective = false;
360 bool is_decomposable = true;
361 uint64_t prepare_tiles_id = 1;
362 SkFilterQuality quality = kHigh_SkFilterQuality;
363
364 DrawImage half_size_draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
365 has_perspective, is_decomposable);
366 scoped_refptr<ImageDecodeTask> half_size_task;
367 bool need_unref = controller.GetTaskForImageAndRef(
368 half_size_draw_image, prepare_tiles_id, &half_size_task);
369 EXPECT_TRUE(need_unref);
370 EXPECT_TRUE(half_size_task);
371
372 DrawImage quarter_size_draw_image(image.get(), SkSize::Make(0.25f, 0.25f),
373 quality, has_perspective, is_decomposable);
374 scoped_refptr<ImageDecodeTask> quarter_size_task;
375 need_unref = controller.GetTaskForImageAndRef(
376 quarter_size_draw_image, prepare_tiles_id, &quarter_size_task);
377 EXPECT_TRUE(need_unref);
378 EXPECT_TRUE(quarter_size_task);
379 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get());
380
381 controller.UnrefImage(half_size_draw_image);
382 controller.UnrefImage(quarter_size_draw_image);
383 }
384
385 TEST(ImageDecodeControllerTest, GetTaskForImageDifferentImage) {
386 ImageDecodeController controller;
387 bool has_perspective = false;
388 bool is_decomposable = true;
389 uint64_t prepare_tiles_id = 1;
390 SkFilterQuality quality = kHigh_SkFilterQuality;
391
392 skia::RefPtr<SkImage> first_image = CreateImage(100, 100);
393 DrawImage first_draw_image(first_image.get(), SkSize::Make(0.5f, 0.5f),
394 quality, has_perspective, is_decomposable);
395 scoped_refptr<ImageDecodeTask> first_task;
396 bool need_unref = controller.GetTaskForImageAndRef(
397 first_draw_image, prepare_tiles_id, &first_task);
398 EXPECT_TRUE(need_unref);
399 EXPECT_TRUE(first_task);
400
401 skia::RefPtr<SkImage> second_image = CreateImage(100, 100);
402 DrawImage second_draw_image(second_image.get(), SkSize::Make(0.25f, 0.25f),
403 quality, has_perspective, is_decomposable);
404 scoped_refptr<ImageDecodeTask> second_task;
405 need_unref = controller.GetTaskForImageAndRef(second_draw_image,
406 prepare_tiles_id, &second_task);
407 EXPECT_TRUE(need_unref);
408 EXPECT_TRUE(second_task);
409 EXPECT_TRUE(first_task.get() != second_task.get());
410
411 controller.UnrefImage(first_draw_image);
412 controller.UnrefImage(second_draw_image);
413 }
414
415 TEST(ImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) {
416 ImageDecodeController controller;
417 bool has_perspective = false;
418 bool is_decomposable = true;
419 uint64_t prepare_tiles_id = 1;
420 SkFilterQuality quality = kHigh_SkFilterQuality;
421
422 skia::RefPtr<SkImage> image = CreateImage(100, 100);
423 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
424 has_perspective, is_decomposable);
425 scoped_refptr<ImageDecodeTask> task;
426 bool need_unref =
427 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
428 EXPECT_TRUE(need_unref);
429 EXPECT_TRUE(task);
430
431 task->WillSchedule();
432 task->ScheduleOnOriginThread(nullptr);
433 task->DidSchedule();
434 task->RunOnWorkerThread();
435
436 scoped_refptr<ImageDecodeTask> another_task;
437 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
438 &another_task);
439 EXPECT_TRUE(need_unref);
440 EXPECT_FALSE(another_task);
441
442 task->WillComplete();
443 task->CompleteOnOriginThread(nullptr);
444 task->DidComplete();
445
446 controller.UnrefImage(draw_image);
447 controller.UnrefImage(draw_image);
448 }
449
450 TEST(ImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) {
451 ImageDecodeController controller;
452 bool has_perspective = false;
453 bool is_decomposable = true;
454 uint64_t prepare_tiles_id = 1;
455 SkFilterQuality quality = kLow_SkFilterQuality;
456
457 skia::RefPtr<SkImage> image = CreateImage(100, 100);
458 DrawImage draw_image(image.get(), SkSize::Make(1.f, 1.f), quality,
459 has_perspective, is_decomposable);
460 scoped_refptr<ImageDecodeTask> task;
461 bool need_unref =
462 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
463 // We're not currently locking original scale or low quality images.
464 EXPECT_FALSE(need_unref);
465 EXPECT_TRUE(task);
466
467 task->WillSchedule();
468 task->ScheduleOnOriginThread(nullptr);
469 task->DidSchedule();
470 task->RunOnWorkerThread();
471
472 scoped_refptr<ImageDecodeTask> another_task;
473 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
474 &another_task);
475 EXPECT_FALSE(need_unref);
476 EXPECT_FALSE(another_task);
477
478 task->WillComplete();
479 task->CompleteOnOriginThread(nullptr);
480 task->DidComplete();
481
482 scoped_refptr<ImageDecodeTask> third_task;
483 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
484 &third_task);
485 EXPECT_FALSE(need_unref);
486 EXPECT_FALSE(third_task);
487 }
488
489 TEST(ImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) {
490 ImageDecodeController controller;
491 bool has_perspective = false;
492 bool is_decomposable = true;
493 uint64_t prepare_tiles_id = 1;
494 SkFilterQuality quality = kHigh_SkFilterQuality;
495
496 skia::RefPtr<SkImage> image = CreateImage(100, 100);
497 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
498 has_perspective, is_decomposable);
499 scoped_refptr<ImageDecodeTask> task;
500 bool need_unref =
501 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
502 EXPECT_TRUE(need_unref);
503 EXPECT_TRUE(task);
504
505 task->WillSchedule();
506 task->ScheduleOnOriginThread(nullptr);
507 task->DidSchedule();
508
509 scoped_refptr<ImageDecodeTask> another_task;
510 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
511 &another_task);
512 EXPECT_TRUE(need_unref);
513 EXPECT_TRUE(another_task.get() == task.get());
514
515 // Didn't run the task, complete it (it was canceled).
516 task->WillComplete();
517 task->CompleteOnOriginThread(nullptr);
518 task->DidComplete();
519
520 // Fully cancel everything (so the raster would unref things).
521 controller.UnrefImage(draw_image);
522 controller.UnrefImage(draw_image);
523
524 // Here a new task is created.
525 scoped_refptr<ImageDecodeTask> third_task;
526 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
527 &third_task);
528 EXPECT_TRUE(need_unref);
529 EXPECT_TRUE(third_task);
530 EXPECT_FALSE(third_task.get() == task.get());
531
532 controller.UnrefImage(draw_image);
533 }
534
535 TEST(ImageDecodeControllerTest, GetTaskForImageCanceledWhileReffedGetsNewTask) {
536 ImageDecodeController controller;
537 bool has_perspective = false;
538 bool is_decomposable = true;
539 uint64_t prepare_tiles_id = 1;
540 SkFilterQuality quality = kHigh_SkFilterQuality;
541
542 skia::RefPtr<SkImage> image = CreateImage(100, 100);
543 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
544 has_perspective, is_decomposable);
545 scoped_refptr<ImageDecodeTask> task;
546 bool need_unref =
547 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
548 EXPECT_TRUE(need_unref);
549 EXPECT_TRUE(task);
550
551 task->WillSchedule();
552 task->ScheduleOnOriginThread(nullptr);
553 task->DidSchedule();
554
555 scoped_refptr<ImageDecodeTask> another_task;
556 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
557 &another_task);
558 EXPECT_TRUE(need_unref);
559 EXPECT_TRUE(another_task.get() == task.get());
560
561 // Didn't run the task, complete it (it was canceled).
562 task->WillComplete();
563 task->CompleteOnOriginThread(nullptr);
564 task->DidComplete();
565
566 // Note that here, everything is reffed, but a new task is created. This is
567 // possible with repeated schedule/cancel operations.
568 scoped_refptr<ImageDecodeTask> third_task;
569 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id,
570 &third_task);
571 EXPECT_TRUE(need_unref);
572 EXPECT_TRUE(third_task);
573 EXPECT_FALSE(third_task.get() == task.get());
574
575 // 3 Unrefs!
576 controller.UnrefImage(draw_image);
577 controller.UnrefImage(draw_image);
578 controller.UnrefImage(draw_image);
579 }
580
581 TEST(ImageDecodeControllerTest, GetDecodedImageForDraw) {
582 ImageDecodeController controller;
583 bool has_perspective = false;
584 bool is_decomposable = true;
585 uint64_t prepare_tiles_id = 1;
586 SkFilterQuality quality = kHigh_SkFilterQuality;
587
588 skia::RefPtr<SkImage> image = CreateImage(100, 100);
589 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
590 has_perspective, is_decomposable);
591 scoped_refptr<ImageDecodeTask> task;
592 bool need_unref =
593 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
594 EXPECT_TRUE(need_unref);
595 EXPECT_TRUE(task);
596
597 task->WillSchedule();
598 task->ScheduleOnOriginThread(nullptr);
599 task->DidSchedule();
600
601 task->RunOnWorkerThread();
602
603 task->WillComplete();
604 task->CompleteOnOriginThread(nullptr);
605 task->DidComplete();
606
607 DecodedDrawImage decoded_draw_image =
608 controller.GetDecodedImageForDraw(draw_image);
609 EXPECT_TRUE(decoded_draw_image.image());
610 EXPECT_EQ(50, decoded_draw_image.image()->width());
611 EXPECT_EQ(50, decoded_draw_image.image()->height());
612 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width());
613 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height());
614 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
615 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
616 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
617
618 controller.DrawWithImageFinished(draw_image, decoded_draw_image);
619 controller.UnrefImage(draw_image);
620 }
621
622 TEST(ImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) {
623 ImageDecodeController controller;
624 bool has_perspective = false;
625 bool is_decomposable = true;
626 SkFilterQuality quality = kHigh_SkFilterQuality;
627
628 skia::RefPtr<SkImage> image = CreateImage(100, 100);
629 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
630 has_perspective, is_decomposable);
631
632 DecodedDrawImage decoded_draw_image =
633 controller.GetDecodedImageForDraw(draw_image);
634 EXPECT_TRUE(decoded_draw_image.image());
635 EXPECT_EQ(50, decoded_draw_image.image()->width());
636 EXPECT_EQ(50, decoded_draw_image.image()->height());
637 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width());
638 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height());
639 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
640 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
641 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
642
643 controller.DrawWithImageFinished(draw_image, decoded_draw_image);
644 }
645
646 TEST(ImageDecodeControllerTest,
647 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
648 ImageDecodeController controller;
649 bool has_perspective = false;
650 bool is_decomposable = true;
651 SkFilterQuality quality = kHigh_SkFilterQuality;
652
653 skia::RefPtr<SkImage> image = CreateImage(100, 100);
654 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
655 has_perspective, is_decomposable);
656
657 DecodedDrawImage decoded_draw_image =
658 controller.GetDecodedImageForDraw(draw_image);
659 EXPECT_TRUE(decoded_draw_image.image());
660 EXPECT_EQ(50, decoded_draw_image.image()->width());
661 EXPECT_EQ(50, decoded_draw_image.image()->height());
662 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width());
663 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height());
664 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
665 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
666 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
667
668 DecodedDrawImage another_decoded_draw_image =
669 controller.GetDecodedImageForDraw(draw_image);
670 EXPECT_EQ(decoded_draw_image.image()->uniqueID(),
671 another_decoded_draw_image.image()->uniqueID());
672
673 controller.DrawWithImageFinished(draw_image, decoded_draw_image);
674 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
675 }
676
677 TEST(ImageDecodeControllerTest,
678 GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) {
679 ImageDecodeController controller;
680 bool has_perspective = false;
681 bool is_decomposable = true;
682 uint64_t prepare_tiles_id = 1;
683 SkFilterQuality quality = kHigh_SkFilterQuality;
684
685 skia::RefPtr<SkImage> image = CreateImage(100, 100);
686 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
687 has_perspective, is_decomposable);
688
689 DecodedDrawImage decoded_draw_image =
690 controller.GetDecodedImageForDraw(draw_image);
691 EXPECT_TRUE(decoded_draw_image.image());
692 EXPECT_EQ(50, decoded_draw_image.image()->width());
693 EXPECT_EQ(50, decoded_draw_image.image()->height());
694 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width());
695 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height());
696 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
697 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
698 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
699
700 scoped_refptr<ImageDecodeTask> task;
701 bool need_unref =
702 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
703 EXPECT_TRUE(need_unref);
704 EXPECT_TRUE(task);
705
706 task->WillSchedule();
707 task->ScheduleOnOriginThread(nullptr);
708 task->DidSchedule();
709
710 task->RunOnWorkerThread();
711
712 task->WillComplete();
713 task->CompleteOnOriginThread(nullptr);
714 task->DidComplete();
715
716 DecodedDrawImage another_decoded_draw_image =
717 controller.GetDecodedImageForDraw(draw_image);
718 // This should get the new decoded/locked image, not the one we're using at
719 // raster.
720 // TODO(vmpstr): We can possibly optimize this so that the decode simply moves
721 // the image to the right spot.
722 EXPECT_NE(decoded_draw_image.image()->uniqueID(),
723 another_decoded_draw_image.image()->uniqueID());
724 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode());
725
726 controller.DrawWithImageFinished(draw_image, decoded_draw_image);
727 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
728 controller.UnrefImage(draw_image);
729 }
730
731 TEST(ImageDecodeControllerTest,
732 GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) {
733 ImageDecodeController controller;
734 bool has_perspective = false;
735 bool is_decomposable = true;
736 uint64_t prepare_tiles_id = 1;
737 SkFilterQuality quality = kHigh_SkFilterQuality;
738
739 skia::RefPtr<SkImage> image = CreateImage(100, 100);
740 DrawImage draw_image(image.get(), SkSize::Make(0.5f, 0.5f), quality,
741 has_perspective, is_decomposable);
742
743 DecodedDrawImage decoded_draw_image =
744 controller.GetDecodedImageForDraw(draw_image);
745 EXPECT_TRUE(decoded_draw_image.image());
746 EXPECT_EQ(50, decoded_draw_image.image()->width());
747 EXPECT_EQ(50, decoded_draw_image.image()->height());
748 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width());
749 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height());
750 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
751 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
752 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
753
754 scoped_refptr<ImageDecodeTask> task;
755 bool need_unref =
756 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task);
757 EXPECT_TRUE(need_unref);
758 EXPECT_TRUE(task);
759
760 task->WillSchedule();
761 task->ScheduleOnOriginThread(nullptr);
762 task->DidSchedule();
763
764 // If we finish the draw here, then we will use it for the locked decode
765 // instead of decoding again.
766 controller.DrawWithImageFinished(draw_image, decoded_draw_image);
767
768 task->RunOnWorkerThread();
769
770 task->WillComplete();
771 task->CompleteOnOriginThread(nullptr);
772 task->DidComplete();
773
774 DecodedDrawImage another_decoded_draw_image =
775 controller.GetDecodedImageForDraw(draw_image);
776 // This should get the decoded/locked image which we originally decoded at
777 // raster time, since it's now in the locked cache.
778 EXPECT_EQ(decoded_draw_image.image()->uniqueID(),
779 another_decoded_draw_image.image()->uniqueID());
780 EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode());
781
782 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
783 controller.UnrefImage(draw_image);
784 }
785
786 } // namespace
787 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698