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