OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/tiles/gpu_image_decode_controller.h" | 5 #include "cc/tiles/gpu_image_decode_controller.h" |
6 | 6 |
7 #include "cc/playback/draw_image.h" | 7 #include "cc/playback/draw_image.h" |
8 #include "cc/raster/tile_task_runner.h" | 8 #include "cc/raster/tile_task_runner.h" |
9 #include "cc/test/test_context_provider.h" | 9 #include "cc/test/test_context_provider.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
(...skipping 13 matching lines...) Expand all Loading... |
24 matrix.setScale(scale.width(), scale.height()); | 24 matrix.setScale(scale.width(), scale.height()); |
25 | 25 |
26 if (!is_decomposable) { | 26 if (!is_decomposable) { |
27 // Perspective is not decomposable, add it. | 27 // Perspective is not decomposable, add it. |
28 matrix[SkMatrix::kMPersp0] = 0.1f; | 28 matrix[SkMatrix::kMPersp0] = 0.1f; |
29 } | 29 } |
30 | 30 |
31 return matrix; | 31 return matrix; |
32 } | 32 } |
33 | 33 |
34 void ScheduleTask(ImageDecodeTask* task) { | 34 void ScheduleTask(TileTask* task) { |
35 task->WillSchedule(); | 35 task->WillSchedule(); |
36 task->ScheduleOnOriginThread(nullptr); | 36 task->ScheduleOnOriginThread(nullptr); |
37 task->DidSchedule(); | 37 task->DidSchedule(); |
38 } | 38 } |
39 | 39 |
40 void RunTask(ImageDecodeTask* task) { | 40 void RunTask(TileTask* task) { |
41 task->WillRun(); | 41 task->WillRun(); |
42 task->RunOnWorkerThread(); | 42 task->RunOnWorkerThread(); |
43 task->DidRun(); | 43 task->DidRun(); |
44 } | 44 } |
45 | 45 |
46 void CompleteTask(ImageDecodeTask* task) { | 46 void CompleteTask(TileTask* task) { |
47 task->WillComplete(); | 47 task->WillComplete(); |
48 task->CompleteOnOriginThread(nullptr); | 48 task->CompleteOnOriginThread(nullptr); |
49 task->DidComplete(); | 49 task->DidComplete(); |
50 } | 50 } |
51 | 51 |
52 void ProcessTask(ImageDecodeTask* task) { | 52 void ProcessTask(TileTask* task) { |
53 ScheduleTask(task); | 53 ScheduleTask(task); |
54 RunTask(task); | 54 RunTask(task); |
55 CompleteTask(task); | 55 CompleteTask(task); |
56 } | 56 } |
57 | 57 |
58 TEST(GpuImageDecodeControllerTest, GetTaskForImageSameImage) { | 58 TEST(GpuImageDecodeControllerTest, GetTaskForImageSameImage) { |
59 auto context_provider = TestContextProvider::Create(); | 59 auto context_provider = TestContextProvider::Create(); |
60 context_provider->BindToCurrentThread(); | 60 context_provider->BindToCurrentThread(); |
61 GpuImageDecodeController controller(context_provider.get(), | 61 GpuImageDecodeController controller(context_provider.get(), |
62 ResourceFormat::RGBA_8888); | 62 ResourceFormat::RGBA_8888); |
63 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 63 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
64 bool is_decomposable = true; | 64 bool is_decomposable = true; |
65 SkFilterQuality quality = kHigh_SkFilterQuality; | 65 SkFilterQuality quality = kHigh_SkFilterQuality; |
66 uint64_t prepare_tiles_id = 1; | 66 uint64_t prepare_tiles_id = 1; |
67 | 67 |
68 DrawImage draw_image( | 68 DrawImage draw_image( |
69 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 69 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
70 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 70 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
71 scoped_refptr<ImageDecodeTask> task; | 71 scoped_refptr<TileTask> task; |
72 bool need_unref = | 72 bool need_unref = |
73 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 73 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
74 EXPECT_TRUE(need_unref); | 74 EXPECT_TRUE(need_unref); |
75 EXPECT_TRUE(task); | 75 EXPECT_TRUE(task); |
76 | 76 |
77 DrawImage another_draw_image( | 77 DrawImage another_draw_image( |
78 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 78 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
79 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); | 79 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
80 scoped_refptr<ImageDecodeTask> another_task; | 80 scoped_refptr<TileTask> another_task; |
81 need_unref = controller.GetTaskForImageAndRef( | 81 need_unref = controller.GetTaskForImageAndRef( |
82 another_draw_image, prepare_tiles_id, &another_task); | 82 another_draw_image, prepare_tiles_id, &another_task); |
83 EXPECT_TRUE(need_unref); | 83 EXPECT_TRUE(need_unref); |
84 EXPECT_TRUE(task.get() == another_task.get()); | 84 EXPECT_TRUE(task.get() == another_task.get()); |
85 | 85 |
86 ProcessTask(task->dependency().get()); | 86 ProcessTask(task->dependencies()[0].get()); |
87 ProcessTask(task.get()); | 87 ProcessTask(task.get()); |
88 | 88 |
89 controller.UnrefImage(draw_image); | 89 controller.UnrefImage(draw_image); |
90 controller.UnrefImage(draw_image); | 90 controller.UnrefImage(draw_image); |
91 } | 91 } |
92 | 92 |
93 TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { | 93 TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
94 auto context_provider = TestContextProvider::Create(); | 94 auto context_provider = TestContextProvider::Create(); |
95 context_provider->BindToCurrentThread(); | 95 context_provider->BindToCurrentThread(); |
96 GpuImageDecodeController controller(context_provider.get(), | 96 GpuImageDecodeController controller(context_provider.get(), |
97 ResourceFormat::RGBA_8888); | 97 ResourceFormat::RGBA_8888); |
98 bool is_decomposable = true; | 98 bool is_decomposable = true; |
99 uint64_t prepare_tiles_id = 1; | 99 uint64_t prepare_tiles_id = 1; |
100 SkFilterQuality quality = kHigh_SkFilterQuality; | 100 SkFilterQuality quality = kHigh_SkFilterQuality; |
101 | 101 |
102 skia::RefPtr<SkImage> first_image = CreateImage(100, 100); | 102 skia::RefPtr<SkImage> first_image = CreateImage(100, 100); |
103 DrawImage first_draw_image( | 103 DrawImage first_draw_image( |
104 first_image.get(), | 104 first_image.get(), |
105 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, | 105 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
106 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 106 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
107 scoped_refptr<ImageDecodeTask> first_task; | 107 scoped_refptr<TileTask> first_task; |
108 bool need_unref = controller.GetTaskForImageAndRef( | 108 bool need_unref = controller.GetTaskForImageAndRef( |
109 first_draw_image, prepare_tiles_id, &first_task); | 109 first_draw_image, prepare_tiles_id, &first_task); |
110 EXPECT_TRUE(need_unref); | 110 EXPECT_TRUE(need_unref); |
111 EXPECT_TRUE(first_task); | 111 EXPECT_TRUE(first_task); |
112 | 112 |
113 skia::RefPtr<SkImage> second_image = CreateImage(100, 100); | 113 skia::RefPtr<SkImage> second_image = CreateImage(100, 100); |
114 DrawImage second_draw_image( | 114 DrawImage second_draw_image( |
115 second_image.get(), | 115 second_image.get(), |
116 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 116 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
117 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 117 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
118 scoped_refptr<ImageDecodeTask> second_task; | 118 scoped_refptr<TileTask> second_task; |
119 need_unref = controller.GetTaskForImageAndRef(second_draw_image, | 119 need_unref = controller.GetTaskForImageAndRef(second_draw_image, |
120 prepare_tiles_id, &second_task); | 120 prepare_tiles_id, &second_task); |
121 EXPECT_TRUE(need_unref); | 121 EXPECT_TRUE(need_unref); |
122 EXPECT_TRUE(second_task); | 122 EXPECT_TRUE(second_task); |
123 EXPECT_TRUE(first_task.get() != second_task.get()); | 123 EXPECT_TRUE(first_task.get() != second_task.get()); |
124 | 124 |
125 ProcessTask(first_task->dependency().get()); | 125 ProcessTask(first_task->dependencies()[0].get()); |
126 ProcessTask(first_task.get()); | 126 ProcessTask(first_task.get()); |
127 ProcessTask(second_task->dependency().get()); | 127 ProcessTask(second_task->dependencies()[0].get()); |
128 ProcessTask(second_task.get()); | 128 ProcessTask(second_task.get()); |
129 | 129 |
130 controller.UnrefImage(first_draw_image); | 130 controller.UnrefImage(first_draw_image); |
131 controller.UnrefImage(second_draw_image); | 131 controller.UnrefImage(second_draw_image); |
132 } | 132 } |
133 | 133 |
134 TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { | 134 TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { |
135 auto context_provider = TestContextProvider::Create(); | 135 auto context_provider = TestContextProvider::Create(); |
136 context_provider->BindToCurrentThread(); | 136 context_provider->BindToCurrentThread(); |
137 GpuImageDecodeController controller(context_provider.get(), | 137 GpuImageDecodeController controller(context_provider.get(), |
138 ResourceFormat::RGBA_8888); | 138 ResourceFormat::RGBA_8888); |
139 bool is_decomposable = true; | 139 bool is_decomposable = true; |
140 uint64_t prepare_tiles_id = 1; | 140 uint64_t prepare_tiles_id = 1; |
141 SkFilterQuality quality = kHigh_SkFilterQuality; | 141 SkFilterQuality quality = kHigh_SkFilterQuality; |
142 | 142 |
143 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 143 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
144 DrawImage draw_image( | 144 DrawImage draw_image( |
145 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 145 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
146 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 146 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
147 scoped_refptr<ImageDecodeTask> task; | 147 scoped_refptr<TileTask> task; |
148 bool need_unref = | 148 bool need_unref = |
149 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 149 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
150 EXPECT_TRUE(need_unref); | 150 EXPECT_TRUE(need_unref); |
151 EXPECT_TRUE(task); | 151 EXPECT_TRUE(task); |
152 EXPECT_TRUE(task->dependency()); | 152 EXPECT_EQ(task->dependencies().size(), 1u); |
| 153 EXPECT_TRUE(task->dependencies()[0]); |
153 | 154 |
154 ProcessTask(task->dependency().get()); | 155 ProcessTask(task->dependencies()[0].get()); |
155 ScheduleTask(task.get()); | 156 ScheduleTask(task.get()); |
156 RunTask(task.get()); | 157 RunTask(task.get()); |
157 | 158 |
158 scoped_refptr<ImageDecodeTask> another_task; | 159 scoped_refptr<TileTask> another_task; |
159 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 160 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
160 &another_task); | 161 &another_task); |
161 EXPECT_TRUE(need_unref); | 162 EXPECT_TRUE(need_unref); |
162 EXPECT_FALSE(another_task); | 163 EXPECT_FALSE(another_task); |
163 | 164 |
164 CompleteTask(task.get()); | 165 CompleteTask(task.get()); |
165 | 166 |
166 controller.UnrefImage(draw_image); | 167 controller.UnrefImage(draw_image); |
167 controller.UnrefImage(draw_image); | 168 controller.UnrefImage(draw_image); |
168 } | 169 } |
169 | 170 |
170 TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { | 171 TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { |
171 auto context_provider = TestContextProvider::Create(); | 172 auto context_provider = TestContextProvider::Create(); |
172 context_provider->BindToCurrentThread(); | 173 context_provider->BindToCurrentThread(); |
173 GpuImageDecodeController controller(context_provider.get(), | 174 GpuImageDecodeController controller(context_provider.get(), |
174 ResourceFormat::RGBA_8888); | 175 ResourceFormat::RGBA_8888); |
175 bool is_decomposable = true; | 176 bool is_decomposable = true; |
176 uint64_t prepare_tiles_id = 1; | 177 uint64_t prepare_tiles_id = 1; |
177 SkFilterQuality quality = kHigh_SkFilterQuality; | 178 SkFilterQuality quality = kHigh_SkFilterQuality; |
178 | 179 |
179 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 180 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
180 DrawImage draw_image( | 181 DrawImage draw_image( |
181 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 182 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
182 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 183 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
183 scoped_refptr<ImageDecodeTask> task; | 184 scoped_refptr<TileTask> task; |
184 bool need_unref = | 185 bool need_unref = |
185 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 186 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
186 EXPECT_TRUE(need_unref); | 187 EXPECT_TRUE(need_unref); |
187 EXPECT_TRUE(task); | 188 EXPECT_TRUE(task); |
188 | 189 |
189 ProcessTask(task->dependency().get()); | 190 ProcessTask(task->dependencies()[0].get()); |
190 ScheduleTask(task.get()); | 191 ScheduleTask(task.get()); |
191 | 192 |
192 scoped_refptr<ImageDecodeTask> another_task; | 193 scoped_refptr<TileTask> another_task; |
193 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 194 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
194 &another_task); | 195 &another_task); |
195 EXPECT_TRUE(need_unref); | 196 EXPECT_TRUE(need_unref); |
196 EXPECT_TRUE(another_task.get() == task.get()); | 197 EXPECT_TRUE(another_task.get() == task.get()); |
197 | 198 |
198 // Didn't run the task, complete it (it was canceled). | 199 // Didn't run the task, complete it (it was canceled). |
199 CompleteTask(task.get()); | 200 CompleteTask(task.get()); |
200 | 201 |
201 // Fully cancel everything (so the raster would unref things). | 202 // Fully cancel everything (so the raster would unref things). |
202 controller.UnrefImage(draw_image); | 203 controller.UnrefImage(draw_image); |
203 controller.UnrefImage(draw_image); | 204 controller.UnrefImage(draw_image); |
204 | 205 |
205 // Here a new task is created. | 206 // Here a new task is created. |
206 scoped_refptr<ImageDecodeTask> third_task; | 207 scoped_refptr<TileTask> third_task; |
207 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 208 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
208 &third_task); | 209 &third_task); |
209 EXPECT_TRUE(need_unref); | 210 EXPECT_TRUE(need_unref); |
210 EXPECT_TRUE(third_task); | 211 EXPECT_TRUE(third_task); |
211 EXPECT_FALSE(third_task.get() == task.get()); | 212 EXPECT_FALSE(third_task.get() == task.get()); |
212 | 213 |
213 ProcessTask(third_task->dependency().get()); | 214 ProcessTask(third_task->dependencies()[0].get()); |
214 ProcessTask(third_task.get()); | 215 ProcessTask(third_task.get()); |
215 | 216 |
216 controller.UnrefImage(draw_image); | 217 controller.UnrefImage(draw_image); |
217 } | 218 } |
218 | 219 |
219 TEST(GpuImageDecodeControllerTest, | 220 TEST(GpuImageDecodeControllerTest, |
220 GetTaskForImageCanceledWhileReffedGetsNewTask) { | 221 GetTaskForImageCanceledWhileReffedGetsNewTask) { |
221 auto context_provider = TestContextProvider::Create(); | 222 auto context_provider = TestContextProvider::Create(); |
222 context_provider->BindToCurrentThread(); | 223 context_provider->BindToCurrentThread(); |
223 GpuImageDecodeController controller(context_provider.get(), | 224 GpuImageDecodeController controller(context_provider.get(), |
224 ResourceFormat::RGBA_8888); | 225 ResourceFormat::RGBA_8888); |
225 bool is_decomposable = true; | 226 bool is_decomposable = true; |
226 uint64_t prepare_tiles_id = 1; | 227 uint64_t prepare_tiles_id = 1; |
227 SkFilterQuality quality = kHigh_SkFilterQuality; | 228 SkFilterQuality quality = kHigh_SkFilterQuality; |
228 | 229 |
229 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 230 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
230 DrawImage draw_image( | 231 DrawImage draw_image( |
231 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 232 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
232 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 233 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
233 scoped_refptr<ImageDecodeTask> task; | 234 scoped_refptr<TileTask> task; |
234 bool need_unref = | 235 bool need_unref = |
235 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 236 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
236 EXPECT_TRUE(need_unref); | 237 EXPECT_TRUE(need_unref); |
237 EXPECT_TRUE(task); | 238 EXPECT_TRUE(task); |
238 | 239 |
239 ProcessTask(task->dependency().get()); | 240 ProcessTask(task->dependencies()[0].get()); |
240 ScheduleTask(task.get()); | 241 ScheduleTask(task.get()); |
241 | 242 |
242 scoped_refptr<ImageDecodeTask> another_task; | 243 scoped_refptr<TileTask> another_task; |
243 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 244 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
244 &another_task); | 245 &another_task); |
245 EXPECT_TRUE(need_unref); | 246 EXPECT_TRUE(need_unref); |
246 EXPECT_TRUE(another_task.get() == task.get()); | 247 EXPECT_TRUE(another_task.get() == task.get()); |
247 | 248 |
248 // Didn't run the task, complete it (it was canceled). | 249 // Didn't run the task, complete it (it was canceled). |
249 CompleteTask(task.get()); | 250 CompleteTask(task.get()); |
250 | 251 |
251 // Note that here, everything is reffed, but a new task is created. This is | 252 // Note that here, everything is reffed, but a new task is created. This is |
252 // possible with repeated schedule/cancel operations. | 253 // possible with repeated schedule/cancel operations. |
253 scoped_refptr<ImageDecodeTask> third_task; | 254 scoped_refptr<TileTask> third_task; |
254 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 255 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
255 &third_task); | 256 &third_task); |
256 EXPECT_TRUE(need_unref); | 257 EXPECT_TRUE(need_unref); |
257 EXPECT_TRUE(third_task); | 258 EXPECT_TRUE(third_task); |
258 EXPECT_FALSE(third_task.get() == task.get()); | 259 EXPECT_FALSE(third_task.get() == task.get()); |
259 | 260 |
260 ProcessTask(third_task->dependency().get()); | 261 ProcessTask(third_task->dependencies()[0].get()); |
261 ProcessTask(third_task.get()); | 262 ProcessTask(third_task.get()); |
262 | 263 |
263 // 3 Unrefs! | 264 // 3 Unrefs! |
264 controller.UnrefImage(draw_image); | 265 controller.UnrefImage(draw_image); |
265 controller.UnrefImage(draw_image); | 266 controller.UnrefImage(draw_image); |
266 controller.UnrefImage(draw_image); | 267 controller.UnrefImage(draw_image); |
267 } | 268 } |
268 | 269 |
269 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDraw) { | 270 TEST(GpuImageDecodeControllerTest, GetDecodedImageForDraw) { |
270 auto context_provider = TestContextProvider::Create(); | 271 auto context_provider = TestContextProvider::Create(); |
271 context_provider->BindToCurrentThread(); | 272 context_provider->BindToCurrentThread(); |
272 GpuImageDecodeController controller(context_provider.get(), | 273 GpuImageDecodeController controller(context_provider.get(), |
273 ResourceFormat::RGBA_8888); | 274 ResourceFormat::RGBA_8888); |
274 bool is_decomposable = true; | 275 bool is_decomposable = true; |
275 uint64_t prepare_tiles_id = 1; | 276 uint64_t prepare_tiles_id = 1; |
276 SkFilterQuality quality = kHigh_SkFilterQuality; | 277 SkFilterQuality quality = kHigh_SkFilterQuality; |
277 | 278 |
278 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 279 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
279 DrawImage draw_image( | 280 DrawImage draw_image( |
280 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 281 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
281 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 282 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
282 scoped_refptr<ImageDecodeTask> task; | 283 scoped_refptr<TileTask> task; |
283 bool need_unref = | 284 bool need_unref = |
284 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 285 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
285 EXPECT_TRUE(need_unref); | 286 EXPECT_TRUE(need_unref); |
286 EXPECT_TRUE(task); | 287 EXPECT_TRUE(task); |
287 | 288 |
288 ProcessTask(task->dependency().get()); | 289 ProcessTask(task->dependencies()[0].get()); |
289 ProcessTask(task.get()); | 290 ProcessTask(task.get()); |
290 | 291 |
291 // Must hold context lock before calling GetDecodedImageForDraw / | 292 // Must hold context lock before calling GetDecodedImageForDraw / |
292 // DrawWithImageFinished. | 293 // DrawWithImageFinished. |
293 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 294 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
294 DecodedDrawImage decoded_draw_image = | 295 DecodedDrawImage decoded_draw_image = |
295 controller.GetDecodedImageForDraw(draw_image); | 296 controller.GetDecodedImageForDraw(draw_image); |
296 EXPECT_TRUE(decoded_draw_image.image()); | 297 EXPECT_TRUE(decoded_draw_image.image()); |
297 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | 298 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); |
298 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | 299 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); |
299 | 300 |
300 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 301 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
301 controller.UnrefImage(draw_image); | 302 controller.UnrefImage(draw_image); |
302 } | 303 } |
303 | 304 |
304 TEST(GpuImageDecodeControllerTest, GetLargeDecodedImageForDraw) { | 305 TEST(GpuImageDecodeControllerTest, GetLargeDecodedImageForDraw) { |
305 auto context_provider = TestContextProvider::Create(); | 306 auto context_provider = TestContextProvider::Create(); |
306 context_provider->BindToCurrentThread(); | 307 context_provider->BindToCurrentThread(); |
307 GpuImageDecodeController controller(context_provider.get(), | 308 GpuImageDecodeController controller(context_provider.get(), |
308 ResourceFormat::RGBA_8888); | 309 ResourceFormat::RGBA_8888); |
309 bool is_decomposable = true; | 310 bool is_decomposable = true; |
310 uint64_t prepare_tiles_id = 1; | 311 uint64_t prepare_tiles_id = 1; |
311 SkFilterQuality quality = kHigh_SkFilterQuality; | 312 SkFilterQuality quality = kHigh_SkFilterQuality; |
312 | 313 |
313 skia::RefPtr<SkImage> image = CreateImage(1, 24000); | 314 skia::RefPtr<SkImage> image = CreateImage(1, 24000); |
314 DrawImage draw_image( | 315 DrawImage draw_image( |
315 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 316 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
316 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 317 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
317 scoped_refptr<ImageDecodeTask> task; | 318 scoped_refptr<TileTask> task; |
318 bool need_unref = | 319 bool need_unref = |
319 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 320 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
320 EXPECT_TRUE(need_unref); | 321 EXPECT_TRUE(need_unref); |
321 EXPECT_TRUE(task); | 322 EXPECT_TRUE(task); |
322 | 323 |
323 ProcessTask(task->dependency().get()); | 324 ProcessTask(task->dependencies()[0].get()); |
324 ProcessTask(task.get()); | 325 ProcessTask(task.get()); |
325 | 326 |
326 // Must hold context lock before calling GetDecodedImageForDraw / | 327 // Must hold context lock before calling GetDecodedImageForDraw / |
327 // DrawWithImageFinished. | 328 // DrawWithImageFinished. |
328 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 329 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
329 DecodedDrawImage decoded_draw_image = | 330 DecodedDrawImage decoded_draw_image = |
330 controller.GetDecodedImageForDraw(draw_image); | 331 controller.GetDecodedImageForDraw(draw_image); |
331 EXPECT_TRUE(decoded_draw_image.image()); | 332 EXPECT_TRUE(decoded_draw_image.image()); |
332 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); | 333 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); |
333 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); | 334 EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); |
(...skipping 12 matching lines...) Expand all Loading... |
346 SkFilterQuality quality = kHigh_SkFilterQuality; | 347 SkFilterQuality quality = kHigh_SkFilterQuality; |
347 | 348 |
348 controller.SetCachedItemLimitForTesting(0); | 349 controller.SetCachedItemLimitForTesting(0); |
349 controller.SetCachedBytesLimitForTesting(0); | 350 controller.SetCachedBytesLimitForTesting(0); |
350 | 351 |
351 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 352 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
352 DrawImage draw_image( | 353 DrawImage draw_image( |
353 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 354 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
354 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 355 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
355 | 356 |
356 scoped_refptr<ImageDecodeTask> task; | 357 scoped_refptr<TileTask> task; |
357 bool need_unref = | 358 bool need_unref = |
358 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 359 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
359 EXPECT_FALSE(need_unref); | 360 EXPECT_FALSE(need_unref); |
360 EXPECT_FALSE(task); | 361 EXPECT_FALSE(task); |
361 | 362 |
362 // Must hold context lock before calling GetDecodedImageForDraw / | 363 // Must hold context lock before calling GetDecodedImageForDraw / |
363 // DrawWithImageFinished. | 364 // DrawWithImageFinished. |
364 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 365 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
365 DecodedDrawImage decoded_draw_image = | 366 DecodedDrawImage decoded_draw_image = |
366 controller.GetDecodedImageForDraw(draw_image); | 367 controller.GetDecodedImageForDraw(draw_image); |
(...skipping 14 matching lines...) Expand all Loading... |
381 SkFilterQuality quality = kHigh_SkFilterQuality; | 382 SkFilterQuality quality = kHigh_SkFilterQuality; |
382 | 383 |
383 controller.SetCachedItemLimitForTesting(0); | 384 controller.SetCachedItemLimitForTesting(0); |
384 controller.SetCachedBytesLimitForTesting(0); | 385 controller.SetCachedBytesLimitForTesting(0); |
385 | 386 |
386 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 387 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
387 DrawImage draw_image( | 388 DrawImage draw_image( |
388 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 389 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
389 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 390 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
390 | 391 |
391 scoped_refptr<ImageDecodeTask> task; | 392 scoped_refptr<TileTask> task; |
392 bool need_unref = | 393 bool need_unref = |
393 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 394 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
394 EXPECT_FALSE(need_unref); | 395 EXPECT_FALSE(need_unref); |
395 EXPECT_FALSE(task); | 396 EXPECT_FALSE(task); |
396 | 397 |
397 // Must hold context lock before calling GetDecodedImageForDraw / | 398 // Must hold context lock before calling GetDecodedImageForDraw / |
398 // DrawWithImageFinished. | 399 // DrawWithImageFinished. |
399 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 400 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
400 DecodedDrawImage decoded_draw_image = | 401 DecodedDrawImage decoded_draw_image = |
401 controller.GetDecodedImageForDraw(draw_image); | 402 controller.GetDecodedImageForDraw(draw_image); |
402 EXPECT_TRUE(decoded_draw_image.image()); | 403 EXPECT_TRUE(decoded_draw_image.image()); |
403 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | 404 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); |
404 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 405 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
405 | 406 |
406 controller.SetCachedItemLimitForTesting(1000); | 407 controller.SetCachedItemLimitForTesting(1000); |
407 controller.SetCachedBytesLimitForTesting(96 * 1024 * 1024); | 408 controller.SetCachedBytesLimitForTesting(96 * 1024 * 1024); |
408 | 409 |
409 // Finish our draw after increasing the memory limit, image should be added to | 410 // Finish our draw after increasing the memory limit, image should be added to |
410 // cache. | 411 // cache. |
411 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 412 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
412 | 413 |
413 scoped_refptr<ImageDecodeTask> another_task; | 414 scoped_refptr<TileTask> another_task; |
414 bool another_task_needs_unref = | 415 bool another_task_needs_unref = |
415 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 416 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
416 EXPECT_TRUE(another_task_needs_unref); | 417 EXPECT_TRUE(another_task_needs_unref); |
417 EXPECT_FALSE(another_task); | 418 EXPECT_FALSE(another_task); |
418 controller.UnrefImage(draw_image); | 419 controller.UnrefImage(draw_image); |
419 } | 420 } |
420 | 421 |
421 TEST(GpuImageDecodeControllerTest, | 422 TEST(GpuImageDecodeControllerTest, |
422 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { | 423 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
423 auto context_provider = TestContextProvider::Create(); | 424 auto context_provider = TestContextProvider::Create(); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
460 ResourceFormat::RGBA_8888); | 461 ResourceFormat::RGBA_8888); |
461 bool is_decomposable = true; | 462 bool is_decomposable = true; |
462 uint64_t prepare_tiles_id = 1; | 463 uint64_t prepare_tiles_id = 1; |
463 SkFilterQuality quality = kHigh_SkFilterQuality; | 464 SkFilterQuality quality = kHigh_SkFilterQuality; |
464 | 465 |
465 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 466 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
466 DrawImage draw_image( | 467 DrawImage draw_image( |
467 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 468 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
468 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); | 469 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); |
469 | 470 |
470 scoped_refptr<ImageDecodeTask> task; | 471 scoped_refptr<TileTask> task; |
471 bool need_unref = | 472 bool need_unref = |
472 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 473 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
473 EXPECT_FALSE(task); | 474 EXPECT_FALSE(task); |
474 EXPECT_FALSE(need_unref); | 475 EXPECT_FALSE(need_unref); |
475 | 476 |
476 // Must hold context lock before calling GetDecodedImageForDraw / | 477 // Must hold context lock before calling GetDecodedImageForDraw / |
477 // DrawWithImageFinished. | 478 // DrawWithImageFinished. |
478 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 479 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
479 DecodedDrawImage decoded_draw_image = | 480 DecodedDrawImage decoded_draw_image = |
480 controller.GetDecodedImageForDraw(draw_image); | 481 controller.GetDecodedImageForDraw(draw_image); |
481 EXPECT_FALSE(decoded_draw_image.image()); | 482 EXPECT_FALSE(decoded_draw_image.image()); |
482 | 483 |
483 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 484 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
484 } | 485 } |
485 | 486 |
486 TEST(GpuImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { | 487 TEST(GpuImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { |
487 auto context_provider = TestContextProvider::Create(); | 488 auto context_provider = TestContextProvider::Create(); |
488 context_provider->BindToCurrentThread(); | 489 context_provider->BindToCurrentThread(); |
489 GpuImageDecodeController controller(context_provider.get(), | 490 GpuImageDecodeController controller(context_provider.get(), |
490 ResourceFormat::RGBA_8888); | 491 ResourceFormat::RGBA_8888); |
491 bool is_decomposable = true; | 492 bool is_decomposable = true; |
492 uint64_t prepare_tiles_id = 1; | 493 uint64_t prepare_tiles_id = 1; |
493 SkFilterQuality quality = kHigh_SkFilterQuality; | 494 SkFilterQuality quality = kHigh_SkFilterQuality; |
494 | 495 |
495 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 496 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
496 DrawImage draw_image( | 497 DrawImage draw_image( |
497 image.get(), SkIRect::MakeXYWH(150, 150, image->width(), image->height()), | 498 image.get(), SkIRect::MakeXYWH(150, 150, image->width(), image->height()), |
498 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 499 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
499 | 500 |
500 scoped_refptr<ImageDecodeTask> task; | 501 scoped_refptr<TileTask> task; |
501 bool need_unref = | 502 bool need_unref = |
502 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 503 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
503 EXPECT_FALSE(task); | 504 EXPECT_FALSE(task); |
504 EXPECT_FALSE(need_unref); | 505 EXPECT_FALSE(need_unref); |
505 | 506 |
506 // Must hold context lock before calling GetDecodedImageForDraw / | 507 // Must hold context lock before calling GetDecodedImageForDraw / |
507 // DrawWithImageFinished. | 508 // DrawWithImageFinished. |
508 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 509 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
509 DecodedDrawImage decoded_draw_image = | 510 DecodedDrawImage decoded_draw_image = |
510 controller.GetDecodedImageForDraw(draw_image); | 511 controller.GetDecodedImageForDraw(draw_image); |
511 EXPECT_FALSE(decoded_draw_image.image()); | 512 EXPECT_FALSE(decoded_draw_image.image()); |
512 | 513 |
513 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 514 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
514 } | 515 } |
515 | 516 |
516 TEST(GpuImageDecodeControllerTest, CanceledTasksDoNotCountAgainstBudget) { | 517 TEST(GpuImageDecodeControllerTest, CanceledTasksDoNotCountAgainstBudget) { |
517 auto context_provider = TestContextProvider::Create(); | 518 auto context_provider = TestContextProvider::Create(); |
518 context_provider->BindToCurrentThread(); | 519 context_provider->BindToCurrentThread(); |
519 GpuImageDecodeController controller(context_provider.get(), | 520 GpuImageDecodeController controller(context_provider.get(), |
520 ResourceFormat::RGBA_8888); | 521 ResourceFormat::RGBA_8888); |
521 bool is_decomposable = true; | 522 bool is_decomposable = true; |
522 uint64_t prepare_tiles_id = 1; | 523 uint64_t prepare_tiles_id = 1; |
523 SkFilterQuality quality = kHigh_SkFilterQuality; | 524 SkFilterQuality quality = kHigh_SkFilterQuality; |
524 | 525 |
525 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 526 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
526 DrawImage draw_image( | 527 DrawImage draw_image( |
527 image.get(), SkIRect::MakeXYWH(0, 0, image->width(), image->height()), | 528 image.get(), SkIRect::MakeXYWH(0, 0, image->width(), image->height()), |
528 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 529 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
529 | 530 |
530 scoped_refptr<ImageDecodeTask> task; | 531 scoped_refptr<TileTask> task; |
531 bool need_unref = | 532 bool need_unref = |
532 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 533 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
533 EXPECT_NE(0u, controller.GetBytesUsedForTesting()); | 534 EXPECT_NE(0u, controller.GetBytesUsedForTesting()); |
534 EXPECT_TRUE(task); | 535 EXPECT_TRUE(task); |
535 EXPECT_TRUE(need_unref); | 536 EXPECT_TRUE(need_unref); |
536 | 537 |
537 ScheduleTask(task->dependency().get()); | 538 ScheduleTask(task->dependencies()[0].get()); |
538 CompleteTask(task->dependency().get()); | 539 CompleteTask(task->dependencies()[0].get()); |
539 ScheduleTask(task.get()); | 540 ScheduleTask(task.get()); |
540 CompleteTask(task.get()); | 541 CompleteTask(task.get()); |
541 | 542 |
542 controller.UnrefImage(draw_image); | 543 controller.UnrefImage(draw_image); |
543 EXPECT_EQ(0u, controller.GetBytesUsedForTesting()); | 544 EXPECT_EQ(0u, controller.GetBytesUsedForTesting()); |
544 } | 545 } |
545 | 546 |
546 TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { | 547 TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { |
547 auto context_provider = TestContextProvider::Create(); | 548 auto context_provider = TestContextProvider::Create(); |
548 context_provider->BindToCurrentThread(); | 549 context_provider->BindToCurrentThread(); |
549 GpuImageDecodeController controller(context_provider.get(), | 550 GpuImageDecodeController controller(context_provider.get(), |
550 ResourceFormat::RGBA_8888); | 551 ResourceFormat::RGBA_8888); |
551 bool is_decomposable = true; | 552 bool is_decomposable = true; |
552 uint64_t prepare_tiles_id = 1; | 553 uint64_t prepare_tiles_id = 1; |
553 SkFilterQuality quality = kHigh_SkFilterQuality; | 554 SkFilterQuality quality = kHigh_SkFilterQuality; |
554 | 555 |
555 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 556 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
556 DrawImage draw_image( | 557 DrawImage draw_image( |
557 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 558 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
558 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 559 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
559 scoped_refptr<ImageDecodeTask> task; | 560 scoped_refptr<TileTask> task; |
560 { | 561 { |
561 bool need_unref = | 562 bool need_unref = |
562 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 563 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
563 EXPECT_TRUE(need_unref); | 564 EXPECT_TRUE(need_unref); |
564 EXPECT_TRUE(task); | 565 EXPECT_TRUE(task); |
565 } | 566 } |
566 | 567 |
567 ProcessTask(task->dependency().get()); | 568 ProcessTask(task->dependencies()[0].get()); |
568 ProcessTask(task.get()); | 569 ProcessTask(task.get()); |
569 | 570 |
570 controller.UnrefImage(draw_image); | 571 controller.UnrefImage(draw_image); |
571 | 572 |
572 // We should now have data image in our cache. | 573 // We should now have data image in our cache. |
573 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); | 574 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); |
574 | 575 |
575 // Tell our controller to aggressively free resources. | 576 // Tell our controller to aggressively free resources. |
576 controller.SetShouldAggressivelyFreeResources(true); | 577 controller.SetShouldAggressivelyFreeResources(true); |
577 DCHECK_EQ(0u, controller.GetBytesUsedForTesting()); | 578 DCHECK_EQ(0u, controller.GetBytesUsedForTesting()); |
578 | 579 |
579 // Attempting to upload a new image should result in at-raster decode. | 580 // Attempting to upload a new image should result in at-raster decode. |
580 { | 581 { |
581 bool need_unref = | 582 bool need_unref = |
582 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 583 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
583 EXPECT_FALSE(need_unref); | 584 EXPECT_FALSE(need_unref); |
584 EXPECT_FALSE(task); | 585 EXPECT_FALSE(task); |
585 } | 586 } |
586 | 587 |
587 // We now tell the controller to not aggressively free resources. Uploads | 588 // We now tell the controller to not aggressively free resources. Uploads |
588 // should work again. | 589 // should work again. |
589 controller.SetShouldAggressivelyFreeResources(false); | 590 controller.SetShouldAggressivelyFreeResources(false); |
590 { | 591 { |
591 bool need_unref = | 592 bool need_unref = |
592 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 593 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
593 EXPECT_TRUE(need_unref); | 594 EXPECT_TRUE(need_unref); |
594 EXPECT_TRUE(task); | 595 EXPECT_TRUE(task); |
595 } | 596 } |
596 | 597 |
597 ProcessTask(task->dependency().get()); | 598 ProcessTask(task->dependencies()[0].get()); |
598 ProcessTask(task.get()); | 599 ProcessTask(task.get()); |
599 | 600 |
600 // The image should be in our cache after un-ref. | 601 // The image should be in our cache after un-ref. |
601 controller.UnrefImage(draw_image); | 602 controller.UnrefImage(draw_image); |
602 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); | 603 DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); |
603 } | 604 } |
604 | 605 |
605 } // namespace | 606 } // namespace |
606 } // namespace cc | 607 } // namespace cc |
OLD | NEW |