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