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_cache.h" | 5 #include "cc/tiles/gpu_image_decode_cache.h" |
6 | 6 |
7 #include "cc/paint/draw_image.h" | 7 #include "cc/paint/draw_image.h" |
8 #include "cc/test/test_context_provider.h" | 8 #include "cc/test/test_context_provider.h" |
9 #include "cc/test/test_tile_task_runner.h" | 9 #include "cc/test/test_tile_task_runner.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
49 } | 49 } |
50 | 50 |
51 TEST(GpuImageDecodeCacheTest, GetTaskForImageSameImage) { | 51 TEST(GpuImageDecodeCacheTest, GetTaskForImageSameImage) { |
52 auto context_provider = TestContextProvider::Create(); | 52 auto context_provider = TestContextProvider::Create(); |
53 context_provider->BindToCurrentThread(); | 53 context_provider->BindToCurrentThread(); |
54 TestGpuImageDecodeCache cache(context_provider.get()); | 54 TestGpuImageDecodeCache cache(context_provider.get()); |
55 sk_sp<SkImage> image = CreateImage(100, 100); | 55 sk_sp<SkImage> image = CreateImage(100, 100); |
56 bool is_decomposable = true; | 56 bool is_decomposable = true; |
57 SkFilterQuality quality = kHigh_SkFilterQuality; | 57 SkFilterQuality quality = kHigh_SkFilterQuality; |
58 | 58 |
59 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 59 DrawImage draw_image( |
60 quality, | 60 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
61 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 61 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
62 DefaultColorSpace()); | 62 DefaultColorSpace()); |
63 scoped_refptr<TileTask> task; | 63 scoped_refptr<TileTask> task; |
64 bool need_unref = cache.GetTaskForImageAndRef( | 64 bool need_unref = cache.GetTaskForImageAndRef( |
65 draw_image, ImageDecodeCache::TracingInfo(), &task); | 65 draw_image, ImageDecodeCache::TracingInfo(), &task); |
66 EXPECT_TRUE(need_unref); | 66 EXPECT_TRUE(need_unref); |
67 EXPECT_TRUE(task); | 67 EXPECT_TRUE(task); |
68 | 68 |
69 DrawImage another_draw_image( | 69 DrawImage another_draw_image( |
70 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 70 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
71 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 71 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
72 DefaultColorSpace()); | 72 DefaultColorSpace()); |
73 scoped_refptr<TileTask> another_task; | 73 scoped_refptr<TileTask> another_task; |
74 need_unref = cache.GetTaskForImageAndRef( | 74 need_unref = cache.GetTaskForImageAndRef( |
75 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 75 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
76 EXPECT_TRUE(need_unref); | 76 EXPECT_TRUE(need_unref); |
77 EXPECT_TRUE(task.get() == another_task.get()); | 77 EXPECT_TRUE(task.get() == another_task.get()); |
78 | 78 |
79 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 79 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
80 TestTileTaskRunner::ProcessTask(task.get()); | 80 TestTileTaskRunner::ProcessTask(task.get()); |
81 | 81 |
82 cache.UnrefImage(draw_image); | 82 cache.UnrefImage(draw_image); |
83 cache.UnrefImage(draw_image); | 83 cache.UnrefImage(draw_image); |
84 } | 84 } |
85 | 85 |
86 TEST(GpuImageDecodeCacheTest, GetTaskForImageSmallerScale) { | 86 TEST(GpuImageDecodeCacheTest, GetTaskForImageSmallerScale) { |
87 auto context_provider = TestContextProvider::Create(); | 87 auto context_provider = TestContextProvider::Create(); |
88 context_provider->BindToCurrentThread(); | 88 context_provider->BindToCurrentThread(); |
89 TestGpuImageDecodeCache cache(context_provider.get()); | 89 TestGpuImageDecodeCache cache(context_provider.get()); |
90 sk_sp<SkImage> image = CreateImage(100, 100); | 90 sk_sp<SkImage> image = CreateImage(100, 100); |
91 bool is_decomposable = true; | 91 bool is_decomposable = true; |
92 SkFilterQuality quality = kHigh_SkFilterQuality; | 92 SkFilterQuality quality = kHigh_SkFilterQuality; |
93 | 93 |
94 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 94 DrawImage draw_image( |
95 quality, | 95 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
96 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 96 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
97 DefaultColorSpace()); | 97 DefaultColorSpace()); |
98 scoped_refptr<TileTask> task; | 98 scoped_refptr<TileTask> task; |
99 bool need_unref = cache.GetTaskForImageAndRef( | 99 bool need_unref = cache.GetTaskForImageAndRef( |
100 draw_image, ImageDecodeCache::TracingInfo(), &task); | 100 draw_image, ImageDecodeCache::TracingInfo(), &task); |
101 EXPECT_TRUE(need_unref); | 101 EXPECT_TRUE(need_unref); |
102 EXPECT_TRUE(task); | 102 EXPECT_TRUE(task); |
103 | 103 |
104 DrawImage another_draw_image( | 104 DrawImage another_draw_image( |
105 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 105 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
106 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 106 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
107 DefaultColorSpace()); | 107 DefaultColorSpace()); |
108 scoped_refptr<TileTask> another_task; | 108 scoped_refptr<TileTask> another_task; |
109 need_unref = cache.GetTaskForImageAndRef( | 109 need_unref = cache.GetTaskForImageAndRef( |
110 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 110 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
111 EXPECT_TRUE(need_unref); | 111 EXPECT_TRUE(need_unref); |
112 EXPECT_TRUE(task.get() == another_task.get()); | 112 EXPECT_TRUE(task.get() == another_task.get()); |
113 | 113 |
114 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 114 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
115 TestTileTaskRunner::ProcessTask(task.get()); | 115 TestTileTaskRunner::ProcessTask(task.get()); |
116 | 116 |
117 cache.UnrefImage(draw_image); | 117 cache.UnrefImage(draw_image); |
118 cache.UnrefImage(another_draw_image); | 118 cache.UnrefImage(another_draw_image); |
119 } | 119 } |
120 | 120 |
121 TEST(GpuImageDecodeCacheTest, GetTaskForImageLowerQuality) { | 121 TEST(GpuImageDecodeCacheTest, GetTaskForImageLowerQuality) { |
122 auto context_provider = TestContextProvider::Create(); | 122 auto context_provider = TestContextProvider::Create(); |
123 context_provider->BindToCurrentThread(); | 123 context_provider->BindToCurrentThread(); |
124 TestGpuImageDecodeCache cache(context_provider.get()); | 124 TestGpuImageDecodeCache cache(context_provider.get()); |
125 sk_sp<SkImage> image = CreateImage(100, 100); | 125 sk_sp<SkImage> image = CreateImage(100, 100); |
126 bool is_decomposable = true; | 126 bool is_decomposable = true; |
127 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); | 127 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); |
128 | 128 |
129 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 129 DrawImage draw_image(PaintImage(image), |
| 130 SkIRect::MakeWH(image->width(), image->height()), |
130 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); | 131 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); |
131 scoped_refptr<TileTask> task; | 132 scoped_refptr<TileTask> task; |
132 bool need_unref = cache.GetTaskForImageAndRef( | 133 bool need_unref = cache.GetTaskForImageAndRef( |
133 draw_image, ImageDecodeCache::TracingInfo(), &task); | 134 draw_image, ImageDecodeCache::TracingInfo(), &task); |
134 EXPECT_TRUE(need_unref); | 135 EXPECT_TRUE(need_unref); |
135 EXPECT_TRUE(task); | 136 EXPECT_TRUE(task); |
136 | 137 |
137 DrawImage another_draw_image( | 138 DrawImage another_draw_image( |
138 image, SkIRect::MakeWH(image->width(), image->height()), | 139 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
139 kLow_SkFilterQuality, matrix, DefaultColorSpace()); | 140 kLow_SkFilterQuality, matrix, DefaultColorSpace()); |
140 scoped_refptr<TileTask> another_task; | 141 scoped_refptr<TileTask> another_task; |
141 need_unref = cache.GetTaskForImageAndRef( | 142 need_unref = cache.GetTaskForImageAndRef( |
142 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 143 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
143 EXPECT_TRUE(need_unref); | 144 EXPECT_TRUE(need_unref); |
144 EXPECT_TRUE(task.get() == another_task.get()); | 145 EXPECT_TRUE(task.get() == another_task.get()); |
145 | 146 |
146 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 147 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
147 TestTileTaskRunner::ProcessTask(task.get()); | 148 TestTileTaskRunner::ProcessTask(task.get()); |
148 | 149 |
149 cache.UnrefImage(draw_image); | 150 cache.UnrefImage(draw_image); |
150 cache.UnrefImage(another_draw_image); | 151 cache.UnrefImage(another_draw_image); |
151 } | 152 } |
152 | 153 |
153 TEST(GpuImageDecodeCacheTest, GetTaskForImageDifferentImage) { | 154 TEST(GpuImageDecodeCacheTest, GetTaskForImageDifferentImage) { |
154 auto context_provider = TestContextProvider::Create(); | 155 auto context_provider = TestContextProvider::Create(); |
155 context_provider->BindToCurrentThread(); | 156 context_provider->BindToCurrentThread(); |
156 TestGpuImageDecodeCache cache(context_provider.get()); | 157 TestGpuImageDecodeCache cache(context_provider.get()); |
157 bool is_decomposable = true; | 158 bool is_decomposable = true; |
158 SkFilterQuality quality = kHigh_SkFilterQuality; | 159 SkFilterQuality quality = kHigh_SkFilterQuality; |
159 | 160 |
160 sk_sp<SkImage> first_image = CreateImage(100, 100); | 161 sk_sp<SkImage> first_image = CreateImage(100, 100); |
161 DrawImage first_draw_image( | 162 DrawImage first_draw_image( |
162 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 163 PaintImage(first_image), |
163 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 164 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 165 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
164 DefaultColorSpace()); | 166 DefaultColorSpace()); |
165 scoped_refptr<TileTask> first_task; | 167 scoped_refptr<TileTask> first_task; |
166 bool need_unref = cache.GetTaskForImageAndRef( | 168 bool need_unref = cache.GetTaskForImageAndRef( |
167 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 169 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
168 EXPECT_TRUE(need_unref); | 170 EXPECT_TRUE(need_unref); |
169 EXPECT_TRUE(first_task); | 171 EXPECT_TRUE(first_task); |
170 | 172 |
171 sk_sp<SkImage> second_image = CreateImage(100, 100); | 173 sk_sp<SkImage> second_image = CreateImage(100, 100); |
172 DrawImage second_draw_image( | 174 DrawImage second_draw_image( |
173 second_image, | 175 PaintImage(second_image), |
174 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 176 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
175 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable), | 177 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable), |
176 DefaultColorSpace()); | 178 DefaultColorSpace()); |
177 scoped_refptr<TileTask> second_task; | 179 scoped_refptr<TileTask> second_task; |
178 need_unref = cache.GetTaskForImageAndRef( | 180 need_unref = cache.GetTaskForImageAndRef( |
179 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 181 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
180 EXPECT_TRUE(need_unref); | 182 EXPECT_TRUE(need_unref); |
181 EXPECT_TRUE(second_task); | 183 EXPECT_TRUE(second_task); |
182 EXPECT_TRUE(first_task.get() != second_task.get()); | 184 EXPECT_TRUE(first_task.get() != second_task.get()); |
183 | 185 |
184 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | 186 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
185 TestTileTaskRunner::ProcessTask(first_task.get()); | 187 TestTileTaskRunner::ProcessTask(first_task.get()); |
186 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 188 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
187 TestTileTaskRunner::ProcessTask(second_task.get()); | 189 TestTileTaskRunner::ProcessTask(second_task.get()); |
188 | 190 |
189 cache.UnrefImage(first_draw_image); | 191 cache.UnrefImage(first_draw_image); |
190 cache.UnrefImage(second_draw_image); | 192 cache.UnrefImage(second_draw_image); |
191 } | 193 } |
192 | 194 |
193 TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScale) { | 195 TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScale) { |
194 auto context_provider = TestContextProvider::Create(); | 196 auto context_provider = TestContextProvider::Create(); |
195 context_provider->BindToCurrentThread(); | 197 context_provider->BindToCurrentThread(); |
196 TestGpuImageDecodeCache cache(context_provider.get()); | 198 TestGpuImageDecodeCache cache(context_provider.get()); |
197 bool is_decomposable = true; | 199 bool is_decomposable = true; |
198 SkFilterQuality quality = kHigh_SkFilterQuality; | 200 SkFilterQuality quality = kHigh_SkFilterQuality; |
199 | 201 |
200 sk_sp<SkImage> first_image = CreateImage(100, 100); | 202 sk_sp<SkImage> first_image = CreateImage(100, 100); |
201 DrawImage first_draw_image( | 203 DrawImage first_draw_image( |
202 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 204 PaintImage(first_image), |
203 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 205 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 206 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
204 DefaultColorSpace()); | 207 DefaultColorSpace()); |
205 scoped_refptr<TileTask> first_task; | 208 scoped_refptr<TileTask> first_task; |
206 bool need_unref = cache.GetTaskForImageAndRef( | 209 bool need_unref = cache.GetTaskForImageAndRef( |
207 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 210 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
208 EXPECT_TRUE(need_unref); | 211 EXPECT_TRUE(need_unref); |
209 EXPECT_TRUE(first_task); | 212 EXPECT_TRUE(first_task); |
210 | 213 |
211 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | 214 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
212 TestTileTaskRunner::ProcessTask(first_task.get()); | 215 TestTileTaskRunner::ProcessTask(first_task.get()); |
213 | 216 |
214 cache.UnrefImage(first_draw_image); | 217 cache.UnrefImage(first_draw_image); |
215 | 218 |
216 DrawImage second_draw_image( | 219 DrawImage second_draw_image( |
217 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 220 PaintImage(first_image), |
218 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 221 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 222 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
219 DefaultColorSpace()); | 223 DefaultColorSpace()); |
220 scoped_refptr<TileTask> second_task; | 224 scoped_refptr<TileTask> second_task; |
221 need_unref = cache.GetTaskForImageAndRef( | 225 need_unref = cache.GetTaskForImageAndRef( |
222 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 226 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
223 EXPECT_TRUE(need_unref); | 227 EXPECT_TRUE(need_unref); |
224 EXPECT_TRUE(second_task); | 228 EXPECT_TRUE(second_task); |
225 EXPECT_TRUE(first_task.get() != second_task.get()); | 229 EXPECT_TRUE(first_task.get() != second_task.get()); |
226 | 230 |
227 DrawImage third_draw_image( | 231 DrawImage third_draw_image( |
228 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 232 PaintImage(first_image), |
229 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 233 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 234 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
230 DefaultColorSpace()); | 235 DefaultColorSpace()); |
231 scoped_refptr<TileTask> third_task; | 236 scoped_refptr<TileTask> third_task; |
232 need_unref = cache.GetTaskForImageAndRef( | 237 need_unref = cache.GetTaskForImageAndRef( |
233 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); | 238 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
234 EXPECT_TRUE(need_unref); | 239 EXPECT_TRUE(need_unref); |
235 EXPECT_TRUE(third_task.get() == second_task.get()); | 240 EXPECT_TRUE(third_task.get() == second_task.get()); |
236 | 241 |
237 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 242 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
238 TestTileTaskRunner::ProcessTask(second_task.get()); | 243 TestTileTaskRunner::ProcessTask(second_task.get()); |
239 | 244 |
240 cache.UnrefImage(second_draw_image); | 245 cache.UnrefImage(second_draw_image); |
241 cache.UnrefImage(third_draw_image); | 246 cache.UnrefImage(third_draw_image); |
242 } | 247 } |
243 | 248 |
244 TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScaleNoReuse) { | 249 TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScaleNoReuse) { |
245 auto context_provider = TestContextProvider::Create(); | 250 auto context_provider = TestContextProvider::Create(); |
246 context_provider->BindToCurrentThread(); | 251 context_provider->BindToCurrentThread(); |
247 TestGpuImageDecodeCache cache(context_provider.get()); | 252 TestGpuImageDecodeCache cache(context_provider.get()); |
248 bool is_decomposable = true; | 253 bool is_decomposable = true; |
249 SkFilterQuality quality = kHigh_SkFilterQuality; | 254 SkFilterQuality quality = kHigh_SkFilterQuality; |
250 | 255 |
251 sk_sp<SkImage> first_image = CreateImage(100, 100); | 256 sk_sp<SkImage> first_image = CreateImage(100, 100); |
252 DrawImage first_draw_image( | 257 DrawImage first_draw_image( |
253 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 258 PaintImage(first_image), |
254 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 259 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 260 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
255 DefaultColorSpace()); | 261 DefaultColorSpace()); |
256 scoped_refptr<TileTask> first_task; | 262 scoped_refptr<TileTask> first_task; |
257 bool need_unref = cache.GetTaskForImageAndRef( | 263 bool need_unref = cache.GetTaskForImageAndRef( |
258 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 264 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
259 EXPECT_TRUE(need_unref); | 265 EXPECT_TRUE(need_unref); |
260 EXPECT_TRUE(first_task); | 266 EXPECT_TRUE(first_task); |
261 | 267 |
262 DrawImage second_draw_image( | 268 DrawImage second_draw_image( |
263 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 269 PaintImage(first_image), |
264 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 270 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 271 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
265 DefaultColorSpace()); | 272 DefaultColorSpace()); |
266 scoped_refptr<TileTask> second_task; | 273 scoped_refptr<TileTask> second_task; |
267 need_unref = cache.GetTaskForImageAndRef( | 274 need_unref = cache.GetTaskForImageAndRef( |
268 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 275 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
269 EXPECT_TRUE(need_unref); | 276 EXPECT_TRUE(need_unref); |
270 EXPECT_TRUE(second_task); | 277 EXPECT_TRUE(second_task); |
271 EXPECT_TRUE(first_task.get() != second_task.get()); | 278 EXPECT_TRUE(first_task.get() != second_task.get()); |
272 | 279 |
273 DrawImage third_draw_image( | 280 DrawImage third_draw_image( |
274 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 281 PaintImage(first_image), |
275 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 282 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 283 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
276 DefaultColorSpace()); | 284 DefaultColorSpace()); |
277 scoped_refptr<TileTask> third_task; | 285 scoped_refptr<TileTask> third_task; |
278 need_unref = cache.GetTaskForImageAndRef( | 286 need_unref = cache.GetTaskForImageAndRef( |
279 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); | 287 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
280 EXPECT_TRUE(need_unref); | 288 EXPECT_TRUE(need_unref); |
281 EXPECT_TRUE(third_task.get() == first_task.get()); | 289 EXPECT_TRUE(third_task.get() == first_task.get()); |
282 | 290 |
283 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | 291 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
284 TestTileTaskRunner::ProcessTask(first_task.get()); | 292 TestTileTaskRunner::ProcessTask(first_task.get()); |
285 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 293 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
286 TestTileTaskRunner::ProcessTask(second_task.get()); | 294 TestTileTaskRunner::ProcessTask(second_task.get()); |
287 | 295 |
288 cache.UnrefImage(first_draw_image); | 296 cache.UnrefImage(first_draw_image); |
289 cache.UnrefImage(second_draw_image); | 297 cache.UnrefImage(second_draw_image); |
290 cache.UnrefImage(third_draw_image); | 298 cache.UnrefImage(third_draw_image); |
291 } | 299 } |
292 | 300 |
293 TEST(GpuImageDecodeCacheTest, GetTaskForImageHigherQuality) { | 301 TEST(GpuImageDecodeCacheTest, GetTaskForImageHigherQuality) { |
294 auto context_provider = TestContextProvider::Create(); | 302 auto context_provider = TestContextProvider::Create(); |
295 context_provider->BindToCurrentThread(); | 303 context_provider->BindToCurrentThread(); |
296 TestGpuImageDecodeCache cache(context_provider.get()); | 304 TestGpuImageDecodeCache cache(context_provider.get()); |
297 bool is_decomposable = true; | 305 bool is_decomposable = true; |
298 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); | 306 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); |
299 | 307 |
300 sk_sp<SkImage> first_image = CreateImage(100, 100); | 308 sk_sp<SkImage> first_image = CreateImage(100, 100); |
301 DrawImage first_draw_image( | 309 DrawImage first_draw_image( |
302 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 310 PaintImage(first_image), |
| 311 SkIRect::MakeWH(first_image->width(), first_image->height()), |
303 kLow_SkFilterQuality, matrix, DefaultColorSpace()); | 312 kLow_SkFilterQuality, matrix, DefaultColorSpace()); |
304 scoped_refptr<TileTask> first_task; | 313 scoped_refptr<TileTask> first_task; |
305 bool need_unref = cache.GetTaskForImageAndRef( | 314 bool need_unref = cache.GetTaskForImageAndRef( |
306 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 315 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
307 EXPECT_TRUE(need_unref); | 316 EXPECT_TRUE(need_unref); |
308 EXPECT_TRUE(first_task); | 317 EXPECT_TRUE(first_task); |
309 | 318 |
310 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | 319 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
311 TestTileTaskRunner::ProcessTask(first_task.get()); | 320 TestTileTaskRunner::ProcessTask(first_task.get()); |
312 | 321 |
313 cache.UnrefImage(first_draw_image); | 322 cache.UnrefImage(first_draw_image); |
314 | 323 |
315 DrawImage second_draw_image( | 324 DrawImage second_draw_image( |
316 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 325 PaintImage(first_image), |
| 326 SkIRect::MakeWH(first_image->width(), first_image->height()), |
317 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); | 327 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); |
318 scoped_refptr<TileTask> second_task; | 328 scoped_refptr<TileTask> second_task; |
319 need_unref = cache.GetTaskForImageAndRef( | 329 need_unref = cache.GetTaskForImageAndRef( |
320 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 330 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
321 EXPECT_TRUE(need_unref); | 331 EXPECT_TRUE(need_unref); |
322 EXPECT_TRUE(second_task); | 332 EXPECT_TRUE(second_task); |
323 EXPECT_TRUE(first_task.get() != second_task.get()); | 333 EXPECT_TRUE(first_task.get() != second_task.get()); |
324 | 334 |
325 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 335 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
326 TestTileTaskRunner::ProcessTask(second_task.get()); | 336 TestTileTaskRunner::ProcessTask(second_task.get()); |
327 | 337 |
328 cache.UnrefImage(second_draw_image); | 338 cache.UnrefImage(second_draw_image); |
329 } | 339 } |
330 | 340 |
331 TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedAndLocked) { | 341 TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedAndLocked) { |
332 auto context_provider = TestContextProvider::Create(); | 342 auto context_provider = TestContextProvider::Create(); |
333 context_provider->BindToCurrentThread(); | 343 context_provider->BindToCurrentThread(); |
334 TestGpuImageDecodeCache cache(context_provider.get()); | 344 TestGpuImageDecodeCache cache(context_provider.get()); |
335 bool is_decomposable = true; | 345 bool is_decomposable = true; |
336 SkFilterQuality quality = kHigh_SkFilterQuality; | 346 SkFilterQuality quality = kHigh_SkFilterQuality; |
337 | 347 |
338 sk_sp<SkImage> image = CreateImage(100, 100); | 348 sk_sp<SkImage> image = CreateImage(100, 100); |
339 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 349 DrawImage draw_image( |
340 quality, | 350 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
341 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 351 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
342 DefaultColorSpace()); | 352 DefaultColorSpace()); |
343 scoped_refptr<TileTask> task; | 353 scoped_refptr<TileTask> task; |
344 bool need_unref = cache.GetTaskForImageAndRef( | 354 bool need_unref = cache.GetTaskForImageAndRef( |
345 draw_image, ImageDecodeCache::TracingInfo(), &task); | 355 draw_image, ImageDecodeCache::TracingInfo(), &task); |
346 EXPECT_TRUE(need_unref); | 356 EXPECT_TRUE(need_unref); |
347 EXPECT_TRUE(task); | 357 EXPECT_TRUE(task); |
348 EXPECT_EQ(task->dependencies().size(), 1u); | 358 EXPECT_EQ(task->dependencies().size(), 1u); |
349 EXPECT_TRUE(task->dependencies()[0]); | 359 EXPECT_TRUE(task->dependencies()[0]); |
350 | 360 |
351 // Run the decode but don't complete it (this will keep the decode locked). | 361 // Run the decode but don't complete it (this will keep the decode locked). |
352 TestTileTaskRunner::ScheduleTask(task->dependencies()[0].get()); | 362 TestTileTaskRunner::ScheduleTask(task->dependencies()[0].get()); |
(...skipping 22 matching lines...) Expand all Loading... |
375 } | 385 } |
376 | 386 |
377 TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedNotLocked) { | 387 TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedNotLocked) { |
378 auto context_provider = TestContextProvider::Create(); | 388 auto context_provider = TestContextProvider::Create(); |
379 context_provider->BindToCurrentThread(); | 389 context_provider->BindToCurrentThread(); |
380 TestGpuImageDecodeCache cache(context_provider.get()); | 390 TestGpuImageDecodeCache cache(context_provider.get()); |
381 bool is_decomposable = true; | 391 bool is_decomposable = true; |
382 SkFilterQuality quality = kHigh_SkFilterQuality; | 392 SkFilterQuality quality = kHigh_SkFilterQuality; |
383 | 393 |
384 sk_sp<SkImage> image = CreateImage(100, 100); | 394 sk_sp<SkImage> image = CreateImage(100, 100); |
385 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 395 DrawImage draw_image( |
386 quality, | 396 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
387 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 397 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
388 DefaultColorSpace()); | 398 DefaultColorSpace()); |
389 scoped_refptr<TileTask> task; | 399 scoped_refptr<TileTask> task; |
390 bool need_unref = cache.GetTaskForImageAndRef( | 400 bool need_unref = cache.GetTaskForImageAndRef( |
391 draw_image, ImageDecodeCache::TracingInfo(), &task); | 401 draw_image, ImageDecodeCache::TracingInfo(), &task); |
392 EXPECT_TRUE(need_unref); | 402 EXPECT_TRUE(need_unref); |
393 EXPECT_TRUE(task); | 403 EXPECT_TRUE(task); |
394 EXPECT_EQ(task->dependencies().size(), 1u); | 404 EXPECT_EQ(task->dependencies().size(), 1u); |
395 EXPECT_TRUE(task->dependencies()[0]); | 405 EXPECT_TRUE(task->dependencies()[0]); |
396 | 406 |
397 // Run the decode. | 407 // Run the decode. |
398 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 408 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
(...skipping 22 matching lines...) Expand all Loading... |
421 } | 431 } |
422 | 432 |
423 TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyUploaded) { | 433 TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyUploaded) { |
424 auto context_provider = TestContextProvider::Create(); | 434 auto context_provider = TestContextProvider::Create(); |
425 context_provider->BindToCurrentThread(); | 435 context_provider->BindToCurrentThread(); |
426 TestGpuImageDecodeCache cache(context_provider.get()); | 436 TestGpuImageDecodeCache cache(context_provider.get()); |
427 bool is_decomposable = true; | 437 bool is_decomposable = true; |
428 SkFilterQuality quality = kHigh_SkFilterQuality; | 438 SkFilterQuality quality = kHigh_SkFilterQuality; |
429 | 439 |
430 sk_sp<SkImage> image = CreateImage(100, 100); | 440 sk_sp<SkImage> image = CreateImage(100, 100); |
431 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 441 DrawImage draw_image( |
432 quality, | 442 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
433 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 443 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
434 DefaultColorSpace()); | 444 DefaultColorSpace()); |
435 scoped_refptr<TileTask> task; | 445 scoped_refptr<TileTask> task; |
436 bool need_unref = cache.GetTaskForImageAndRef( | 446 bool need_unref = cache.GetTaskForImageAndRef( |
437 draw_image, ImageDecodeCache::TracingInfo(), &task); | 447 draw_image, ImageDecodeCache::TracingInfo(), &task); |
438 EXPECT_TRUE(need_unref); | 448 EXPECT_TRUE(need_unref); |
439 EXPECT_TRUE(task); | 449 EXPECT_TRUE(task); |
440 EXPECT_EQ(task->dependencies().size(), 1u); | 450 EXPECT_EQ(task->dependencies().size(), 1u); |
441 EXPECT_TRUE(task->dependencies()[0]); | 451 EXPECT_TRUE(task->dependencies()[0]); |
442 | 452 |
443 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 453 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
444 TestTileTaskRunner::ScheduleTask(task.get()); | 454 TestTileTaskRunner::ScheduleTask(task.get()); |
(...skipping 12 matching lines...) Expand all Loading... |
457 } | 467 } |
458 | 468 |
459 TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) { | 469 TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) { |
460 auto context_provider = TestContextProvider::Create(); | 470 auto context_provider = TestContextProvider::Create(); |
461 context_provider->BindToCurrentThread(); | 471 context_provider->BindToCurrentThread(); |
462 TestGpuImageDecodeCache cache(context_provider.get()); | 472 TestGpuImageDecodeCache cache(context_provider.get()); |
463 bool is_decomposable = true; | 473 bool is_decomposable = true; |
464 SkFilterQuality quality = kHigh_SkFilterQuality; | 474 SkFilterQuality quality = kHigh_SkFilterQuality; |
465 | 475 |
466 sk_sp<SkImage> image = CreateImage(100, 100); | 476 sk_sp<SkImage> image = CreateImage(100, 100); |
467 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 477 DrawImage draw_image( |
468 quality, | 478 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
469 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 479 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
470 DefaultColorSpace()); | 480 DefaultColorSpace()); |
471 scoped_refptr<TileTask> task; | 481 scoped_refptr<TileTask> task; |
472 bool need_unref = cache.GetTaskForImageAndRef( | 482 bool need_unref = cache.GetTaskForImageAndRef( |
473 draw_image, ImageDecodeCache::TracingInfo(), &task); | 483 draw_image, ImageDecodeCache::TracingInfo(), &task); |
474 EXPECT_TRUE(need_unref); | 484 EXPECT_TRUE(need_unref); |
475 EXPECT_TRUE(task); | 485 EXPECT_TRUE(task); |
476 | 486 |
477 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 487 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
478 | 488 |
479 scoped_refptr<TileTask> another_task; | 489 scoped_refptr<TileTask> another_task; |
480 need_unref = cache.GetTaskForImageAndRef( | 490 need_unref = cache.GetTaskForImageAndRef( |
(...skipping 24 matching lines...) Expand all Loading... |
505 } | 515 } |
506 | 516 |
507 TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledWhileReffedGetsNewTask) { | 517 TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledWhileReffedGetsNewTask) { |
508 auto context_provider = TestContextProvider::Create(); | 518 auto context_provider = TestContextProvider::Create(); |
509 context_provider->BindToCurrentThread(); | 519 context_provider->BindToCurrentThread(); |
510 TestGpuImageDecodeCache cache(context_provider.get()); | 520 TestGpuImageDecodeCache cache(context_provider.get()); |
511 bool is_decomposable = true; | 521 bool is_decomposable = true; |
512 SkFilterQuality quality = kHigh_SkFilterQuality; | 522 SkFilterQuality quality = kHigh_SkFilterQuality; |
513 | 523 |
514 sk_sp<SkImage> image = CreateImage(100, 100); | 524 sk_sp<SkImage> image = CreateImage(100, 100); |
515 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 525 DrawImage draw_image( |
516 quality, | 526 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
517 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 527 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
518 DefaultColorSpace()); | 528 DefaultColorSpace()); |
519 scoped_refptr<TileTask> task; | 529 scoped_refptr<TileTask> task; |
520 bool need_unref = cache.GetTaskForImageAndRef( | 530 bool need_unref = cache.GetTaskForImageAndRef( |
521 draw_image, ImageDecodeCache::TracingInfo(), &task); | 531 draw_image, ImageDecodeCache::TracingInfo(), &task); |
522 EXPECT_TRUE(need_unref); | 532 EXPECT_TRUE(need_unref); |
523 EXPECT_TRUE(task); | 533 EXPECT_TRUE(task); |
524 | 534 |
525 ASSERT_GT(task->dependencies().size(), 0u); | 535 ASSERT_GT(task->dependencies().size(), 0u); |
526 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 536 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
527 | 537 |
528 scoped_refptr<TileTask> another_task; | 538 scoped_refptr<TileTask> another_task; |
(...skipping 28 matching lines...) Expand all Loading... |
557 } | 567 } |
558 | 568 |
559 TEST(GpuImageDecodeCacheTest, NoTaskForImageAlreadyFailedDecoding) { | 569 TEST(GpuImageDecodeCacheTest, NoTaskForImageAlreadyFailedDecoding) { |
560 auto context_provider = TestContextProvider::Create(); | 570 auto context_provider = TestContextProvider::Create(); |
561 context_provider->BindToCurrentThread(); | 571 context_provider->BindToCurrentThread(); |
562 TestGpuImageDecodeCache cache(context_provider.get()); | 572 TestGpuImageDecodeCache cache(context_provider.get()); |
563 bool is_decomposable = true; | 573 bool is_decomposable = true; |
564 SkFilterQuality quality = kHigh_SkFilterQuality; | 574 SkFilterQuality quality = kHigh_SkFilterQuality; |
565 | 575 |
566 sk_sp<SkImage> image = CreateImage(100, 100); | 576 sk_sp<SkImage> image = CreateImage(100, 100); |
567 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 577 DrawImage draw_image( |
568 quality, | 578 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
569 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 579 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
570 DefaultColorSpace()); | 580 DefaultColorSpace()); |
571 scoped_refptr<TileTask> task; | 581 scoped_refptr<TileTask> task; |
572 bool need_unref = cache.GetTaskForImageAndRef( | 582 bool need_unref = cache.GetTaskForImageAndRef( |
573 draw_image, ImageDecodeCache::TracingInfo(), &task); | 583 draw_image, ImageDecodeCache::TracingInfo(), &task); |
574 EXPECT_TRUE(need_unref); | 584 EXPECT_TRUE(need_unref); |
575 EXPECT_TRUE(task); | 585 EXPECT_TRUE(task); |
576 | 586 |
577 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 587 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
578 // Didn't run the task, so cancel it. | 588 // Didn't run the task, so cancel it. |
579 TestTileTaskRunner::CancelTask(task.get()); | 589 TestTileTaskRunner::CancelTask(task.get()); |
580 TestTileTaskRunner::CompleteTask(task.get()); | 590 TestTileTaskRunner::CompleteTask(task.get()); |
(...skipping 10 matching lines...) Expand all Loading... |
591 } | 601 } |
592 | 602 |
593 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDraw) { | 603 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDraw) { |
594 auto context_provider = TestContextProvider::Create(); | 604 auto context_provider = TestContextProvider::Create(); |
595 context_provider->BindToCurrentThread(); | 605 context_provider->BindToCurrentThread(); |
596 TestGpuImageDecodeCache cache(context_provider.get()); | 606 TestGpuImageDecodeCache cache(context_provider.get()); |
597 bool is_decomposable = true; | 607 bool is_decomposable = true; |
598 SkFilterQuality quality = kHigh_SkFilterQuality; | 608 SkFilterQuality quality = kHigh_SkFilterQuality; |
599 | 609 |
600 sk_sp<SkImage> image = CreateImage(100, 100); | 610 sk_sp<SkImage> image = CreateImage(100, 100); |
601 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 611 DrawImage draw_image( |
602 quality, | 612 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
603 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 613 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
604 DefaultColorSpace()); | 614 DefaultColorSpace()); |
605 scoped_refptr<TileTask> task; | 615 scoped_refptr<TileTask> task; |
606 bool need_unref = cache.GetTaskForImageAndRef( | 616 bool need_unref = cache.GetTaskForImageAndRef( |
607 draw_image, ImageDecodeCache::TracingInfo(), &task); | 617 draw_image, ImageDecodeCache::TracingInfo(), &task); |
608 EXPECT_TRUE(need_unref); | 618 EXPECT_TRUE(need_unref); |
609 EXPECT_TRUE(task); | 619 EXPECT_TRUE(task); |
610 | 620 |
611 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 621 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
612 TestTileTaskRunner::ProcessTask(task.get()); | 622 TestTileTaskRunner::ProcessTask(task.get()); |
613 | 623 |
614 // Must hold context lock before calling GetDecodedImageForDraw / | 624 // Must hold context lock before calling GetDecodedImageForDraw / |
(...skipping 11 matching lines...) Expand all Loading... |
626 } | 636 } |
627 | 637 |
628 TEST(GpuImageDecodeCacheTest, GetLargeDecodedImageForDraw) { | 638 TEST(GpuImageDecodeCacheTest, GetLargeDecodedImageForDraw) { |
629 auto context_provider = TestContextProvider::Create(); | 639 auto context_provider = TestContextProvider::Create(); |
630 context_provider->BindToCurrentThread(); | 640 context_provider->BindToCurrentThread(); |
631 TestGpuImageDecodeCache cache(context_provider.get()); | 641 TestGpuImageDecodeCache cache(context_provider.get()); |
632 bool is_decomposable = true; | 642 bool is_decomposable = true; |
633 SkFilterQuality quality = kHigh_SkFilterQuality; | 643 SkFilterQuality quality = kHigh_SkFilterQuality; |
634 | 644 |
635 sk_sp<SkImage> image = CreateImage(1, 24000); | 645 sk_sp<SkImage> image = CreateImage(1, 24000); |
636 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 646 DrawImage draw_image( |
637 quality, | 647 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
638 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 648 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
639 DefaultColorSpace()); | 649 DefaultColorSpace()); |
640 scoped_refptr<TileTask> task; | 650 scoped_refptr<TileTask> task; |
641 bool need_unref = cache.GetTaskForImageAndRef( | 651 bool need_unref = cache.GetTaskForImageAndRef( |
642 draw_image, ImageDecodeCache::TracingInfo(), &task); | 652 draw_image, ImageDecodeCache::TracingInfo(), &task); |
643 EXPECT_TRUE(need_unref); | 653 EXPECT_TRUE(need_unref); |
644 EXPECT_TRUE(task); | 654 EXPECT_TRUE(task); |
645 | 655 |
646 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 656 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
647 TestTileTaskRunner::ProcessTask(task.get()); | 657 TestTileTaskRunner::ProcessTask(task.get()); |
648 | 658 |
649 // Must hold context lock before calling GetDecodedImageForDraw / | 659 // Must hold context lock before calling GetDecodedImageForDraw / |
(...skipping 14 matching lines...) Expand all Loading... |
664 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) { | 674 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) { |
665 auto context_provider = TestContextProvider::Create(); | 675 auto context_provider = TestContextProvider::Create(); |
666 context_provider->BindToCurrentThread(); | 676 context_provider->BindToCurrentThread(); |
667 TestGpuImageDecodeCache cache(context_provider.get()); | 677 TestGpuImageDecodeCache cache(context_provider.get()); |
668 bool is_decomposable = true; | 678 bool is_decomposable = true; |
669 SkFilterQuality quality = kHigh_SkFilterQuality; | 679 SkFilterQuality quality = kHigh_SkFilterQuality; |
670 | 680 |
671 cache.SetAllByteLimitsForTesting(0); | 681 cache.SetAllByteLimitsForTesting(0); |
672 | 682 |
673 sk_sp<SkImage> image = CreateImage(100, 100); | 683 sk_sp<SkImage> image = CreateImage(100, 100); |
674 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 684 DrawImage draw_image( |
675 quality, | 685 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
676 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 686 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
677 DefaultColorSpace()); | 687 DefaultColorSpace()); |
678 | 688 |
679 scoped_refptr<TileTask> task; | 689 scoped_refptr<TileTask> task; |
680 bool need_unref = cache.GetTaskForImageAndRef( | 690 bool need_unref = cache.GetTaskForImageAndRef( |
681 draw_image, ImageDecodeCache::TracingInfo(), &task); | 691 draw_image, ImageDecodeCache::TracingInfo(), &task); |
682 EXPECT_FALSE(need_unref); | 692 EXPECT_FALSE(need_unref); |
683 EXPECT_FALSE(task); | 693 EXPECT_FALSE(task); |
684 | 694 |
685 // Must hold context lock before calling GetDecodedImageForDraw / | 695 // Must hold context lock before calling GetDecodedImageForDraw / |
686 // DrawWithImageFinished. | 696 // DrawWithImageFinished. |
687 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 697 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
688 DecodedDrawImage decoded_draw_image = | 698 DecodedDrawImage decoded_draw_image = |
689 cache.GetDecodedImageForDraw(draw_image); | 699 cache.GetDecodedImageForDraw(draw_image); |
690 EXPECT_TRUE(decoded_draw_image.image()); | 700 EXPECT_TRUE(decoded_draw_image.image()); |
691 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | 701 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); |
692 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 702 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
693 EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); | 703 EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
694 | 704 |
695 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 705 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
696 } | 706 } |
697 | 707 |
698 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawLargerScale) { | 708 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawLargerScale) { |
699 auto context_provider = TestContextProvider::Create(); | 709 auto context_provider = TestContextProvider::Create(); |
700 context_provider->BindToCurrentThread(); | 710 context_provider->BindToCurrentThread(); |
701 TestGpuImageDecodeCache cache(context_provider.get()); | 711 TestGpuImageDecodeCache cache(context_provider.get()); |
702 bool is_decomposable = true; | 712 bool is_decomposable = true; |
703 SkFilterQuality quality = kHigh_SkFilterQuality; | 713 SkFilterQuality quality = kHigh_SkFilterQuality; |
704 | 714 |
705 sk_sp<SkImage> image = CreateImage(100, 100); | 715 sk_sp<SkImage> image = CreateImage(100, 100); |
706 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 716 DrawImage draw_image( |
707 quality, | 717 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
708 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 718 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
709 DefaultColorSpace()); | 719 DefaultColorSpace()); |
710 scoped_refptr<TileTask> task; | 720 scoped_refptr<TileTask> task; |
711 bool need_unref = cache.GetTaskForImageAndRef( | 721 bool need_unref = cache.GetTaskForImageAndRef( |
712 draw_image, ImageDecodeCache::TracingInfo(), &task); | 722 draw_image, ImageDecodeCache::TracingInfo(), &task); |
713 EXPECT_TRUE(need_unref); | 723 EXPECT_TRUE(need_unref); |
714 EXPECT_TRUE(task); | 724 EXPECT_TRUE(task); |
715 | 725 |
716 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 726 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
717 TestTileTaskRunner::ProcessTask(task.get()); | 727 TestTileTaskRunner::ProcessTask(task.get()); |
718 | 728 |
719 DrawImage larger_draw_image( | 729 DrawImage larger_draw_image( |
720 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 730 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
721 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 731 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
722 DefaultColorSpace()); | 732 DefaultColorSpace()); |
723 scoped_refptr<TileTask> larger_task; | 733 scoped_refptr<TileTask> larger_task; |
724 bool larger_need_unref = cache.GetTaskForImageAndRef( | 734 bool larger_need_unref = cache.GetTaskForImageAndRef( |
725 larger_draw_image, ImageDecodeCache::TracingInfo(), &larger_task); | 735 larger_draw_image, ImageDecodeCache::TracingInfo(), &larger_task); |
726 EXPECT_TRUE(larger_need_unref); | 736 EXPECT_TRUE(larger_need_unref); |
727 EXPECT_TRUE(larger_task); | 737 EXPECT_TRUE(larger_task); |
728 | 738 |
729 TestTileTaskRunner::ProcessTask(larger_task->dependencies()[0].get()); | 739 TestTileTaskRunner::ProcessTask(larger_task->dependencies()[0].get()); |
730 TestTileTaskRunner::ProcessTask(larger_task.get()); | 740 TestTileTaskRunner::ProcessTask(larger_task.get()); |
731 | 741 |
(...skipping 23 matching lines...) Expand all Loading... |
755 } | 765 } |
756 | 766 |
757 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawHigherQuality) { | 767 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawHigherQuality) { |
758 auto context_provider = TestContextProvider::Create(); | 768 auto context_provider = TestContextProvider::Create(); |
759 context_provider->BindToCurrentThread(); | 769 context_provider->BindToCurrentThread(); |
760 TestGpuImageDecodeCache cache(context_provider.get()); | 770 TestGpuImageDecodeCache cache(context_provider.get()); |
761 bool is_decomposable = true; | 771 bool is_decomposable = true; |
762 SkMatrix matrix = CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable); | 772 SkMatrix matrix = CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable); |
763 | 773 |
764 sk_sp<SkImage> image = CreateImage(100, 100); | 774 sk_sp<SkImage> image = CreateImage(100, 100); |
765 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 775 DrawImage draw_image(PaintImage(image), |
| 776 SkIRect::MakeWH(image->width(), image->height()), |
766 kLow_SkFilterQuality, matrix, DefaultColorSpace()); | 777 kLow_SkFilterQuality, matrix, DefaultColorSpace()); |
767 scoped_refptr<TileTask> task; | 778 scoped_refptr<TileTask> task; |
768 bool need_unref = cache.GetTaskForImageAndRef( | 779 bool need_unref = cache.GetTaskForImageAndRef( |
769 draw_image, ImageDecodeCache::TracingInfo(), &task); | 780 draw_image, ImageDecodeCache::TracingInfo(), &task); |
770 EXPECT_TRUE(need_unref); | 781 EXPECT_TRUE(need_unref); |
771 EXPECT_TRUE(task); | 782 EXPECT_TRUE(task); |
772 | 783 |
773 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 784 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
774 TestTileTaskRunner::ProcessTask(task.get()); | 785 TestTileTaskRunner::ProcessTask(task.get()); |
775 | 786 |
776 DrawImage higher_quality_draw_image( | 787 DrawImage higher_quality_draw_image( |
777 image, SkIRect::MakeWH(image->width(), image->height()), | 788 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
778 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); | 789 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); |
779 scoped_refptr<TileTask> hq_task; | 790 scoped_refptr<TileTask> hq_task; |
780 bool hq_needs_unref = cache.GetTaskForImageAndRef( | 791 bool hq_needs_unref = cache.GetTaskForImageAndRef( |
781 higher_quality_draw_image, ImageDecodeCache::TracingInfo(), &hq_task); | 792 higher_quality_draw_image, ImageDecodeCache::TracingInfo(), &hq_task); |
782 EXPECT_TRUE(hq_needs_unref); | 793 EXPECT_TRUE(hq_needs_unref); |
783 EXPECT_TRUE(hq_task); | 794 EXPECT_TRUE(hq_task); |
784 | 795 |
785 TestTileTaskRunner::ProcessTask(hq_task->dependencies()[0].get()); | 796 TestTileTaskRunner::ProcessTask(hq_task->dependencies()[0].get()); |
786 TestTileTaskRunner::ProcessTask(hq_task.get()); | 797 TestTileTaskRunner::ProcessTask(hq_task.get()); |
787 | 798 |
(...skipping 24 matching lines...) Expand all Loading... |
812 } | 823 } |
813 | 824 |
814 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawNegative) { | 825 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawNegative) { |
815 auto context_provider = TestContextProvider::Create(); | 826 auto context_provider = TestContextProvider::Create(); |
816 context_provider->BindToCurrentThread(); | 827 context_provider->BindToCurrentThread(); |
817 TestGpuImageDecodeCache cache(context_provider.get()); | 828 TestGpuImageDecodeCache cache(context_provider.get()); |
818 bool is_decomposable = true; | 829 bool is_decomposable = true; |
819 SkFilterQuality quality = kHigh_SkFilterQuality; | 830 SkFilterQuality quality = kHigh_SkFilterQuality; |
820 | 831 |
821 sk_sp<SkImage> image = CreateImage(100, 100); | 832 sk_sp<SkImage> image = CreateImage(100, 100); |
822 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 833 DrawImage draw_image( |
823 quality, | 834 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
824 CreateMatrix(SkSize::Make(-0.5f, 0.5f), is_decomposable), | 835 quality, CreateMatrix(SkSize::Make(-0.5f, 0.5f), is_decomposable), |
825 DefaultColorSpace()); | 836 DefaultColorSpace()); |
826 scoped_refptr<TileTask> task; | 837 scoped_refptr<TileTask> task; |
827 bool need_unref = cache.GetTaskForImageAndRef( | 838 bool need_unref = cache.GetTaskForImageAndRef( |
828 draw_image, ImageDecodeCache::TracingInfo(), &task); | 839 draw_image, ImageDecodeCache::TracingInfo(), &task); |
829 EXPECT_TRUE(need_unref); | 840 EXPECT_TRUE(need_unref); |
830 EXPECT_TRUE(task); | 841 EXPECT_TRUE(task); |
831 | 842 |
832 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 843 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
833 TestTileTaskRunner::ProcessTask(task.get()); | 844 TestTileTaskRunner::ProcessTask(task.get()); |
834 | 845 |
835 // Must hold context lock before calling GetDecodedImageForDraw / | 846 // Must hold context lock before calling GetDecodedImageForDraw / |
(...skipping 13 matching lines...) Expand all Loading... |
849 } | 860 } |
850 | 861 |
851 TEST(GpuImageDecodeCacheTest, GetLargeScaledDecodedImageForDraw) { | 862 TEST(GpuImageDecodeCacheTest, GetLargeScaledDecodedImageForDraw) { |
852 auto context_provider = TestContextProvider::Create(); | 863 auto context_provider = TestContextProvider::Create(); |
853 context_provider->BindToCurrentThread(); | 864 context_provider->BindToCurrentThread(); |
854 TestGpuImageDecodeCache cache(context_provider.get()); | 865 TestGpuImageDecodeCache cache(context_provider.get()); |
855 bool is_decomposable = true; | 866 bool is_decomposable = true; |
856 SkFilterQuality quality = kHigh_SkFilterQuality; | 867 SkFilterQuality quality = kHigh_SkFilterQuality; |
857 | 868 |
858 sk_sp<SkImage> image = CreateImage(1, 48000); | 869 sk_sp<SkImage> image = CreateImage(1, 48000); |
859 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 870 DrawImage draw_image( |
860 quality, | 871 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
861 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 872 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
862 DefaultColorSpace()); | 873 DefaultColorSpace()); |
863 scoped_refptr<TileTask> task; | 874 scoped_refptr<TileTask> task; |
864 bool need_unref = cache.GetTaskForImageAndRef( | 875 bool need_unref = cache.GetTaskForImageAndRef( |
865 draw_image, ImageDecodeCache::TracingInfo(), &task); | 876 draw_image, ImageDecodeCache::TracingInfo(), &task); |
866 EXPECT_TRUE(need_unref); | 877 EXPECT_TRUE(need_unref); |
867 EXPECT_TRUE(task); | 878 EXPECT_TRUE(task); |
868 | 879 |
869 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 880 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
870 TestTileTaskRunner::ProcessTask(task.get()); | 881 TestTileTaskRunner::ProcessTask(task.get()); |
871 | 882 |
872 // Must hold context lock before calling GetDecodedImageForDraw / | 883 // Must hold context lock before calling GetDecodedImageForDraw / |
(...skipping 17 matching lines...) Expand all Loading... |
890 TEST(GpuImageDecodeCacheTest, AtRasterUsedDirectlyIfSpaceAllows) { | 901 TEST(GpuImageDecodeCacheTest, AtRasterUsedDirectlyIfSpaceAllows) { |
891 auto context_provider = TestContextProvider::Create(); | 902 auto context_provider = TestContextProvider::Create(); |
892 context_provider->BindToCurrentThread(); | 903 context_provider->BindToCurrentThread(); |
893 TestGpuImageDecodeCache cache(context_provider.get()); | 904 TestGpuImageDecodeCache cache(context_provider.get()); |
894 bool is_decomposable = true; | 905 bool is_decomposable = true; |
895 SkFilterQuality quality = kHigh_SkFilterQuality; | 906 SkFilterQuality quality = kHigh_SkFilterQuality; |
896 | 907 |
897 cache.SetAllByteLimitsForTesting(0); | 908 cache.SetAllByteLimitsForTesting(0); |
898 | 909 |
899 sk_sp<SkImage> image = CreateImage(100, 100); | 910 sk_sp<SkImage> image = CreateImage(100, 100); |
900 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 911 DrawImage draw_image( |
901 quality, | 912 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
902 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 913 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
903 DefaultColorSpace()); | 914 DefaultColorSpace()); |
904 | 915 |
905 scoped_refptr<TileTask> task; | 916 scoped_refptr<TileTask> task; |
906 bool need_unref = cache.GetTaskForImageAndRef( | 917 bool need_unref = cache.GetTaskForImageAndRef( |
907 draw_image, ImageDecodeCache::TracingInfo(), &task); | 918 draw_image, ImageDecodeCache::TracingInfo(), &task); |
908 EXPECT_FALSE(need_unref); | 919 EXPECT_FALSE(need_unref); |
909 EXPECT_FALSE(task); | 920 EXPECT_FALSE(task); |
910 | 921 |
911 // Must hold context lock before calling GetDecodedImageForDraw / | 922 // Must hold context lock before calling GetDecodedImageForDraw / |
912 // DrawWithImageFinished. | 923 // DrawWithImageFinished. |
913 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 924 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
(...skipping 22 matching lines...) Expand all Loading... |
936 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { | 947 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
937 auto context_provider = TestContextProvider::Create(); | 948 auto context_provider = TestContextProvider::Create(); |
938 context_provider->BindToCurrentThread(); | 949 context_provider->BindToCurrentThread(); |
939 TestGpuImageDecodeCache cache(context_provider.get()); | 950 TestGpuImageDecodeCache cache(context_provider.get()); |
940 bool is_decomposable = true; | 951 bool is_decomposable = true; |
941 SkFilterQuality quality = kHigh_SkFilterQuality; | 952 SkFilterQuality quality = kHigh_SkFilterQuality; |
942 | 953 |
943 cache.SetAllByteLimitsForTesting(0); | 954 cache.SetAllByteLimitsForTesting(0); |
944 | 955 |
945 sk_sp<SkImage> image = CreateImage(100, 100); | 956 sk_sp<SkImage> image = CreateImage(100, 100); |
946 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 957 DrawImage draw_image( |
947 quality, | 958 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
948 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 959 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
949 DefaultColorSpace()); | 960 DefaultColorSpace()); |
950 | 961 |
951 // Must hold context lock before calling GetDecodedImageForDraw / | 962 // Must hold context lock before calling GetDecodedImageForDraw / |
952 // DrawWithImageFinished. | 963 // DrawWithImageFinished. |
953 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 964 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
954 DecodedDrawImage decoded_draw_image = | 965 DecodedDrawImage decoded_draw_image = |
955 cache.GetDecodedImageForDraw(draw_image); | 966 cache.GetDecodedImageForDraw(draw_image); |
956 EXPECT_TRUE(decoded_draw_image.image()); | 967 EXPECT_TRUE(decoded_draw_image.image()); |
957 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); | 968 EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked()); |
958 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 969 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
959 EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); | 970 EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
960 | 971 |
961 DecodedDrawImage another_decoded_draw_image = | 972 DecodedDrawImage another_decoded_draw_image = |
962 cache.GetDecodedImageForDraw(draw_image); | 973 cache.GetDecodedImageForDraw(draw_image); |
963 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | 974 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
964 another_decoded_draw_image.image()->uniqueID()); | 975 another_decoded_draw_image.image()->uniqueID()); |
965 | 976 |
966 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 977 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
967 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 978 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
968 } | 979 } |
969 | 980 |
970 TEST(GpuImageDecodeCacheTest, | 981 TEST(GpuImageDecodeCacheTest, |
971 GetLargeDecodedImageForDrawAtRasterDecodeMultipleTimes) { | 982 GetLargeDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
972 auto context_provider = TestContextProvider::Create(); | 983 auto context_provider = TestContextProvider::Create(); |
973 context_provider->BindToCurrentThread(); | 984 context_provider->BindToCurrentThread(); |
974 TestGpuImageDecodeCache cache(context_provider.get()); | 985 TestGpuImageDecodeCache cache(context_provider.get()); |
975 bool is_decomposable = true; | 986 bool is_decomposable = true; |
976 SkFilterQuality quality = kHigh_SkFilterQuality; | 987 SkFilterQuality quality = kHigh_SkFilterQuality; |
977 | 988 |
978 sk_sp<SkImage> image = CreateImage(1, 24000); | 989 sk_sp<SkImage> image = CreateImage(1, 24000); |
979 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 990 DrawImage draw_image( |
980 quality, | 991 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
981 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 992 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
982 DefaultColorSpace()); | 993 DefaultColorSpace()); |
983 | 994 |
984 // Must hold context lock before calling GetDecodedImageForDraw / | 995 // Must hold context lock before calling GetDecodedImageForDraw / |
985 // DrawWithImageFinished. | 996 // DrawWithImageFinished. |
986 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 997 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
987 DecodedDrawImage decoded_draw_image = | 998 DecodedDrawImage decoded_draw_image = |
988 cache.GetDecodedImageForDraw(draw_image); | 999 cache.GetDecodedImageForDraw(draw_image); |
989 EXPECT_TRUE(decoded_draw_image.image()); | 1000 EXPECT_TRUE(decoded_draw_image.image()); |
990 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); | 1001 EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); |
991 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 1002 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
992 EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image)); | 1003 EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image)); |
(...skipping 13 matching lines...) Expand all Loading... |
1006 } | 1017 } |
1007 | 1018 |
1008 TEST(GpuImageDecodeCacheTest, ZeroSizedImagesAreSkipped) { | 1019 TEST(GpuImageDecodeCacheTest, ZeroSizedImagesAreSkipped) { |
1009 auto context_provider = TestContextProvider::Create(); | 1020 auto context_provider = TestContextProvider::Create(); |
1010 context_provider->BindToCurrentThread(); | 1021 context_provider->BindToCurrentThread(); |
1011 TestGpuImageDecodeCache cache(context_provider.get()); | 1022 TestGpuImageDecodeCache cache(context_provider.get()); |
1012 bool is_decomposable = true; | 1023 bool is_decomposable = true; |
1013 SkFilterQuality quality = kHigh_SkFilterQuality; | 1024 SkFilterQuality quality = kHigh_SkFilterQuality; |
1014 | 1025 |
1015 sk_sp<SkImage> image = CreateImage(100, 100); | 1026 sk_sp<SkImage> image = CreateImage(100, 100); |
1016 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1027 DrawImage draw_image( |
1017 quality, | 1028 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1018 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable), | 1029 quality, CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable), |
1019 DefaultColorSpace()); | 1030 DefaultColorSpace()); |
1020 | 1031 |
1021 scoped_refptr<TileTask> task; | 1032 scoped_refptr<TileTask> task; |
1022 bool need_unref = cache.GetTaskForImageAndRef( | 1033 bool need_unref = cache.GetTaskForImageAndRef( |
1023 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1034 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1024 EXPECT_FALSE(task); | 1035 EXPECT_FALSE(task); |
1025 EXPECT_FALSE(need_unref); | 1036 EXPECT_FALSE(need_unref); |
1026 | 1037 |
1027 // Must hold context lock before calling GetDecodedImageForDraw / | 1038 // Must hold context lock before calling GetDecodedImageForDraw / |
1028 // DrawWithImageFinished. | 1039 // DrawWithImageFinished. |
1029 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 1040 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
1030 DecodedDrawImage decoded_draw_image = | 1041 DecodedDrawImage decoded_draw_image = |
1031 cache.GetDecodedImageForDraw(draw_image); | 1042 cache.GetDecodedImageForDraw(draw_image); |
1032 EXPECT_FALSE(decoded_draw_image.image()); | 1043 EXPECT_FALSE(decoded_draw_image.image()); |
1033 | 1044 |
1034 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1045 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1035 } | 1046 } |
1036 | 1047 |
1037 TEST(GpuImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) { | 1048 TEST(GpuImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) { |
1038 auto context_provider = TestContextProvider::Create(); | 1049 auto context_provider = TestContextProvider::Create(); |
1039 context_provider->BindToCurrentThread(); | 1050 context_provider->BindToCurrentThread(); |
1040 TestGpuImageDecodeCache cache(context_provider.get()); | 1051 TestGpuImageDecodeCache cache(context_provider.get()); |
1041 bool is_decomposable = true; | 1052 bool is_decomposable = true; |
1042 SkFilterQuality quality = kHigh_SkFilterQuality; | 1053 SkFilterQuality quality = kHigh_SkFilterQuality; |
1043 | 1054 |
1044 sk_sp<SkImage> image = CreateImage(100, 100); | 1055 sk_sp<SkImage> image = CreateImage(100, 100); |
1045 DrawImage draw_image( | 1056 DrawImage draw_image( |
1046 image, SkIRect::MakeXYWH(150, 150, image->width(), image->height()), | 1057 PaintImage(image), |
1047 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 1058 SkIRect::MakeXYWH(150, 150, image->width(), image->height()), quality, |
| 1059 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
1048 DefaultColorSpace()); | 1060 DefaultColorSpace()); |
1049 | 1061 |
1050 scoped_refptr<TileTask> task; | 1062 scoped_refptr<TileTask> task; |
1051 bool need_unref = cache.GetTaskForImageAndRef( | 1063 bool need_unref = cache.GetTaskForImageAndRef( |
1052 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1064 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1053 EXPECT_FALSE(task); | 1065 EXPECT_FALSE(task); |
1054 EXPECT_FALSE(need_unref); | 1066 EXPECT_FALSE(need_unref); |
1055 | 1067 |
1056 // Must hold context lock before calling GetDecodedImageForDraw / | 1068 // Must hold context lock before calling GetDecodedImageForDraw / |
1057 // DrawWithImageFinished. | 1069 // DrawWithImageFinished. |
1058 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 1070 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
1059 DecodedDrawImage decoded_draw_image = | 1071 DecodedDrawImage decoded_draw_image = |
1060 cache.GetDecodedImageForDraw(draw_image); | 1072 cache.GetDecodedImageForDraw(draw_image); |
1061 EXPECT_FALSE(decoded_draw_image.image()); | 1073 EXPECT_FALSE(decoded_draw_image.image()); |
1062 | 1074 |
1063 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1075 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1064 } | 1076 } |
1065 | 1077 |
1066 TEST(GpuImageDecodeCacheTest, CanceledTasksDoNotCountAgainstBudget) { | 1078 TEST(GpuImageDecodeCacheTest, CanceledTasksDoNotCountAgainstBudget) { |
1067 auto context_provider = TestContextProvider::Create(); | 1079 auto context_provider = TestContextProvider::Create(); |
1068 context_provider->BindToCurrentThread(); | 1080 context_provider->BindToCurrentThread(); |
1069 TestGpuImageDecodeCache cache(context_provider.get()); | 1081 TestGpuImageDecodeCache cache(context_provider.get()); |
1070 bool is_decomposable = true; | 1082 bool is_decomposable = true; |
1071 SkFilterQuality quality = kHigh_SkFilterQuality; | 1083 SkFilterQuality quality = kHigh_SkFilterQuality; |
1072 | 1084 |
1073 sk_sp<SkImage> image = CreateImage(100, 100); | 1085 sk_sp<SkImage> image = CreateImage(100, 100); |
1074 DrawImage draw_image( | 1086 DrawImage draw_image(PaintImage(image), |
1075 image, SkIRect::MakeXYWH(0, 0, image->width(), image->height()), quality, | 1087 SkIRect::MakeXYWH(0, 0, image->width(), image->height()), |
1076 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 1088 quality, |
1077 DefaultColorSpace()); | 1089 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
| 1090 DefaultColorSpace()); |
1078 | 1091 |
1079 scoped_refptr<TileTask> task; | 1092 scoped_refptr<TileTask> task; |
1080 bool need_unref = cache.GetTaskForImageAndRef( | 1093 bool need_unref = cache.GetTaskForImageAndRef( |
1081 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1094 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1082 EXPECT_NE(0u, cache.GetBytesUsedForTesting()); | 1095 EXPECT_NE(0u, cache.GetBytesUsedForTesting()); |
1083 EXPECT_TRUE(task); | 1096 EXPECT_TRUE(task); |
1084 EXPECT_TRUE(need_unref); | 1097 EXPECT_TRUE(need_unref); |
1085 | 1098 |
1086 TestTileTaskRunner::CancelTask(task->dependencies()[0].get()); | 1099 TestTileTaskRunner::CancelTask(task->dependencies()[0].get()); |
1087 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); | 1100 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); |
1088 TestTileTaskRunner::CancelTask(task.get()); | 1101 TestTileTaskRunner::CancelTask(task.get()); |
1089 TestTileTaskRunner::CompleteTask(task.get()); | 1102 TestTileTaskRunner::CompleteTask(task.get()); |
1090 | 1103 |
1091 cache.UnrefImage(draw_image); | 1104 cache.UnrefImage(draw_image); |
1092 EXPECT_EQ(0u, cache.GetBytesUsedForTesting()); | 1105 EXPECT_EQ(0u, cache.GetBytesUsedForTesting()); |
1093 } | 1106 } |
1094 | 1107 |
1095 TEST(GpuImageDecodeCacheTest, ShouldAggressivelyFreeResources) { | 1108 TEST(GpuImageDecodeCacheTest, ShouldAggressivelyFreeResources) { |
1096 auto context_provider = TestContextProvider::Create(); | 1109 auto context_provider = TestContextProvider::Create(); |
1097 context_provider->BindToCurrentThread(); | 1110 context_provider->BindToCurrentThread(); |
1098 TestGpuImageDecodeCache cache(context_provider.get()); | 1111 TestGpuImageDecodeCache cache(context_provider.get()); |
1099 bool is_decomposable = true; | 1112 bool is_decomposable = true; |
1100 SkFilterQuality quality = kHigh_SkFilterQuality; | 1113 SkFilterQuality quality = kHigh_SkFilterQuality; |
1101 | 1114 |
1102 sk_sp<SkImage> image = CreateImage(100, 100); | 1115 sk_sp<SkImage> image = CreateImage(100, 100); |
1103 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1116 DrawImage draw_image( |
1104 quality, | 1117 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1105 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1118 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1106 DefaultColorSpace()); | 1119 DefaultColorSpace()); |
1107 scoped_refptr<TileTask> task; | 1120 scoped_refptr<TileTask> task; |
1108 { | 1121 { |
1109 bool need_unref = cache.GetTaskForImageAndRef( | 1122 bool need_unref = cache.GetTaskForImageAndRef( |
1110 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1123 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1111 EXPECT_TRUE(need_unref); | 1124 EXPECT_TRUE(need_unref); |
1112 EXPECT_TRUE(task); | 1125 EXPECT_TRUE(task); |
1113 } | 1126 } |
1114 | 1127 |
1115 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 1128 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
1116 TestTileTaskRunner::ProcessTask(task.get()); | 1129 TestTileTaskRunner::ProcessTask(task.get()); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1159 TEST(GpuImageDecodeCacheTest, OrphanedImagesFreeOnReachingZeroRefs) { | 1172 TEST(GpuImageDecodeCacheTest, OrphanedImagesFreeOnReachingZeroRefs) { |
1160 auto context_provider = TestContextProvider::Create(); | 1173 auto context_provider = TestContextProvider::Create(); |
1161 context_provider->BindToCurrentThread(); | 1174 context_provider->BindToCurrentThread(); |
1162 TestGpuImageDecodeCache cache(context_provider.get()); | 1175 TestGpuImageDecodeCache cache(context_provider.get()); |
1163 bool is_decomposable = true; | 1176 bool is_decomposable = true; |
1164 SkFilterQuality quality = kHigh_SkFilterQuality; | 1177 SkFilterQuality quality = kHigh_SkFilterQuality; |
1165 | 1178 |
1166 // Create a downscaled image. | 1179 // Create a downscaled image. |
1167 sk_sp<SkImage> first_image = CreateImage(100, 100); | 1180 sk_sp<SkImage> first_image = CreateImage(100, 100); |
1168 DrawImage first_draw_image( | 1181 DrawImage first_draw_image( |
1169 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1182 PaintImage(first_image), |
1170 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1183 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 1184 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1171 DefaultColorSpace()); | 1185 DefaultColorSpace()); |
1172 scoped_refptr<TileTask> first_task; | 1186 scoped_refptr<TileTask> first_task; |
1173 bool need_unref = cache.GetTaskForImageAndRef( | 1187 bool need_unref = cache.GetTaskForImageAndRef( |
1174 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 1188 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
1175 EXPECT_TRUE(need_unref); | 1189 EXPECT_TRUE(need_unref); |
1176 EXPECT_TRUE(first_task); | 1190 EXPECT_TRUE(first_task); |
1177 | 1191 |
1178 // The budget should account for exactly one image. | 1192 // The budget should account for exactly one image. |
1179 EXPECT_EQ(cache.GetBytesUsedForTesting(), | 1193 EXPECT_EQ(cache.GetBytesUsedForTesting(), |
1180 cache.GetDrawImageSizeForTesting(first_draw_image)); | 1194 cache.GetDrawImageSizeForTesting(first_draw_image)); |
1181 | 1195 |
1182 // Create a larger version of |first_image|, this should immediately free the | 1196 // Create a larger version of |first_image|, this should immediately free the |
1183 // memory used by |first_image| for the smaller scale. | 1197 // memory used by |first_image| for the smaller scale. |
1184 DrawImage second_draw_image( | 1198 DrawImage second_draw_image( |
1185 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1199 PaintImage(first_image), |
1186 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1200 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 1201 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1187 DefaultColorSpace()); | 1202 DefaultColorSpace()); |
1188 scoped_refptr<TileTask> second_task; | 1203 scoped_refptr<TileTask> second_task; |
1189 need_unref = cache.GetTaskForImageAndRef( | 1204 need_unref = cache.GetTaskForImageAndRef( |
1190 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 1205 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
1191 EXPECT_TRUE(need_unref); | 1206 EXPECT_TRUE(need_unref); |
1192 EXPECT_TRUE(second_task); | 1207 EXPECT_TRUE(second_task); |
1193 EXPECT_TRUE(first_task.get() != second_task.get()); | 1208 EXPECT_TRUE(first_task.get() != second_task.get()); |
1194 | 1209 |
1195 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 1210 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
1196 TestTileTaskRunner::ProcessTask(second_task.get()); | 1211 TestTileTaskRunner::ProcessTask(second_task.get()); |
(...skipping 19 matching lines...) Expand all Loading... |
1216 TEST(GpuImageDecodeCacheTest, OrphanedZeroRefImagesImmediatelyDeleted) { | 1231 TEST(GpuImageDecodeCacheTest, OrphanedZeroRefImagesImmediatelyDeleted) { |
1217 auto context_provider = TestContextProvider::Create(); | 1232 auto context_provider = TestContextProvider::Create(); |
1218 context_provider->BindToCurrentThread(); | 1233 context_provider->BindToCurrentThread(); |
1219 TestGpuImageDecodeCache cache(context_provider.get()); | 1234 TestGpuImageDecodeCache cache(context_provider.get()); |
1220 bool is_decomposable = true; | 1235 bool is_decomposable = true; |
1221 SkFilterQuality quality = kHigh_SkFilterQuality; | 1236 SkFilterQuality quality = kHigh_SkFilterQuality; |
1222 | 1237 |
1223 // Create a downscaled image. | 1238 // Create a downscaled image. |
1224 sk_sp<SkImage> first_image = CreateImage(100, 100); | 1239 sk_sp<SkImage> first_image = CreateImage(100, 100); |
1225 DrawImage first_draw_image( | 1240 DrawImage first_draw_image( |
1226 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1241 PaintImage(first_image), |
1227 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1242 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 1243 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1228 DefaultColorSpace()); | 1244 DefaultColorSpace()); |
1229 scoped_refptr<TileTask> first_task; | 1245 scoped_refptr<TileTask> first_task; |
1230 bool need_unref = cache.GetTaskForImageAndRef( | 1246 bool need_unref = cache.GetTaskForImageAndRef( |
1231 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 1247 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
1232 EXPECT_TRUE(need_unref); | 1248 EXPECT_TRUE(need_unref); |
1233 EXPECT_TRUE(first_task); | 1249 EXPECT_TRUE(first_task); |
1234 | 1250 |
1235 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | 1251 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
1236 TestTileTaskRunner::ProcessTask(first_task.get()); | 1252 TestTileTaskRunner::ProcessTask(first_task.get()); |
1237 cache.UnrefImage(first_draw_image); | 1253 cache.UnrefImage(first_draw_image); |
1238 | 1254 |
1239 // The budget should account for exactly one image. | 1255 // The budget should account for exactly one image. |
1240 EXPECT_EQ(cache.GetBytesUsedForTesting(), | 1256 EXPECT_EQ(cache.GetBytesUsedForTesting(), |
1241 cache.GetDrawImageSizeForTesting(first_draw_image)); | 1257 cache.GetDrawImageSizeForTesting(first_draw_image)); |
1242 | 1258 |
1243 // Create a larger version of |first_image|, this should immediately free the | 1259 // Create a larger version of |first_image|, this should immediately free the |
1244 // memory used by |first_image| for the smaller scale. | 1260 // memory used by |first_image| for the smaller scale. |
1245 DrawImage second_draw_image( | 1261 DrawImage second_draw_image( |
1246 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1262 PaintImage(first_image), |
1247 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1263 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 1264 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1248 DefaultColorSpace()); | 1265 DefaultColorSpace()); |
1249 scoped_refptr<TileTask> second_task; | 1266 scoped_refptr<TileTask> second_task; |
1250 need_unref = cache.GetTaskForImageAndRef( | 1267 need_unref = cache.GetTaskForImageAndRef( |
1251 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 1268 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
1252 EXPECT_TRUE(need_unref); | 1269 EXPECT_TRUE(need_unref); |
1253 EXPECT_TRUE(second_task); | 1270 EXPECT_TRUE(second_task); |
1254 EXPECT_TRUE(first_task.get() != second_task.get()); | 1271 EXPECT_TRUE(first_task.get() != second_task.get()); |
1255 | 1272 |
1256 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 1273 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
1257 TestTileTaskRunner::ProcessTask(second_task.get()); | 1274 TestTileTaskRunner::ProcessTask(second_task.get()); |
1258 | 1275 |
1259 cache.UnrefImage(second_draw_image); | 1276 cache.UnrefImage(second_draw_image); |
1260 | 1277 |
1261 // The budget should account for exactly one image. | 1278 // The budget should account for exactly one image. |
1262 EXPECT_EQ(cache.GetBytesUsedForTesting(), | 1279 EXPECT_EQ(cache.GetBytesUsedForTesting(), |
1263 cache.GetDrawImageSizeForTesting(second_draw_image)); | 1280 cache.GetDrawImageSizeForTesting(second_draw_image)); |
1264 } | 1281 } |
1265 | 1282 |
1266 TEST(GpuImageDecodeCacheTest, QualityCappedAtMedium) { | 1283 TEST(GpuImageDecodeCacheTest, QualityCappedAtMedium) { |
1267 auto context_provider = TestContextProvider::Create(); | 1284 auto context_provider = TestContextProvider::Create(); |
1268 context_provider->BindToCurrentThread(); | 1285 context_provider->BindToCurrentThread(); |
1269 TestGpuImageDecodeCache cache(context_provider.get()); | 1286 TestGpuImageDecodeCache cache(context_provider.get()); |
1270 sk_sp<SkImage> image = CreateImage(100, 100); | 1287 sk_sp<SkImage> image = CreateImage(100, 100); |
1271 bool is_decomposable = true; | 1288 bool is_decomposable = true; |
1272 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); | 1289 SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); |
1273 | 1290 |
1274 // Create an image with kLow_FilterQuality. | 1291 // Create an image with kLow_FilterQuality. |
1275 DrawImage low_draw_image(image, | 1292 DrawImage low_draw_image(PaintImage(image), |
1276 SkIRect::MakeWH(image->width(), image->height()), | 1293 SkIRect::MakeWH(image->width(), image->height()), |
1277 kLow_SkFilterQuality, matrix, DefaultColorSpace()); | 1294 kLow_SkFilterQuality, matrix, DefaultColorSpace()); |
1278 scoped_refptr<TileTask> low_task; | 1295 scoped_refptr<TileTask> low_task; |
1279 bool need_unref = cache.GetTaskForImageAndRef( | 1296 bool need_unref = cache.GetTaskForImageAndRef( |
1280 low_draw_image, ImageDecodeCache::TracingInfo(), &low_task); | 1297 low_draw_image, ImageDecodeCache::TracingInfo(), &low_task); |
1281 EXPECT_TRUE(need_unref); | 1298 EXPECT_TRUE(need_unref); |
1282 EXPECT_TRUE(low_task); | 1299 EXPECT_TRUE(low_task); |
1283 | 1300 |
1284 // Get the same image at kMedium_FilterQuality. We can't re-use low, so we | 1301 // Get the same image at kMedium_FilterQuality. We can't re-use low, so we |
1285 // should get a new task/ref. | 1302 // should get a new task/ref. |
1286 DrawImage medium_draw_image( | 1303 DrawImage medium_draw_image( |
1287 image, SkIRect::MakeWH(image->width(), image->height()), | 1304 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1288 kMedium_SkFilterQuality, matrix, DefaultColorSpace()); | 1305 kMedium_SkFilterQuality, matrix, DefaultColorSpace()); |
1289 scoped_refptr<TileTask> medium_task; | 1306 scoped_refptr<TileTask> medium_task; |
1290 need_unref = cache.GetTaskForImageAndRef( | 1307 need_unref = cache.GetTaskForImageAndRef( |
1291 medium_draw_image, ImageDecodeCache::TracingInfo(), &medium_task); | 1308 medium_draw_image, ImageDecodeCache::TracingInfo(), &medium_task); |
1292 EXPECT_TRUE(need_unref); | 1309 EXPECT_TRUE(need_unref); |
1293 EXPECT_TRUE(medium_task.get()); | 1310 EXPECT_TRUE(medium_task.get()); |
1294 EXPECT_FALSE(low_task.get() == medium_task.get()); | 1311 EXPECT_FALSE(low_task.get() == medium_task.get()); |
1295 | 1312 |
1296 // Get the same image at kHigh_FilterQuality. We should re-use medium. | 1313 // Get the same image at kHigh_FilterQuality. We should re-use medium. |
1297 DrawImage large_draw_image( | 1314 DrawImage large_draw_image( |
1298 image, SkIRect::MakeWH(image->width(), image->height()), | 1315 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1299 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); | 1316 kHigh_SkFilterQuality, matrix, DefaultColorSpace()); |
1300 scoped_refptr<TileTask> large_task; | 1317 scoped_refptr<TileTask> large_task; |
1301 need_unref = cache.GetTaskForImageAndRef( | 1318 need_unref = cache.GetTaskForImageAndRef( |
1302 large_draw_image, ImageDecodeCache::TracingInfo(), &large_task); | 1319 large_draw_image, ImageDecodeCache::TracingInfo(), &large_task); |
1303 EXPECT_TRUE(need_unref); | 1320 EXPECT_TRUE(need_unref); |
1304 EXPECT_TRUE(medium_task.get() == large_task.get()); | 1321 EXPECT_TRUE(medium_task.get() == large_task.get()); |
1305 | 1322 |
1306 TestTileTaskRunner::ProcessTask(low_task->dependencies()[0].get()); | 1323 TestTileTaskRunner::ProcessTask(low_task->dependencies()[0].get()); |
1307 TestTileTaskRunner::ProcessTask(low_task.get()); | 1324 TestTileTaskRunner::ProcessTask(low_task.get()); |
1308 TestTileTaskRunner::ProcessTask(medium_task->dependencies()[0].get()); | 1325 TestTileTaskRunner::ProcessTask(medium_task->dependencies()[0].get()); |
1309 TestTileTaskRunner::ProcessTask(medium_task.get()); | 1326 TestTileTaskRunner::ProcessTask(medium_task.get()); |
1310 | 1327 |
1311 cache.UnrefImage(low_draw_image); | 1328 cache.UnrefImage(low_draw_image); |
1312 cache.UnrefImage(medium_draw_image); | 1329 cache.UnrefImage(medium_draw_image); |
1313 cache.UnrefImage(large_draw_image); | 1330 cache.UnrefImage(large_draw_image); |
1314 } | 1331 } |
1315 | 1332 |
1316 // Ensure that switching to a mipped version of an image after the initial | 1333 // Ensure that switching to a mipped version of an image after the initial |
1317 // cache entry creation doesn't cause a buffer overflow/crash. | 1334 // cache entry creation doesn't cause a buffer overflow/crash. |
1318 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawMipUsageChange) { | 1335 TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawMipUsageChange) { |
1319 auto context_provider = TestContextProvider::Create(); | 1336 auto context_provider = TestContextProvider::Create(); |
1320 context_provider->BindToCurrentThread(); | 1337 context_provider->BindToCurrentThread(); |
1321 TestGpuImageDecodeCache cache(context_provider.get()); | 1338 TestGpuImageDecodeCache cache(context_provider.get()); |
1322 bool is_decomposable = true; | 1339 bool is_decomposable = true; |
1323 SkFilterQuality quality = kHigh_SkFilterQuality; | 1340 SkFilterQuality quality = kHigh_SkFilterQuality; |
1324 | 1341 |
1325 // Create an image decode task and cache entry that does not need mips. | 1342 // Create an image decode task and cache entry that does not need mips. |
1326 sk_sp<SkImage> image = CreateImage(4000, 4000); | 1343 sk_sp<SkImage> image = CreateImage(4000, 4000); |
1327 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1344 DrawImage draw_image( |
1328 quality, | 1345 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1329 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1346 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1330 DefaultColorSpace()); | 1347 DefaultColorSpace()); |
1331 scoped_refptr<TileTask> task; | 1348 scoped_refptr<TileTask> task; |
1332 bool need_unref = cache.GetTaskForImageAndRef( | 1349 bool need_unref = cache.GetTaskForImageAndRef( |
1333 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1350 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1334 EXPECT_TRUE(need_unref); | 1351 EXPECT_TRUE(need_unref); |
1335 EXPECT_TRUE(task); | 1352 EXPECT_TRUE(task); |
1336 | 1353 |
1337 // Cancel the task without ever using it. | 1354 // Cancel the task without ever using it. |
1338 TestTileTaskRunner::CancelTask(task->dependencies()[0].get()); | 1355 TestTileTaskRunner::CancelTask(task->dependencies()[0].get()); |
1339 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); | 1356 TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); |
1340 TestTileTaskRunner::CancelTask(task.get()); | 1357 TestTileTaskRunner::CancelTask(task.get()); |
1341 TestTileTaskRunner::CompleteTask(task.get()); | 1358 TestTileTaskRunner::CompleteTask(task.get()); |
1342 | 1359 |
1343 cache.UnrefImage(draw_image); | 1360 cache.UnrefImage(draw_image); |
1344 | 1361 |
1345 // Must hold context lock before calling GetDecodedImageForDraw / | 1362 // Must hold context lock before calling GetDecodedImageForDraw / |
1346 // DrawWithImageFinished. | 1363 // DrawWithImageFinished. |
1347 ContextProvider::ScopedContextLock context_lock(context_provider.get()); | 1364 ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
1348 | 1365 |
1349 // Do an at-raster decode of the above image that *does* require mips. | 1366 // Do an at-raster decode of the above image that *does* require mips. |
1350 DrawImage draw_image_mips( | 1367 DrawImage draw_image_mips( |
1351 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1368 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1352 CreateMatrix(SkSize::Make(0.6f, 0.6f), is_decomposable), | 1369 quality, CreateMatrix(SkSize::Make(0.6f, 0.6f), is_decomposable), |
1353 DefaultColorSpace()); | 1370 DefaultColorSpace()); |
1354 DecodedDrawImage decoded_draw_image = | 1371 DecodedDrawImage decoded_draw_image = |
1355 cache.GetDecodedImageForDraw(draw_image_mips); | 1372 cache.GetDecodedImageForDraw(draw_image_mips); |
1356 cache.DrawWithImageFinished(draw_image_mips, decoded_draw_image); | 1373 cache.DrawWithImageFinished(draw_image_mips, decoded_draw_image); |
1357 } | 1374 } |
1358 | 1375 |
1359 TEST(GpuImageDecodeCacheTest, MemoryStateSuspended) { | 1376 TEST(GpuImageDecodeCacheTest, MemoryStateSuspended) { |
1360 auto context_provider = TestContextProvider::Create(); | 1377 auto context_provider = TestContextProvider::Create(); |
1361 context_provider->BindToCurrentThread(); | 1378 context_provider->BindToCurrentThread(); |
1362 TestGpuImageDecodeCache cache(context_provider.get()); | 1379 TestGpuImageDecodeCache cache(context_provider.get()); |
1363 | 1380 |
1364 // First Insert an image into our cache. | 1381 // First Insert an image into our cache. |
1365 sk_sp<SkImage> image = CreateImage(1, 1); | 1382 sk_sp<SkImage> image = CreateImage(1, 1); |
1366 bool is_decomposable = true; | 1383 bool is_decomposable = true; |
1367 SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable); | 1384 SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable); |
1368 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1385 DrawImage draw_image(PaintImage(image), |
| 1386 SkIRect::MakeWH(image->width(), image->height()), |
1369 kLow_SkFilterQuality, matrix, DefaultColorSpace()); | 1387 kLow_SkFilterQuality, matrix, DefaultColorSpace()); |
1370 scoped_refptr<TileTask> task; | 1388 scoped_refptr<TileTask> task; |
1371 bool need_unref = cache.GetTaskForImageAndRef( | 1389 bool need_unref = cache.GetTaskForImageAndRef( |
1372 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1390 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1373 EXPECT_TRUE(need_unref); | 1391 EXPECT_TRUE(need_unref); |
1374 EXPECT_TRUE(task); | 1392 EXPECT_TRUE(task); |
1375 | 1393 |
1376 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 1394 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
1377 TestTileTaskRunner::ProcessTask(task.get()); | 1395 TestTileTaskRunner::ProcessTask(task.get()); |
1378 cache.UnrefImage(draw_image); | 1396 cache.UnrefImage(draw_image); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1427 } | 1445 } |
1428 | 1446 |
1429 TEST(GpuImageDecodeCacheTest, OutOfRasterDecodeTask) { | 1447 TEST(GpuImageDecodeCacheTest, OutOfRasterDecodeTask) { |
1430 auto context_provider = TestContextProvider::Create(); | 1448 auto context_provider = TestContextProvider::Create(); |
1431 context_provider->BindToCurrentThread(); | 1449 context_provider->BindToCurrentThread(); |
1432 TestGpuImageDecodeCache cache(context_provider.get()); | 1450 TestGpuImageDecodeCache cache(context_provider.get()); |
1433 | 1451 |
1434 sk_sp<SkImage> image = CreateImage(1, 1); | 1452 sk_sp<SkImage> image = CreateImage(1, 1); |
1435 bool is_decomposable = true; | 1453 bool is_decomposable = true; |
1436 SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable); | 1454 SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable); |
1437 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1455 DrawImage draw_image(PaintImage(image), |
| 1456 SkIRect::MakeWH(image->width(), image->height()), |
1438 kLow_SkFilterQuality, matrix, DefaultColorSpace()); | 1457 kLow_SkFilterQuality, matrix, DefaultColorSpace()); |
1439 | 1458 |
1440 scoped_refptr<TileTask> task; | 1459 scoped_refptr<TileTask> task; |
1441 bool need_unref = | 1460 bool need_unref = |
1442 cache.GetOutOfRasterDecodeTaskForImageAndRef(draw_image, &task); | 1461 cache.GetOutOfRasterDecodeTaskForImageAndRef(draw_image, &task); |
1443 EXPECT_TRUE(need_unref); | 1462 EXPECT_TRUE(need_unref); |
1444 EXPECT_TRUE(task); | 1463 EXPECT_TRUE(task); |
1445 EXPECT_TRUE(cache.IsInInUseCacheForTesting(draw_image)); | 1464 EXPECT_TRUE(cache.IsInInUseCacheForTesting(draw_image)); |
1446 | 1465 |
1447 // Run the decode task. | 1466 // Run the decode task. |
1448 TestTileTaskRunner::ProcessTask(task.get()); | 1467 TestTileTaskRunner::ProcessTask(task.get()); |
1449 | 1468 |
1450 // The image should remain in the cache till we unref it. | 1469 // The image should remain in the cache till we unref it. |
1451 EXPECT_TRUE(cache.IsInInUseCacheForTesting(draw_image)); | 1470 EXPECT_TRUE(cache.IsInInUseCacheForTesting(draw_image)); |
1452 cache.UnrefImage(draw_image); | 1471 cache.UnrefImage(draw_image); |
1453 } | 1472 } |
1454 | 1473 |
1455 TEST(GpuImageDecodeCacheTest, ZeroCacheNormalWorkingSet) { | 1474 TEST(GpuImageDecodeCacheTest, ZeroCacheNormalWorkingSet) { |
1456 // Setup - Image cache has a normal working set, but zero cache size. | 1475 // Setup - Image cache has a normal working set, but zero cache size. |
1457 auto context_provider = TestContextProvider::Create(); | 1476 auto context_provider = TestContextProvider::Create(); |
1458 context_provider->BindToCurrentThread(); | 1477 context_provider->BindToCurrentThread(); |
1459 GpuImageDecodeCache cache(context_provider.get(), ResourceFormat::RGBA_8888, | 1478 GpuImageDecodeCache cache(context_provider.get(), ResourceFormat::RGBA_8888, |
1460 kGpuMemoryLimitBytes, 0); | 1479 kGpuMemoryLimitBytes, 0); |
1461 bool is_decomposable = true; | 1480 bool is_decomposable = true; |
1462 SkFilterQuality quality = kHigh_SkFilterQuality; | 1481 SkFilterQuality quality = kHigh_SkFilterQuality; |
1463 | 1482 |
1464 // Add an image to the cache. Due to normal working set, this should produce | 1483 // Add an image to the cache. Due to normal working set, this should produce |
1465 // a task and a ref. | 1484 // a task and a ref. |
1466 sk_sp<SkImage> image = CreateImage(100, 100); | 1485 sk_sp<SkImage> image = CreateImage(100, 100); |
1467 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1486 DrawImage draw_image( |
1468 quality, | 1487 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1469 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1488 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1470 DefaultColorSpace()); | 1489 DefaultColorSpace()); |
1471 scoped_refptr<TileTask> task; | 1490 scoped_refptr<TileTask> task; |
1472 bool need_unref = cache.GetTaskForImageAndRef( | 1491 bool need_unref = cache.GetTaskForImageAndRef( |
1473 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1492 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1474 EXPECT_TRUE(need_unref); | 1493 EXPECT_TRUE(need_unref); |
1475 EXPECT_TRUE(task); | 1494 EXPECT_TRUE(task); |
1476 EXPECT_EQ(task->dependencies().size(), 1u); | 1495 EXPECT_EQ(task->dependencies().size(), 1u); |
1477 EXPECT_TRUE(task->dependencies()[0]); | 1496 EXPECT_TRUE(task->dependencies()[0]); |
1478 | 1497 |
1479 // Run the task. | 1498 // Run the task. |
1480 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 1499 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1512 size_t cache_size = 190 * 100 * 4; | 1531 size_t cache_size = 190 * 100 * 4; |
1513 | 1532 |
1514 auto context_provider = TestContextProvider::Create(); | 1533 auto context_provider = TestContextProvider::Create(); |
1515 context_provider->BindToCurrentThread(); | 1534 context_provider->BindToCurrentThread(); |
1516 GpuImageDecodeCache cache(context_provider.get(), ResourceFormat::RGBA_8888, | 1535 GpuImageDecodeCache cache(context_provider.get(), ResourceFormat::RGBA_8888, |
1517 kGpuMemoryLimitBytes, cache_size); | 1536 kGpuMemoryLimitBytes, cache_size); |
1518 bool is_decomposable = true; | 1537 bool is_decomposable = true; |
1519 SkFilterQuality quality = kHigh_SkFilterQuality; | 1538 SkFilterQuality quality = kHigh_SkFilterQuality; |
1520 | 1539 |
1521 sk_sp<SkImage> image = CreateImage(100, 100); | 1540 sk_sp<SkImage> image = CreateImage(100, 100); |
1522 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1541 DrawImage draw_image( |
1523 quality, | 1542 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1524 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1543 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1525 DefaultColorSpace()); | 1544 DefaultColorSpace()); |
1526 | 1545 |
1527 sk_sp<SkImage> image2 = CreateImage(100, 100); | 1546 sk_sp<SkImage> image2 = CreateImage(100, 100); |
1528 DrawImage draw_image2( | 1547 DrawImage draw_image2( |
1529 image2, SkIRect::MakeWH(image2->width(), image2->height()), quality, | 1548 PaintImage(image2), SkIRect::MakeWH(image2->width(), image2->height()), |
1530 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1549 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1531 DefaultColorSpace()); | 1550 DefaultColorSpace()); |
1532 | 1551 |
1533 // Add an image to the cache and un-ref it. | 1552 // Add an image to the cache and un-ref it. |
1534 { | 1553 { |
1535 scoped_refptr<TileTask> task; | 1554 scoped_refptr<TileTask> task; |
1536 bool need_unref = cache.GetTaskForImageAndRef( | 1555 bool need_unref = cache.GetTaskForImageAndRef( |
1537 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1556 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1538 EXPECT_TRUE(need_unref); | 1557 EXPECT_TRUE(need_unref); |
1539 EXPECT_TRUE(task); | 1558 EXPECT_TRUE(task); |
1540 EXPECT_EQ(task->dependencies().size(), 1u); | 1559 EXPECT_EQ(task->dependencies().size(), 1u); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1603 TEST(GpuImageDecodeCacheTest, ClearCache) { | 1622 TEST(GpuImageDecodeCacheTest, ClearCache) { |
1604 auto context_provider = TestContextProvider::Create(); | 1623 auto context_provider = TestContextProvider::Create(); |
1605 context_provider->BindToCurrentThread(); | 1624 context_provider->BindToCurrentThread(); |
1606 TestGpuImageDecodeCache cache(context_provider.get()); | 1625 TestGpuImageDecodeCache cache(context_provider.get()); |
1607 bool is_decomposable = true; | 1626 bool is_decomposable = true; |
1608 SkFilterQuality quality = kHigh_SkFilterQuality; | 1627 SkFilterQuality quality = kHigh_SkFilterQuality; |
1609 | 1628 |
1610 for (int i = 0; i < 10; ++i) { | 1629 for (int i = 0; i < 10; ++i) { |
1611 sk_sp<SkImage> image = CreateImage(100, 100); | 1630 sk_sp<SkImage> image = CreateImage(100, 100); |
1612 DrawImage draw_image( | 1631 DrawImage draw_image( |
1613 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1632 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1614 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1633 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1615 DefaultColorSpace()); | 1634 DefaultColorSpace()); |
1616 scoped_refptr<TileTask> task; | 1635 scoped_refptr<TileTask> task; |
1617 bool need_unref = cache.GetTaskForImageAndRef( | 1636 bool need_unref = cache.GetTaskForImageAndRef( |
1618 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1637 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1619 EXPECT_TRUE(need_unref); | 1638 EXPECT_TRUE(need_unref); |
1620 EXPECT_TRUE(task); | 1639 EXPECT_TRUE(task); |
1621 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); | 1640 TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
1622 TestTileTaskRunner::ProcessTask(task.get()); | 1641 TestTileTaskRunner::ProcessTask(task.get()); |
1623 cache.UnrefImage(draw_image); | 1642 cache.UnrefImage(draw_image); |
1624 } | 1643 } |
(...skipping 15 matching lines...) Expand all Loading... |
1640 context_provider->BindToCurrentThread(); | 1659 context_provider->BindToCurrentThread(); |
1641 TestGpuImageDecodeCache cache(context_provider.get()); | 1660 TestGpuImageDecodeCache cache(context_provider.get()); |
1642 bool is_decomposable = true; | 1661 bool is_decomposable = true; |
1643 SkFilterQuality quality = kHigh_SkFilterQuality; | 1662 SkFilterQuality quality = kHigh_SkFilterQuality; |
1644 | 1663 |
1645 gfx::ColorSpace color_space_a = gfx::ColorSpace::CreateSRGB(); | 1664 gfx::ColorSpace color_space_a = gfx::ColorSpace::CreateSRGB(); |
1646 gfx::ColorSpace color_space_b = gfx::ColorSpace::CreateXYZD50(); | 1665 gfx::ColorSpace color_space_b = gfx::ColorSpace::CreateXYZD50(); |
1647 | 1666 |
1648 sk_sp<SkImage> first_image = CreateImage(100, 100); | 1667 sk_sp<SkImage> first_image = CreateImage(100, 100); |
1649 DrawImage first_draw_image( | 1668 DrawImage first_draw_image( |
1650 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1669 PaintImage(first_image), |
1651 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1670 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
1652 color_space_a); | 1671 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), color_space_a); |
1653 scoped_refptr<TileTask> first_task; | 1672 scoped_refptr<TileTask> first_task; |
1654 bool need_unref = cache.GetTaskForImageAndRef( | 1673 bool need_unref = cache.GetTaskForImageAndRef( |
1655 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 1674 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
1656 EXPECT_TRUE(need_unref); | 1675 EXPECT_TRUE(need_unref); |
1657 EXPECT_TRUE(first_task); | 1676 EXPECT_TRUE(first_task); |
1658 | 1677 |
1659 DrawImage second_draw_image( | 1678 DrawImage second_draw_image( |
1660 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1679 PaintImage(first_image), |
1661 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1680 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
1662 color_space_b); | 1681 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), color_space_b); |
1663 scoped_refptr<TileTask> second_task; | 1682 scoped_refptr<TileTask> second_task; |
1664 need_unref = cache.GetTaskForImageAndRef( | 1683 need_unref = cache.GetTaskForImageAndRef( |
1665 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 1684 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
1666 EXPECT_TRUE(need_unref); | 1685 EXPECT_TRUE(need_unref); |
1667 EXPECT_TRUE(second_task); | 1686 EXPECT_TRUE(second_task); |
1668 EXPECT_TRUE(first_task.get() != second_task.get()); | 1687 EXPECT_TRUE(first_task.get() != second_task.get()); |
1669 | 1688 |
1670 DrawImage third_draw_image( | 1689 DrawImage third_draw_image( |
1671 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 1690 PaintImage(first_image), |
1672 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1691 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
1673 color_space_a); | 1692 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), color_space_a); |
1674 scoped_refptr<TileTask> third_task; | 1693 scoped_refptr<TileTask> third_task; |
1675 need_unref = cache.GetTaskForImageAndRef( | 1694 need_unref = cache.GetTaskForImageAndRef( |
1676 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); | 1695 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
1677 EXPECT_TRUE(need_unref); | 1696 EXPECT_TRUE(need_unref); |
1678 EXPECT_TRUE(third_task.get() == first_task.get()); | 1697 EXPECT_TRUE(third_task.get() == first_task.get()); |
1679 | 1698 |
1680 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); | 1699 TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
1681 TestTileTaskRunner::ProcessTask(first_task.get()); | 1700 TestTileTaskRunner::ProcessTask(first_task.get()); |
1682 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); | 1701 TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
1683 TestTileTaskRunner::ProcessTask(second_task.get()); | 1702 TestTileTaskRunner::ProcessTask(second_task.get()); |
1684 | 1703 |
1685 cache.UnrefImage(first_draw_image); | 1704 cache.UnrefImage(first_draw_image); |
1686 cache.UnrefImage(second_draw_image); | 1705 cache.UnrefImage(second_draw_image); |
1687 cache.UnrefImage(third_draw_image); | 1706 cache.UnrefImage(third_draw_image); |
1688 } | 1707 } |
1689 | 1708 |
1690 } // namespace | 1709 } // namespace |
1691 } // namespace cc | 1710 } // namespace cc |
OLD | NEW |