OLD | NEW |
| (Empty) |
1 // Copyright 2016 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/gpu_image_decode_controller.h" | |
6 | |
7 #include "cc/playback/draw_image.h" | |
8 #include "cc/test/test_context_provider.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 kGpuMemoryLimitBytes = 96 * 1024 * 1024; | |
17 class TestGpuImageDecodeController : public GpuImageDecodeController { | |
18 public: | |
19 explicit TestGpuImageDecodeController(ContextProvider* context) | |
20 : GpuImageDecodeController(context, | |
21 ResourceFormat::RGBA_8888, | |
22 kGpuMemoryLimitBytes) {} | |
23 }; | |
24 | |
25 sk_sp<SkImage> CreateImage(int width, int height) { | |
26 SkBitmap bitmap; | |
27 bitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height)); | |
28 return SkImage::MakeFromBitmap(bitmap); | |
29 } | |
30 | |
31 SkMatrix CreateMatrix(const SkSize& scale, bool is_decomposable) { | |
32 SkMatrix matrix; | |
33 matrix.setScale(scale.width(), scale.height()); | |
34 | |
35 if (!is_decomposable) { | |
36 // Perspective is not decomposable, add it. | |
37 matrix[SkMatrix::kMPersp0] = 0.1f; | |
38 } | |
39 | |
40 return matrix; | |
41 } | |
42 | |
43 TEST(GpuImageDecodeControllerTest, GetTaskForImageSameImage) { | |
44 auto context_provider = TestContextProvider::Create(); | |
45 context_provider->BindToCurrentThread(); | |
46 TestGpuImageDecodeController controller(context_provider.get()); | |
47 sk_sp<SkImage> image = CreateImage(100, 100); | |
48 bool is_decomposable = true; | |
49 SkFilterQuality quality = kHigh_SkFilterQuality; | |
50 | |
51 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
52 quality, | |
53 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | |
54 scoped_refptr<TileTask> task; | |
55 bool need_unref = controller.GetTaskForImageAndRef( | |
56 draw_image, ImageDecodeController::TracingInfo(), &task); | |
57 EXPECT_TRUE(need_unref); | |
58 EXPECT_TRUE(task); | |
59 | |
60 DrawImage another_draw_image( | |
61 image, SkIRect::MakeWH(image->width(), image->height()), quality, | |
62 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | |
63 scoped_refptr<TileTask> another_task; | |
64 need_unref = controller.GetTaskForImageAndRef( | |
65 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
66 EXPECT_TRUE(need_unref); | |
67 EXPECT_TRUE(task.get() == another_task.get()); | |
68 | |
69 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
70 TestTileTaskRunner::ProcessTask(task.get()); | |
71 | |
72 controller.UnrefImage(draw_image); | |
73 controller.UnrefImage(draw_image); | |
74 } | |
75 | |
76 TEST(GpuImageDecodeControllerTest, GetTaskForImageSmallerScale) { | |
77 auto context_provider = TestContextProvider::Create(); | |
78 context_provider->BindToCurrentThread(); | |
79 TestGpuImageDecodeController controller(context_provider.get()); | |
80 sk_sp<SkImage> image = CreateImage(100, 100); | |
81 bool is_decomposable = true; | |
82 SkFilterQuality quality = kHigh_SkFilterQuality; | |
83 | |
84 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
85 quality, | |
86 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | |
87 scoped_refptr<TileTask> task; | |
88 bool need_unref = controller.GetTaskForImageAndRef( | |
89 draw_image, ImageDecodeController::TracingInfo(), &task); | |
90 EXPECT_TRUE(need_unref); | |
91 EXPECT_TRUE(task); | |
92 | |
93 DrawImage another_draw_image( | |
94 image, SkIRect::MakeWH(image->width(), image->height()), quality, | |
95 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
96 scoped_refptr<TileTask> another_task; | |
97 need_unref = controller.GetTaskForImageAndRef( | |
98 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
99 EXPECT_TRUE(need_unref); | |
100 EXPECT_TRUE(task.get() == another_task.get()); | |
101 | |
102 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
103 TestTileTaskRunner::ProcessTask(task.get()); | |
104 | |
105 controller.UnrefImage(draw_image); | |
106 controller.UnrefImage(another_draw_image); | |
107 } | |
108 | |
109 TEST(GpuImageDecodeControllerTest, GetTaskForImageLowerQuality) { | |
110 auto context_provider = TestContextProvider::Create(); | |
111 context_provider->BindToCurrentThread(); | |
112 TestGpuImageDecodeController controller(context_provider.get()); | |
113 sk_sp<SkImage> image = CreateImage(100, 100); | |
114 bool is_decomposable = true; | |
115 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); | |
116 | |
117 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
118 kHigh_SkFilterQuality, matrix); | |
119 scoped_refptr<TileTask> task; | |
120 bool need_unref = controller.GetTaskForImageAndRef( | |
121 draw_image, ImageDecodeController::TracingInfo(), &task); | |
122 EXPECT_TRUE(need_unref); | |
123 EXPECT_TRUE(task); | |
124 | |
125 DrawImage another_draw_image(image, | |
126 SkIRect::MakeWH(image->width(), image->height()), | |
127 kLow_SkFilterQuality, matrix); | |
128 scoped_refptr<TileTask> another_task; | |
129 need_unref = controller.GetTaskForImageAndRef( | |
130 another_draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
131 EXPECT_TRUE(need_unref); | |
132 EXPECT_TRUE(task.get() == another_task.get()); | |
133 | |
134 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
135 TestTileTaskRunner::ProcessTask(task.get()); | |
136 | |
137 controller.UnrefImage(draw_image); | |
138 controller.UnrefImage(another_draw_image); | |
139 } | |
140 | |
141 TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { | |
142 auto context_provider = TestContextProvider::Create(); | |
143 context_provider->BindToCurrentThread(); | |
144 TestGpuImageDecodeController controller(context_provider.get()); | |
145 bool is_decomposable = true; | |
146 SkFilterQuality quality = kHigh_SkFilterQuality; | |
147 | |
148 sk_sp<SkImage> first_image = CreateImage(100, 100); | |
149 DrawImage first_draw_image( | |
150 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
151 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
152 scoped_refptr<TileTask> first_task; | |
153 bool need_unref = controller.GetTaskForImageAndRef( | |
154 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | |
155 EXPECT_TRUE(need_unref); | |
156 EXPECT_TRUE(first_task); | |
157 | |
158 sk_sp<SkImage> second_image = CreateImage(100, 100); | |
159 DrawImage second_draw_image( | |
160 second_image, | |
161 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | |
162 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | |
163 scoped_refptr<TileTask> second_task; | |
164 need_unref = controller.GetTaskForImageAndRef( | |
165 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | |
166 EXPECT_TRUE(need_unref); | |
167 EXPECT_TRUE(second_task); | |
168 EXPECT_TRUE(first_task.get() != second_task.get()); | |
169 | |
170 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | |
171 TestTileTaskRunner::ProcessTask(first_task.get()); | |
172 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | |
173 TestTileTaskRunner::ProcessTask(second_task.get()); | |
174 | |
175 controller.UnrefImage(first_draw_image); | |
176 controller.UnrefImage(second_draw_image); | |
177 } | |
178 | |
179 TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScale) { | |
180 auto context_provider = TestContextProvider::Create(); | |
181 context_provider->BindToCurrentThread(); | |
182 TestGpuImageDecodeController controller(context_provider.get()); | |
183 bool is_decomposable = true; | |
184 SkFilterQuality quality = kHigh_SkFilterQuality; | |
185 | |
186 sk_sp<SkImage> first_image = CreateImage(100, 100); | |
187 DrawImage first_draw_image( | |
188 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
189 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
190 scoped_refptr<TileTask> first_task; | |
191 bool need_unref = controller.GetTaskForImageAndRef( | |
192 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | |
193 EXPECT_TRUE(need_unref); | |
194 EXPECT_TRUE(first_task); | |
195 | |
196 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | |
197 TestTileTaskRunner::ProcessTask(first_task.get()); | |
198 | |
199 controller.UnrefImage(first_draw_image); | |
200 | |
201 DrawImage second_draw_image( | |
202 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
203 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
204 scoped_refptr<TileTask> second_task; | |
205 need_unref = controller.GetTaskForImageAndRef( | |
206 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | |
207 EXPECT_TRUE(need_unref); | |
208 EXPECT_TRUE(second_task); | |
209 EXPECT_TRUE(first_task.get() != second_task.get()); | |
210 | |
211 DrawImage third_draw_image( | |
212 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
213 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
214 scoped_refptr<TileTask> third_task; | |
215 need_unref = controller.GetTaskForImageAndRef( | |
216 third_draw_image, ImageDecodeController::TracingInfo(), &third_task); | |
217 EXPECT_TRUE(need_unref); | |
218 EXPECT_TRUE(third_task.get() == second_task.get()); | |
219 | |
220 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | |
221 TestTileTaskRunner::ProcessTask(second_task.get()); | |
222 | |
223 controller.UnrefImage(second_draw_image); | |
224 controller.UnrefImage(third_draw_image); | |
225 } | |
226 | |
227 TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScaleNoReuse) { | |
228 auto context_provider = TestContextProvider::Create(); | |
229 context_provider->BindToCurrentThread(); | |
230 TestGpuImageDecodeController controller(context_provider.get()); | |
231 bool is_decomposable = true; | |
232 SkFilterQuality quality = kHigh_SkFilterQuality; | |
233 | |
234 sk_sp<SkImage> first_image = CreateImage(100, 100); | |
235 DrawImage first_draw_image( | |
236 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
237 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
238 scoped_refptr<TileTask> first_task; | |
239 bool need_unref = controller.GetTaskForImageAndRef( | |
240 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | |
241 EXPECT_TRUE(need_unref); | |
242 EXPECT_TRUE(first_task); | |
243 | |
244 DrawImage second_draw_image( | |
245 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
246 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
247 scoped_refptr<TileTask> second_task; | |
248 need_unref = controller.GetTaskForImageAndRef( | |
249 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | |
250 EXPECT_TRUE(need_unref); | |
251 EXPECT_TRUE(second_task); | |
252 EXPECT_TRUE(first_task.get() != second_task.get()); | |
253 | |
254 DrawImage third_draw_image( | |
255 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
256 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
257 scoped_refptr<TileTask> third_task; | |
258 need_unref = controller.GetTaskForImageAndRef( | |
259 third_draw_image, ImageDecodeController::TracingInfo(), &third_task); | |
260 EXPECT_TRUE(need_unref); | |
261 EXPECT_TRUE(third_task.get() == first_task.get()); | |
262 | |
263 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | |
264 TestTileTaskRunner::ProcessTask(first_task.get()); | |
265 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | |
266 TestTileTaskRunner::ProcessTask(second_task.get()); | |
267 | |
268 controller.UnrefImage(first_draw_image); | |
269 controller.UnrefImage(second_draw_image); | |
270 controller.UnrefImage(third_draw_image); | |
271 } | |
272 | |
273 TEST(GpuImageDecodeControllerTest, GetTaskForImageHigherQuality) { | |
274 auto context_provider = TestContextProvider::Create(); | |
275 context_provider->BindToCurrentThread(); | |
276 TestGpuImageDecodeController controller(context_provider.get()); | |
277 bool is_decomposable = true; | |
278 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); | |
279 | |
280 sk_sp<SkImage> first_image = CreateImage(100, 100); | |
281 DrawImage first_draw_image( | |
282 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
283 kLow_SkFilterQuality, matrix); | |
284 scoped_refptr<TileTask> first_task; | |
285 bool need_unref = controller.GetTaskForImageAndRef( | |
286 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | |
287 EXPECT_TRUE(need_unref); | |
288 EXPECT_TRUE(first_task); | |
289 | |
290 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | |
291 TestTileTaskRunner::ProcessTask(first_task.get()); | |
292 | |
293 controller.UnrefImage(first_draw_image); | |
294 | |
295 DrawImage second_draw_image( | |
296 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
297 kHigh_SkFilterQuality, matrix); | |
298 scoped_refptr<TileTask> second_task; | |
299 need_unref = controller.GetTaskForImageAndRef( | |
300 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | |
301 EXPECT_TRUE(need_unref); | |
302 EXPECT_TRUE(second_task); | |
303 EXPECT_TRUE(first_task.get() != second_task.get()); | |
304 | |
305 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | |
306 TestTileTaskRunner::ProcessTask(second_task.get()); | |
307 | |
308 controller.UnrefImage(second_draw_image); | |
309 } | |
310 | |
311 TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedAndLocked) { | |
312 auto context_provider = TestContextProvider::Create(); | |
313 context_provider->BindToCurrentThread(); | |
314 TestGpuImageDecodeController controller(context_provider.get()); | |
315 bool is_decomposable = true; | |
316 SkFilterQuality quality = kHigh_SkFilterQuality; | |
317 | |
318 sk_sp<SkImage> image = CreateImage(100, 100); | |
319 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
320 quality, | |
321 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
322 scoped_refptr<TileTask> task; | |
323 bool need_unref = controller.GetTaskForImageAndRef( | |
324 draw_image, ImageDecodeController::TracingInfo(), &task); | |
325 EXPECT_TRUE(need_unref); | |
326 EXPECT_TRUE(task); | |
327 EXPECT_EQ(task->dependencies().size(), 1u); | |
328 EXPECT_TRUE(task->dependencies()[0]); | |
329 | |
330 // Run the decode but don't complete it (this will keep the decode locked). | |
331 TestTileTaskRunner::ScheduleTask(task->dependencies()[0].get()); | |
332 TestTileTaskRunner::RunTask(task->dependencies()[0].get()); | |
333 | |
334 // Cancel the upload. | |
335 TestTileTaskRunner::CancelTask(task.get()); | |
336 TestTileTaskRunner::CompleteTask(task.get()); | |
337 | |
338 // Get the image again - we should have an upload task, but no dependent | |
339 // decode task, as the decode was already locked. | |
340 scoped_refptr<TileTask> another_task; | |
341 need_unref = controller.GetTaskForImageAndRef( | |
342 draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
343 EXPECT_TRUE(need_unref); | |
344 EXPECT_TRUE(another_task); | |
345 EXPECT_EQ(another_task->dependencies().size(), 0u); | |
346 | |
347 TestTileTaskRunner::ProcessTask(another_task.get()); | |
348 | |
349 // Finally, complete the original decode task. | |
350 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); | |
351 | |
352 controller.UnrefImage(draw_image); | |
353 controller.UnrefImage(draw_image); | |
354 } | |
355 | |
356 TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedNotLocked) { | |
357 auto context_provider = TestContextProvider::Create(); | |
358 context_provider->BindToCurrentThread(); | |
359 TestGpuImageDecodeController controller(context_provider.get()); | |
360 bool is_decomposable = true; | |
361 SkFilterQuality quality = kHigh_SkFilterQuality; | |
362 | |
363 sk_sp<SkImage> image = CreateImage(100, 100); | |
364 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
365 quality, | |
366 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
367 scoped_refptr<TileTask> task; | |
368 bool need_unref = controller.GetTaskForImageAndRef( | |
369 draw_image, ImageDecodeController::TracingInfo(), &task); | |
370 EXPECT_TRUE(need_unref); | |
371 EXPECT_TRUE(task); | |
372 EXPECT_EQ(task->dependencies().size(), 1u); | |
373 EXPECT_TRUE(task->dependencies()[0]); | |
374 | |
375 // Run the decode. | |
376 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
377 | |
378 // Cancel the upload. | |
379 TestTileTaskRunner::CancelTask(task.get()); | |
380 TestTileTaskRunner::CompleteTask(task.get()); | |
381 | |
382 // Unref the image. | |
383 controller.UnrefImage(draw_image); | |
384 | |
385 // Get the image again - we should have an upload task and a dependent decode | |
386 // task - this dependent task will typically just re-lock the image. | |
387 scoped_refptr<TileTask> another_task; | |
388 need_unref = controller.GetTaskForImageAndRef( | |
389 draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
390 EXPECT_TRUE(need_unref); | |
391 EXPECT_TRUE(another_task); | |
392 EXPECT_EQ(another_task->dependencies().size(), 1u); | |
393 EXPECT_TRUE(task->dependencies()[0]); | |
394 | |
395 TestTileTaskRunner::ProcessTask(another_task->dependencies()[0].get()); | |
396 TestTileTaskRunner::ProcessTask(another_task.get()); | |
397 | |
398 controller.UnrefImage(draw_image); | |
399 } | |
400 | |
401 TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyUploaded) { | |
402 auto context_provider = TestContextProvider::Create(); | |
403 context_provider->BindToCurrentThread(); | |
404 TestGpuImageDecodeController controller(context_provider.get()); | |
405 bool is_decomposable = true; | |
406 SkFilterQuality quality = kHigh_SkFilterQuality; | |
407 | |
408 sk_sp<SkImage> image = CreateImage(100, 100); | |
409 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
410 quality, | |
411 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
412 scoped_refptr<TileTask> task; | |
413 bool need_unref = controller.GetTaskForImageAndRef( | |
414 draw_image, ImageDecodeController::TracingInfo(), &task); | |
415 EXPECT_TRUE(need_unref); | |
416 EXPECT_TRUE(task); | |
417 EXPECT_EQ(task->dependencies().size(), 1u); | |
418 EXPECT_TRUE(task->dependencies()[0]); | |
419 | |
420 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
421 TestTileTaskRunner::ScheduleTask(task.get()); | |
422 TestTileTaskRunner::RunTask(task.get()); | |
423 | |
424 scoped_refptr<TileTask> another_task; | |
425 need_unref = controller.GetTaskForImageAndRef( | |
426 draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
427 EXPECT_TRUE(need_unref); | |
428 EXPECT_FALSE(another_task); | |
429 | |
430 TestTileTaskRunner::CompleteTask(task.get()); | |
431 | |
432 controller.UnrefImage(draw_image); | |
433 controller.UnrefImage(draw_image); | |
434 } | |
435 | |
436 TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { | |
437 auto context_provider = TestContextProvider::Create(); | |
438 context_provider->BindToCurrentThread(); | |
439 TestGpuImageDecodeController controller(context_provider.get()); | |
440 bool is_decomposable = true; | |
441 SkFilterQuality quality = kHigh_SkFilterQuality; | |
442 | |
443 sk_sp<SkImage> image = CreateImage(100, 100); | |
444 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
445 quality, | |
446 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
447 scoped_refptr<TileTask> task; | |
448 bool need_unref = controller.GetTaskForImageAndRef( | |
449 draw_image, ImageDecodeController::TracingInfo(), &task); | |
450 EXPECT_TRUE(need_unref); | |
451 EXPECT_TRUE(task); | |
452 | |
453 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
454 | |
455 scoped_refptr<TileTask> another_task; | |
456 need_unref = controller.GetTaskForImageAndRef( | |
457 draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
458 EXPECT_TRUE(need_unref); | |
459 EXPECT_TRUE(another_task.get() == task.get()); | |
460 | |
461 // Didn't run the task, so cancel it. | |
462 TestTileTaskRunner::CancelTask(task.get()); | |
463 TestTileTaskRunner::CompleteTask(task.get()); | |
464 | |
465 // Fully cancel everything (so the raster would unref things). | |
466 controller.UnrefImage(draw_image); | |
467 controller.UnrefImage(draw_image); | |
468 | |
469 // Here a new task is created. | |
470 scoped_refptr<TileTask> third_task; | |
471 need_unref = controller.GetTaskForImageAndRef( | |
472 draw_image, ImageDecodeController::TracingInfo(), &third_task); | |
473 EXPECT_TRUE(need_unref); | |
474 EXPECT_TRUE(third_task); | |
475 EXPECT_FALSE(third_task.get() == task.get()); | |
476 | |
477 TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get()); | |
478 TestTileTaskRunner::ProcessTask(third_task.get()); | |
479 | |
480 controller.UnrefImage(draw_image); | |
481 } | |
482 | |
483 TEST(GpuImageDecodeControllerTest, | |
484 GetTaskForImageCanceledWhileReffedGetsNewTask) { | |
485 auto context_provider = TestContextProvider::Create(); | |
486 context_provider->BindToCurrentThread(); | |
487 TestGpuImageDecodeController controller(context_provider.get()); | |
488 bool is_decomposable = true; | |
489 SkFilterQuality quality = kHigh_SkFilterQuality; | |
490 | |
491 sk_sp<SkImage> image = CreateImage(100, 100); | |
492 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
493 quality, | |
494 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
495 scoped_refptr<TileTask> task; | |
496 bool need_unref = controller.GetTaskForImageAndRef( | |
497 draw_image, ImageDecodeController::TracingInfo(), &task); | |
498 EXPECT_TRUE(need_unref); | |
499 EXPECT_TRUE(task); | |
500 | |
501 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
502 | |
503 scoped_refptr<TileTask> another_task; | |
504 need_unref = controller.GetTaskForImageAndRef( | |
505 draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
506 EXPECT_TRUE(need_unref); | |
507 EXPECT_TRUE(another_task.get() == task.get()); | |
508 | |
509 // Didn't run the task, so cancel it. | |
510 TestTileTaskRunner::CancelTask(task.get()); | |
511 TestTileTaskRunner::CompleteTask(task.get()); | |
512 | |
513 // Note that here, everything is reffed, but a new task is created. This is | |
514 // possible with repeated schedule/cancel operations. | |
515 scoped_refptr<TileTask> third_task; | |
516 need_unref = controller.GetTaskForImageAndRef( | |
517 draw_image, ImageDecodeController::TracingInfo(), &third_task); | |
518 EXPECT_TRUE(need_unref); | |
519 EXPECT_TRUE(third_task); | |
520 EXPECT_FALSE(third_task.get() == task.get()); | |
521 | |
522 TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get()); | |
523 TestTileTaskRunner::ProcessTask(third_task.get()); | |
524 | |
525 // 3 Unrefs! | |
526 controller.UnrefImage(draw_image); | |
527 controller.UnrefImage(draw_image); | |
528 controller.UnrefImage(draw_image); | |
529 } | |
530 | |
531 TEST(GpuImageDecodeControllerTest, NoTaskForImageAlreadyFailedDecoding) { | |
532 auto context_provider = TestContextProvider::Create(); | |
533 context_provider->BindToCurrentThread(); | |
534 TestGpuImageDecodeController controller(context_provider.get()); | |
535 bool is_decomposable = true; | |
536 SkFilterQuality quality = kHigh_SkFilterQuality; | |
537 | |
538 sk_sp<SkImage> image = CreateImage(100, 100); | |
539 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
540 quality, | |
541 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
542 scoped_refptr<TileTask> task; | |
543 bool need_unref = controller.GetTaskForImageAndRef( | |
544 draw_image, ImageDecodeController::TracingInfo(), &task); | |
545 EXPECT_TRUE(need_unref); | |
546 EXPECT_TRUE(task); | |
547 | |
548 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
549 // Didn't run the task, so cancel it. | |
550 TestTileTaskRunner::CancelTask(task.get()); | |
551 TestTileTaskRunner::CompleteTask(task.get()); | |
552 | |
553 controller.SetImageDecodingFailedForTesting(draw_image); | |
554 | |
555 scoped_refptr<TileTask> another_task; | |
556 need_unref = controller.GetTaskForImageAndRef( | |
557 draw_image, ImageDecodeController::TracingInfo(), &another_task); | |
558 EXPECT_FALSE(need_unref); | |
559 EXPECT_EQ(another_task.get(), nullptr); | |
560 | |
561 controller.UnrefImage(draw_image); | |
562 } | |
563 | |
564 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDraw) { | |
565 auto context_provider = TestContextProvider::Create(); | |
566 context_provider->BindToCurrentThread(); | |
567 TestGpuImageDecodeController controller(context_provider.get()); | |
568 bool is_decomposable = true; | |
569 SkFilterQuality quality = kHigh_SkFilterQuality; | |
570 | |
571 sk_sp<SkImage> image = CreateImage(100, 100); | |
572 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
573 quality, | |
574 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
575 scoped_refptr<TileTask> task; | |
576 bool need_unref = controller.GetTaskForImageAndRef( | |
577 draw_image, ImageDecodeController::TracingInfo(), &task); | |
578 EXPECT_TRUE(need_unref); | |
579 EXPECT_TRUE(task); | |
580 | |
581 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
582 TestTileTaskRunner::ProcessTask(task.get()); | |
583 | |
584 // Must hold context lock before calling GetDecodedImageForDraw / | |
585 // DrawWithImageFinished. | |
586 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
587 DecodedDrawImage decoded_draw_image = | |
588 controller.GetDecodedImageForDraw(draw_image); | |
589 EXPECT_TRUE(decoded_draw_image.image()); | |
590 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
591 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | |
592 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
593 | |
594 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
595 controller.UnrefImage(draw_image); | |
596 } | |
597 | |
598 TEST(GpuImageDecodeControllerTest, GetLargeDecodedImageForDraw) { | |
599 auto context_provider = TestContextProvider::Create(); | |
600 context_provider->BindToCurrentThread(); | |
601 TestGpuImageDecodeController controller(context_provider.get()); | |
602 bool is_decomposable = true; | |
603 SkFilterQuality quality = kHigh_SkFilterQuality; | |
604 | |
605 sk_sp<SkImage> image = CreateImage(1, 24000); | |
606 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
607 quality, | |
608 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
609 scoped_refptr<TileTask> task; | |
610 bool need_unref = controller.GetTaskForImageAndRef( | |
611 draw_image, ImageDecodeController::TracingInfo(), &task); | |
612 EXPECT_TRUE(need_unref); | |
613 EXPECT_TRUE(task); | |
614 | |
615 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
616 TestTileTaskRunner::ProcessTask(task.get()); | |
617 | |
618 // Must hold context lock before calling GetDecodedImageForDraw / | |
619 // DrawWithImageFinished. | |
620 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
621 DecodedDrawImage decoded_draw_image = | |
622 controller.GetDecodedImageForDraw(draw_image); | |
623 EXPECT_TRUE(decoded_draw_image.image()); | |
624 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); | |
625 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | |
626 EXPECT_TRUE(controller.DiscardableIsLockedForTesting(draw_image)); | |
627 | |
628 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
629 controller.UnrefImage(draw_image); | |
630 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
631 } | |
632 | |
633 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) { | |
634 auto context_provider = TestContextProvider::Create(); | |
635 context_provider->BindToCurrentThread(); | |
636 TestGpuImageDecodeController controller(context_provider.get()); | |
637 bool is_decomposable = true; | |
638 SkFilterQuality quality = kHigh_SkFilterQuality; | |
639 | |
640 controller.SetCachedBytesLimitForTesting(0); | |
641 | |
642 sk_sp<SkImage> image = CreateImage(100, 100); | |
643 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
644 quality, | |
645 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
646 | |
647 scoped_refptr<TileTask> task; | |
648 bool need_unref = controller.GetTaskForImageAndRef( | |
649 draw_image, ImageDecodeController::TracingInfo(), &task); | |
650 EXPECT_FALSE(need_unref); | |
651 EXPECT_FALSE(task); | |
652 | |
653 // Must hold context lock before calling GetDecodedImageForDraw / | |
654 // DrawWithImageFinished. | |
655 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
656 DecodedDrawImage decoded_draw_image = | |
657 controller.GetDecodedImageForDraw(draw_image); | |
658 EXPECT_TRUE(decoded_draw_image.image()); | |
659 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
660 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | |
661 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
662 | |
663 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
664 } | |
665 | |
666 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawLargerScale) { | |
667 auto context_provider = TestContextProvider::Create(); | |
668 context_provider->BindToCurrentThread(); | |
669 TestGpuImageDecodeController controller(context_provider.get()); | |
670 bool is_decomposable = true; | |
671 SkFilterQuality quality = kHigh_SkFilterQuality; | |
672 | |
673 sk_sp<SkImage> image = CreateImage(100, 100); | |
674 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
675 quality, | |
676 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
677 scoped_refptr<TileTask> task; | |
678 bool need_unref = controller.GetTaskForImageAndRef( | |
679 draw_image, ImageDecodeController::TracingInfo(), &task); | |
680 EXPECT_TRUE(need_unref); | |
681 EXPECT_TRUE(task); | |
682 | |
683 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
684 TestTileTaskRunner::ProcessTask(task.get()); | |
685 | |
686 DrawImage larger_draw_image( | |
687 image, SkIRect::MakeWH(image->width(), image->height()), quality, | |
688 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | |
689 scoped_refptr<TileTask> larger_task; | |
690 bool larger_need_unref = controller.GetTaskForImageAndRef( | |
691 larger_draw_image, ImageDecodeController::TracingInfo(), &larger_task); | |
692 EXPECT_TRUE(larger_need_unref); | |
693 EXPECT_TRUE(larger_task); | |
694 | |
695 TestTileTaskRunner::ProcessTask(larger_task->dependencies()[0].get()); | |
696 TestTileTaskRunner::ProcessTask(larger_task.get()); | |
697 | |
698 // Must hold context lock before calling GetDecodedImageForDraw / | |
699 // DrawWithImageFinished. | |
700 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
701 DecodedDrawImage decoded_draw_image = | |
702 controller.GetDecodedImageForDraw(draw_image); | |
703 EXPECT_TRUE(decoded_draw_image.image()); | |
704 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
705 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | |
706 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
707 | |
708 DecodedDrawImage larger_decoded_draw_image = | |
709 controller.GetDecodedImageForDraw(larger_draw_image); | |
710 EXPECT_TRUE(larger_decoded_draw_image.image()); | |
711 EXPECT_TRUE(larger_decoded_draw_image.image()->isTextureBacked()); | |
712 EXPECT_FALSE(larger_decoded_draw_image.is_at_raster_decode()); | |
713 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
714 | |
715 EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image()); | |
716 | |
717 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
718 controller.UnrefImage(draw_image); | |
719 controller.DrawWithImageFinished(larger_draw_image, | |
720 larger_decoded_draw_image); | |
721 controller.UnrefImage(larger_draw_image); | |
722 } | |
723 | |
724 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawHigherQuality) { | |
725 auto context_provider = TestContextProvider::Create(); | |
726 context_provider->BindToCurrentThread(); | |
727 TestGpuImageDecodeController controller(context_provider.get()); | |
728 bool is_decomposable = true; | |
729 SkMatrix matrix = CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable); | |
730 | |
731 sk_sp<SkImage> image = CreateImage(100, 100); | |
732 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
733 kLow_SkFilterQuality, matrix); | |
734 scoped_refptr<TileTask> task; | |
735 bool need_unref = controller.GetTaskForImageAndRef( | |
736 draw_image, ImageDecodeController::TracingInfo(), &task); | |
737 EXPECT_TRUE(need_unref); | |
738 EXPECT_TRUE(task); | |
739 | |
740 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
741 TestTileTaskRunner::ProcessTask(task.get()); | |
742 | |
743 DrawImage higher_quality_draw_image( | |
744 image, SkIRect::MakeWH(image->width(), image->height()), | |
745 kHigh_SkFilterQuality, matrix); | |
746 scoped_refptr<TileTask> hq_task; | |
747 bool hq_needs_unref = controller.GetTaskForImageAndRef( | |
748 higher_quality_draw_image, ImageDecodeController::TracingInfo(), | |
749 &hq_task); | |
750 EXPECT_TRUE(hq_needs_unref); | |
751 EXPECT_TRUE(hq_task); | |
752 | |
753 TestTileTaskRunner::ProcessTask(hq_task->dependencies()[0].get()); | |
754 TestTileTaskRunner::ProcessTask(hq_task.get()); | |
755 | |
756 // Must hold context lock before calling GetDecodedImageForDraw / | |
757 // DrawWithImageFinished. | |
758 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
759 DecodedDrawImage decoded_draw_image = | |
760 controller.GetDecodedImageForDraw(draw_image); | |
761 EXPECT_TRUE(decoded_draw_image.image()); | |
762 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
763 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | |
764 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
765 | |
766 DecodedDrawImage larger_decoded_draw_image = | |
767 controller.GetDecodedImageForDraw(higher_quality_draw_image); | |
768 EXPECT_TRUE(larger_decoded_draw_image.image()); | |
769 EXPECT_TRUE(larger_decoded_draw_image.image()->isTextureBacked()); | |
770 EXPECT_FALSE(larger_decoded_draw_image.is_at_raster_decode()); | |
771 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
772 | |
773 EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image()); | |
774 | |
775 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
776 controller.UnrefImage(draw_image); | |
777 controller.DrawWithImageFinished(higher_quality_draw_image, | |
778 larger_decoded_draw_image); | |
779 controller.UnrefImage(higher_quality_draw_image); | |
780 } | |
781 | |
782 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawNegative) { | |
783 auto context_provider = TestContextProvider::Create(); | |
784 context_provider->BindToCurrentThread(); | |
785 TestGpuImageDecodeController controller(context_provider.get()); | |
786 bool is_decomposable = true; | |
787 SkFilterQuality quality = kHigh_SkFilterQuality; | |
788 | |
789 sk_sp<SkImage> image = CreateImage(100, 100); | |
790 DrawImage draw_image( | |
791 image, SkIRect::MakeWH(image->width(), image->height()), quality, | |
792 CreateMatrix(SkSize::Make(-0.5f, 0.5f), is_decomposable)); | |
793 scoped_refptr<TileTask> task; | |
794 bool need_unref = controller.GetTaskForImageAndRef( | |
795 draw_image, ImageDecodeController::TracingInfo(), &task); | |
796 EXPECT_TRUE(need_unref); | |
797 EXPECT_TRUE(task); | |
798 | |
799 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
800 TestTileTaskRunner::ProcessTask(task.get()); | |
801 | |
802 // Must hold context lock before calling GetDecodedImageForDraw / | |
803 // DrawWithImageFinished. | |
804 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
805 DecodedDrawImage decoded_draw_image = | |
806 controller.GetDecodedImageForDraw(draw_image); | |
807 EXPECT_TRUE(decoded_draw_image.image()); | |
808 EXPECT_EQ(decoded_draw_image.image()->width(), 50); | |
809 EXPECT_EQ(decoded_draw_image.image()->height(), 50); | |
810 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
811 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | |
812 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
813 | |
814 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
815 controller.UnrefImage(draw_image); | |
816 } | |
817 | |
818 TEST(GpuImageDecodeControllerTest, GetLargeScaledDecodedImageForDraw) { | |
819 auto context_provider = TestContextProvider::Create(); | |
820 context_provider->BindToCurrentThread(); | |
821 TestGpuImageDecodeController controller(context_provider.get()); | |
822 bool is_decomposable = true; | |
823 SkFilterQuality quality = kHigh_SkFilterQuality; | |
824 | |
825 sk_sp<SkImage> image = CreateImage(1, 48000); | |
826 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
827 quality, | |
828 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
829 scoped_refptr<TileTask> task; | |
830 bool need_unref = controller.GetTaskForImageAndRef( | |
831 draw_image, ImageDecodeController::TracingInfo(), &task); | |
832 EXPECT_TRUE(need_unref); | |
833 EXPECT_TRUE(task); | |
834 | |
835 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
836 TestTileTaskRunner::ProcessTask(task.get()); | |
837 | |
838 // Must hold context lock before calling GetDecodedImageForDraw / | |
839 // DrawWithImageFinished. | |
840 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
841 DecodedDrawImage decoded_draw_image = | |
842 controller.GetDecodedImageForDraw(draw_image); | |
843 EXPECT_TRUE(decoded_draw_image.image()); | |
844 // The mip level scale should never go below 0 in any dimension. | |
845 EXPECT_EQ(1, decoded_draw_image.image()->width()); | |
846 EXPECT_EQ(24000, decoded_draw_image.image()->height()); | |
847 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); | |
848 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | |
849 EXPECT_TRUE(controller.DiscardableIsLockedForTesting(draw_image)); | |
850 | |
851 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
852 controller.UnrefImage(draw_image); | |
853 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
854 } | |
855 | |
856 TEST(GpuImageDecodeControllerTest, AtRasterUsedDirectlyIfSpaceAllows) { | |
857 auto context_provider = TestContextProvider::Create(); | |
858 context_provider->BindToCurrentThread(); | |
859 TestGpuImageDecodeController controller(context_provider.get()); | |
860 bool is_decomposable = true; | |
861 SkFilterQuality quality = kHigh_SkFilterQuality; | |
862 | |
863 controller.SetCachedBytesLimitForTesting(0); | |
864 | |
865 sk_sp<SkImage> image = CreateImage(100, 100); | |
866 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
867 quality, | |
868 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
869 | |
870 scoped_refptr<TileTask> task; | |
871 bool need_unref = controller.GetTaskForImageAndRef( | |
872 draw_image, ImageDecodeController::TracingInfo(), &task); | |
873 EXPECT_FALSE(need_unref); | |
874 EXPECT_FALSE(task); | |
875 | |
876 // Must hold context lock before calling GetDecodedImageForDraw / | |
877 // DrawWithImageFinished. | |
878 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
879 DecodedDrawImage decoded_draw_image = | |
880 controller.GetDecodedImageForDraw(draw_image); | |
881 EXPECT_TRUE(decoded_draw_image.image()); | |
882 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
883 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | |
884 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
885 | |
886 controller.SetCachedBytesLimitForTesting(96 * 1024 * 1024); | |
887 | |
888 // Finish our draw after increasing the memory limit, image should be added to | |
889 // cache. | |
890 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
891 | |
892 scoped_refptr<TileTask> another_task; | |
893 bool another_task_needs_unref = controller.GetTaskForImageAndRef( | |
894 draw_image, ImageDecodeController::TracingInfo(), &task); | |
895 EXPECT_TRUE(another_task_needs_unref); | |
896 EXPECT_FALSE(another_task); | |
897 controller.UnrefImage(draw_image); | |
898 } | |
899 | |
900 TEST(GpuImageDecodeControllerTest, | |
901 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { | |
902 auto context_provider = TestContextProvider::Create(); | |
903 context_provider->BindToCurrentThread(); | |
904 TestGpuImageDecodeController controller(context_provider.get()); | |
905 bool is_decomposable = true; | |
906 SkFilterQuality quality = kHigh_SkFilterQuality; | |
907 | |
908 controller.SetCachedBytesLimitForTesting(0); | |
909 | |
910 sk_sp<SkImage> image = CreateImage(100, 100); | |
911 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
912 quality, | |
913 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
914 | |
915 // Must hold context lock before calling GetDecodedImageForDraw / | |
916 // DrawWithImageFinished. | |
917 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
918 DecodedDrawImage decoded_draw_image = | |
919 controller.GetDecodedImageForDraw(draw_image); | |
920 EXPECT_TRUE(decoded_draw_image.image()); | |
921 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | |
922 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | |
923 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
924 | |
925 DecodedDrawImage another_decoded_draw_image = | |
926 controller.GetDecodedImageForDraw(draw_image); | |
927 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | |
928 another_decoded_draw_image.image()->uniqueID()); | |
929 | |
930 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
931 controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); | |
932 } | |
933 | |
934 TEST(GpuImageDecodeControllerTest, | |
935 GetLargeDecodedImageForDrawAtRasterDecodeMultipleTimes) { | |
936 auto context_provider = TestContextProvider::Create(); | |
937 context_provider->BindToCurrentThread(); | |
938 TestGpuImageDecodeController controller(context_provider.get()); | |
939 bool is_decomposable = true; | |
940 SkFilterQuality quality = kHigh_SkFilterQuality; | |
941 | |
942 sk_sp<SkImage> image = CreateImage(1, 24000); | |
943 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
944 quality, | |
945 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
946 | |
947 // Must hold context lock before calling GetDecodedImageForDraw / | |
948 // DrawWithImageFinished. | |
949 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
950 DecodedDrawImage decoded_draw_image = | |
951 controller.GetDecodedImageForDraw(draw_image); | |
952 EXPECT_TRUE(decoded_draw_image.image()); | |
953 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); | |
954 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | |
955 EXPECT_TRUE(controller.DiscardableIsLockedForTesting(draw_image)); | |
956 | |
957 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
958 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
959 | |
960 DecodedDrawImage second_decoded_draw_image = | |
961 controller.GetDecodedImageForDraw(draw_image); | |
962 EXPECT_TRUE(second_decoded_draw_image.image()); | |
963 EXPECT_FALSE(second_decoded_draw_image.image()->isTextureBacked()); | |
964 EXPECT_TRUE(second_decoded_draw_image.is_at_raster_decode()); | |
965 EXPECT_TRUE(controller.DiscardableIsLockedForTesting(draw_image)); | |
966 | |
967 controller.DrawWithImageFinished(draw_image, second_decoded_draw_image); | |
968 EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); | |
969 } | |
970 | |
971 TEST(GpuImageDecodeControllerTest, ZeroSizedImagesAreSkipped) { | |
972 auto context_provider = TestContextProvider::Create(); | |
973 context_provider->BindToCurrentThread(); | |
974 TestGpuImageDecodeController controller(context_provider.get()); | |
975 bool is_decomposable = true; | |
976 SkFilterQuality quality = kHigh_SkFilterQuality; | |
977 | |
978 sk_sp<SkImage> image = CreateImage(100, 100); | |
979 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
980 quality, | |
981 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); | |
982 | |
983 scoped_refptr<TileTask> task; | |
984 bool need_unref = controller.GetTaskForImageAndRef( | |
985 draw_image, ImageDecodeController::TracingInfo(), &task); | |
986 EXPECT_FALSE(task); | |
987 EXPECT_FALSE(need_unref); | |
988 | |
989 // Must hold context lock before calling GetDecodedImageForDraw / | |
990 // DrawWithImageFinished. | |
991 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
992 DecodedDrawImage decoded_draw_image = | |
993 controller.GetDecodedImageForDraw(draw_image); | |
994 EXPECT_FALSE(decoded_draw_image.image()); | |
995 | |
996 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
997 } | |
998 | |
999 TEST(GpuImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { | |
1000 auto context_provider = TestContextProvider::Create(); | |
1001 context_provider->BindToCurrentThread(); | |
1002 TestGpuImageDecodeController controller(context_provider.get()); | |
1003 bool is_decomposable = true; | |
1004 SkFilterQuality quality = kHigh_SkFilterQuality; | |
1005 | |
1006 sk_sp<SkImage> image = CreateImage(100, 100); | |
1007 DrawImage draw_image( | |
1008 image, SkIRect::MakeXYWH(150, 150, image->width(), image->height()), | |
1009 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | |
1010 | |
1011 scoped_refptr<TileTask> task; | |
1012 bool need_unref = controller.GetTaskForImageAndRef( | |
1013 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1014 EXPECT_FALSE(task); | |
1015 EXPECT_FALSE(need_unref); | |
1016 | |
1017 // Must hold context lock before calling GetDecodedImageForDraw / | |
1018 // DrawWithImageFinished. | |
1019 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
1020 DecodedDrawImage decoded_draw_image = | |
1021 controller.GetDecodedImageForDraw(draw_image); | |
1022 EXPECT_FALSE(decoded_draw_image.image()); | |
1023 | |
1024 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | |
1025 } | |
1026 | |
1027 TEST(GpuImageDecodeControllerTest, CanceledTasksDoNotCountAgainstBudget) { | |
1028 auto context_provider = TestContextProvider::Create(); | |
1029 context_provider->BindToCurrentThread(); | |
1030 TestGpuImageDecodeController controller(context_provider.get()); | |
1031 bool is_decomposable = true; | |
1032 SkFilterQuality quality = kHigh_SkFilterQuality; | |
1033 | |
1034 sk_sp<SkImage> image = CreateImage(100, 100); | |
1035 DrawImage draw_image( | |
1036 image, SkIRect::MakeXYWH(0, 0, image->width(), image->height()), quality, | |
1037 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | |
1038 | |
1039 scoped_refptr<TileTask> task; | |
1040 bool need_unref = controller.GetTaskForImageAndRef( | |
1041 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1042 EXPECT_NE(0u, controller.GetBytesUsedForTesting()); | |
1043 EXPECT_TRUE(task); | |
1044 EXPECT_TRUE(need_unref); | |
1045 | |
1046 TestTileTaskRunner::CancelTask(task->dependencies()[0].get()); | |
1047 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); | |
1048 TestTileTaskRunner::CancelTask(task.get()); | |
1049 TestTileTaskRunner::CompleteTask(task.get()); | |
1050 | |
1051 controller.UnrefImage(draw_image); | |
1052 EXPECT_EQ(0u, controller.GetBytesUsedForTesting()); | |
1053 } | |
1054 | |
1055 TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { | |
1056 auto context_provider = TestContextProvider::Create(); | |
1057 context_provider->BindToCurrentThread(); | |
1058 TestGpuImageDecodeController controller(context_provider.get()); | |
1059 bool is_decomposable = true; | |
1060 SkFilterQuality quality = kHigh_SkFilterQuality; | |
1061 | |
1062 sk_sp<SkImage> image = CreateImage(100, 100); | |
1063 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
1064 quality, | |
1065 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
1066 scoped_refptr<TileTask> task; | |
1067 { | |
1068 bool need_unref = controller.GetTaskForImageAndRef( | |
1069 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1070 EXPECT_TRUE(need_unref); | |
1071 EXPECT_TRUE(task); | |
1072 } | |
1073 | |
1074 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
1075 TestTileTaskRunner::ProcessTask(task.get()); | |
1076 | |
1077 controller.UnrefImage(draw_image); | |
1078 | |
1079 // We should now have data image in our cache. | |
1080 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); | |
1081 | |
1082 // Tell our controller to aggressively free resources. | |
1083 controller.SetShouldAggressivelyFreeResources(true); | |
1084 DCHECK_EQ(0u, controller.GetBytesUsedForTesting()); | |
1085 | |
1086 // Attempting to upload a new image should result in at-raster decode. | |
1087 { | |
1088 bool need_unref = controller.GetTaskForImageAndRef( | |
1089 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1090 EXPECT_FALSE(need_unref); | |
1091 EXPECT_FALSE(task); | |
1092 } | |
1093 | |
1094 // We now tell the controller to not aggressively free resources. Uploads | |
1095 // should work again. | |
1096 controller.SetShouldAggressivelyFreeResources(false); | |
1097 { | |
1098 bool need_unref = controller.GetTaskForImageAndRef( | |
1099 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1100 EXPECT_TRUE(need_unref); | |
1101 EXPECT_TRUE(task); | |
1102 } | |
1103 | |
1104 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
1105 TestTileTaskRunner::ProcessTask(task.get()); | |
1106 | |
1107 // The image should be in our cache after un-ref. | |
1108 controller.UnrefImage(draw_image); | |
1109 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); | |
1110 } | |
1111 | |
1112 TEST(GpuImageDecodeControllerTest, OrphanedImagesFreeOnReachingZeroRefs) { | |
1113 auto context_provider = TestContextProvider::Create(); | |
1114 context_provider->BindToCurrentThread(); | |
1115 TestGpuImageDecodeController controller(context_provider.get()); | |
1116 bool is_decomposable = true; | |
1117 SkFilterQuality quality = kHigh_SkFilterQuality; | |
1118 | |
1119 // Create a downscaled image. | |
1120 sk_sp<SkImage> first_image = CreateImage(100, 100); | |
1121 DrawImage first_draw_image( | |
1122 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
1123 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
1124 scoped_refptr<TileTask> first_task; | |
1125 bool need_unref = controller.GetTaskForImageAndRef( | |
1126 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | |
1127 EXPECT_TRUE(need_unref); | |
1128 EXPECT_TRUE(first_task); | |
1129 | |
1130 // The budget should account for exactly one image. | |
1131 EXPECT_EQ(controller.GetBytesUsedForTesting(), | |
1132 controller.GetDrawImageSizeForTesting(first_draw_image)); | |
1133 | |
1134 // Create a larger version of |first_image|, this should immediately free the | |
1135 // memory used by |first_image| for the smaller scale. | |
1136 DrawImage second_draw_image( | |
1137 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
1138 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
1139 scoped_refptr<TileTask> second_task; | |
1140 need_unref = controller.GetTaskForImageAndRef( | |
1141 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | |
1142 EXPECT_TRUE(need_unref); | |
1143 EXPECT_TRUE(second_task); | |
1144 EXPECT_TRUE(first_task.get() != second_task.get()); | |
1145 | |
1146 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | |
1147 TestTileTaskRunner::ProcessTask(second_task.get()); | |
1148 | |
1149 controller.UnrefImage(second_draw_image); | |
1150 | |
1151 // The budget should account for both images one image. | |
1152 EXPECT_EQ(controller.GetBytesUsedForTesting(), | |
1153 controller.GetDrawImageSizeForTesting(second_draw_image) + | |
1154 controller.GetDrawImageSizeForTesting(first_draw_image)); | |
1155 | |
1156 // Unref the first image, it was orphaned, so it should be immediately | |
1157 // deleted. | |
1158 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | |
1159 TestTileTaskRunner::ProcessTask(first_task.get()); | |
1160 controller.UnrefImage(first_draw_image); | |
1161 | |
1162 // The budget should account for exactly one image. | |
1163 EXPECT_EQ(controller.GetBytesUsedForTesting(), | |
1164 controller.GetDrawImageSizeForTesting(second_draw_image)); | |
1165 } | |
1166 | |
1167 TEST(GpuImageDecodeControllerTest, OrphanedZeroRefImagesImmediatelyDeleted) { | |
1168 auto context_provider = TestContextProvider::Create(); | |
1169 context_provider->BindToCurrentThread(); | |
1170 TestGpuImageDecodeController controller(context_provider.get()); | |
1171 bool is_decomposable = true; | |
1172 SkFilterQuality quality = kHigh_SkFilterQuality; | |
1173 | |
1174 // Create a downscaled image. | |
1175 sk_sp<SkImage> first_image = CreateImage(100, 100); | |
1176 DrawImage first_draw_image( | |
1177 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
1178 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | |
1179 scoped_refptr<TileTask> first_task; | |
1180 bool need_unref = controller.GetTaskForImageAndRef( | |
1181 first_draw_image, ImageDecodeController::TracingInfo(), &first_task); | |
1182 EXPECT_TRUE(need_unref); | |
1183 EXPECT_TRUE(first_task); | |
1184 | |
1185 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | |
1186 TestTileTaskRunner::ProcessTask(first_task.get()); | |
1187 controller.UnrefImage(first_draw_image); | |
1188 | |
1189 // The budget should account for exactly one image. | |
1190 EXPECT_EQ(controller.GetBytesUsedForTesting(), | |
1191 controller.GetDrawImageSizeForTesting(first_draw_image)); | |
1192 | |
1193 // Create a larger version of |first_image|, this should immediately free the | |
1194 // memory used by |first_image| for the smaller scale. | |
1195 DrawImage second_draw_image( | |
1196 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | |
1197 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
1198 scoped_refptr<TileTask> second_task; | |
1199 need_unref = controller.GetTaskForImageAndRef( | |
1200 second_draw_image, ImageDecodeController::TracingInfo(), &second_task); | |
1201 EXPECT_TRUE(need_unref); | |
1202 EXPECT_TRUE(second_task); | |
1203 EXPECT_TRUE(first_task.get() != second_task.get()); | |
1204 | |
1205 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | |
1206 TestTileTaskRunner::ProcessTask(second_task.get()); | |
1207 | |
1208 controller.UnrefImage(second_draw_image); | |
1209 | |
1210 // The budget should account for exactly one image. | |
1211 EXPECT_EQ(controller.GetBytesUsedForTesting(), | |
1212 controller.GetDrawImageSizeForTesting(second_draw_image)); | |
1213 } | |
1214 | |
1215 TEST(GpuImageDecodeControllerTest, QualityCappedAtMedium) { | |
1216 auto context_provider = TestContextProvider::Create(); | |
1217 context_provider->BindToCurrentThread(); | |
1218 TestGpuImageDecodeController controller(context_provider.get()); | |
1219 sk_sp<SkImage> image = CreateImage(100, 100); | |
1220 bool is_decomposable = true; | |
1221 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); | |
1222 | |
1223 // Create an image with kLow_FilterQuality. | |
1224 DrawImage low_draw_image(image, | |
1225 SkIRect::MakeWH(image->width(), image->height()), | |
1226 kLow_SkFilterQuality, matrix); | |
1227 scoped_refptr<TileTask> low_task; | |
1228 bool need_unref = controller.GetTaskForImageAndRef( | |
1229 low_draw_image, ImageDecodeController::TracingInfo(), &low_task); | |
1230 EXPECT_TRUE(need_unref); | |
1231 EXPECT_TRUE(low_task); | |
1232 | |
1233 // Get the same image at kMedium_FilterQuality. We can't re-use low, so we | |
1234 // should get a new task/ref. | |
1235 DrawImage medium_draw_image(image, | |
1236 SkIRect::MakeWH(image->width(), image->height()), | |
1237 kMedium_SkFilterQuality, matrix); | |
1238 scoped_refptr<TileTask> medium_task; | |
1239 need_unref = controller.GetTaskForImageAndRef( | |
1240 medium_draw_image, ImageDecodeController::TracingInfo(), &medium_task); | |
1241 EXPECT_TRUE(need_unref); | |
1242 EXPECT_TRUE(medium_task.get()); | |
1243 EXPECT_FALSE(low_task.get() == medium_task.get()); | |
1244 | |
1245 // Get the same image at kHigh_FilterQuality. We should re-use medium. | |
1246 DrawImage large_draw_image(image, | |
1247 SkIRect::MakeWH(image->width(), image->height()), | |
1248 kHigh_SkFilterQuality, matrix); | |
1249 scoped_refptr<TileTask> large_task; | |
1250 need_unref = controller.GetTaskForImageAndRef( | |
1251 large_draw_image, ImageDecodeController::TracingInfo(), &large_task); | |
1252 EXPECT_TRUE(need_unref); | |
1253 EXPECT_TRUE(medium_task.get() == large_task.get()); | |
1254 | |
1255 TestTileTaskRunner::ProcessTask(low_task->dependencies()[0].get()); | |
1256 TestTileTaskRunner::ProcessTask(low_task.get()); | |
1257 TestTileTaskRunner::ProcessTask(medium_task->dependencies()[0].get()); | |
1258 TestTileTaskRunner::ProcessTask(medium_task.get()); | |
1259 | |
1260 controller.UnrefImage(low_draw_image); | |
1261 controller.UnrefImage(medium_draw_image); | |
1262 controller.UnrefImage(large_draw_image); | |
1263 } | |
1264 | |
1265 // Ensure that switching to a mipped version of an image after the initial | |
1266 // cache entry creation doesn't cause a buffer overflow/crash. | |
1267 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawMipUsageChange) { | |
1268 auto context_provider = TestContextProvider::Create(); | |
1269 context_provider->BindToCurrentThread(); | |
1270 TestGpuImageDecodeController controller(context_provider.get()); | |
1271 bool is_decomposable = true; | |
1272 SkFilterQuality quality = kHigh_SkFilterQuality; | |
1273 | |
1274 // Create an image decode task and cache entry that does not need mips. | |
1275 sk_sp<SkImage> image = CreateImage(4000, 4000); | |
1276 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
1277 quality, | |
1278 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); | |
1279 scoped_refptr<TileTask> task; | |
1280 bool need_unref = controller.GetTaskForImageAndRef( | |
1281 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1282 EXPECT_TRUE(need_unref); | |
1283 EXPECT_TRUE(task); | |
1284 | |
1285 // Cancel the task without ever using it. | |
1286 TestTileTaskRunner::CancelTask(task->dependencies()[0].get()); | |
1287 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); | |
1288 TestTileTaskRunner::CancelTask(task.get()); | |
1289 TestTileTaskRunner::CompleteTask(task.get()); | |
1290 | |
1291 controller.UnrefImage(draw_image); | |
1292 | |
1293 // Must hold context lock before calling GetDecodedImageForDraw / | |
1294 // DrawWithImageFinished. | |
1295 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | |
1296 | |
1297 // Do an at-raster decode of the above image that *does* require mips. | |
1298 DrawImage draw_image_mips( | |
1299 image, SkIRect::MakeWH(image->width(), image->height()), quality, | |
1300 CreateMatrix(SkSize::Make(0.6f, 0.6f), is_decomposable)); | |
1301 DecodedDrawImage decoded_draw_image = | |
1302 controller.GetDecodedImageForDraw(draw_image_mips); | |
1303 controller.DrawWithImageFinished(draw_image_mips, decoded_draw_image); | |
1304 } | |
1305 | |
1306 TEST(GpuImageDecodeControllerTest, MemoryStateSuspended) { | |
1307 auto context_provider = TestContextProvider::Create(); | |
1308 context_provider->BindToCurrentThread(); | |
1309 TestGpuImageDecodeController controller(context_provider.get()); | |
1310 | |
1311 // First Insert an image into our cache. | |
1312 sk_sp<SkImage> image = CreateImage(1, 1); | |
1313 bool is_decomposable = true; | |
1314 SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable); | |
1315 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | |
1316 kLow_SkFilterQuality, matrix); | |
1317 scoped_refptr<TileTask> task; | |
1318 bool need_unref = controller.GetTaskForImageAndRef( | |
1319 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1320 EXPECT_TRUE(need_unref); | |
1321 EXPECT_TRUE(task); | |
1322 | |
1323 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
1324 TestTileTaskRunner::ProcessTask(task.get()); | |
1325 controller.UnrefImage(draw_image); | |
1326 | |
1327 // The image should be cached. | |
1328 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); | |
1329 DCHECK_EQ(controller.GetNumCacheEntriesForTesting(), 1u); | |
1330 | |
1331 // Set us to the not visible state (prerequisite for SUSPENDED). | |
1332 controller.SetShouldAggressivelyFreeResources(true); | |
1333 | |
1334 // Image should be cached, but not using memory budget. | |
1335 DCHECK_EQ(controller.GetBytesUsedForTesting(), 0u); | |
1336 DCHECK_EQ(controller.GetNumCacheEntriesForTesting(), 1u); | |
1337 | |
1338 // Set us to the SUSPENDED state. | |
1339 controller.OnMemoryStateChange(base::MemoryState::SUSPENDED); | |
1340 | |
1341 // Nothing should be cached. | |
1342 DCHECK_EQ(controller.GetBytesUsedForTesting(), 0u); | |
1343 DCHECK_EQ(controller.GetNumCacheEntriesForTesting(), 0u); | |
1344 | |
1345 // Attempts to get a task for the image should fail, as we have no space (at | |
1346 // raster only). | |
1347 need_unref = controller.GetTaskForImageAndRef( | |
1348 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1349 EXPECT_FALSE(need_unref); | |
1350 EXPECT_FALSE(task); | |
1351 | |
1352 // Restore us to visible and NORMAL memory state. | |
1353 controller.OnMemoryStateChange(base::MemoryState::NORMAL); | |
1354 controller.SetShouldAggressivelyFreeResources(false); | |
1355 | |
1356 // We should now be able to create a task again (space available). | |
1357 need_unref = controller.GetTaskForImageAndRef( | |
1358 draw_image, ImageDecodeController::TracingInfo(), &task); | |
1359 EXPECT_TRUE(need_unref); | |
1360 EXPECT_TRUE(task); | |
1361 | |
1362 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | |
1363 TestTileTaskRunner::ProcessTask(task.get()); | |
1364 controller.UnrefImage(draw_image); | |
1365 } | |
1366 | |
1367 } // namespace | |
1368 } // namespace cc | |
OLD | NEW |