OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/software_image_decode_cache.h" | 5 #include "cc/tiles/software_image_decode_cache.h" |
6 | 6 |
7 #include "cc/paint/draw_image.h" | 7 #include "cc/paint/draw_image.h" |
8 #include "cc/resources/resource_format.h" | 8 #include "cc/resources/resource_format.h" |
9 #include "cc/test/test_tile_task_runner.h" | 9 #include "cc/test/test_tile_task_runner.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
49 | 49 |
50 return matrix; | 50 return matrix; |
51 } | 51 } |
52 | 52 |
53 TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQuality) { | 53 TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQuality) { |
54 sk_sp<SkImage> image = CreateImage(100, 100); | 54 sk_sp<SkImage> image = CreateImage(100, 100); |
55 bool is_decomposable = true; | 55 bool is_decomposable = true; |
56 SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality}; | 56 SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality}; |
57 for (auto quality : qualities) { | 57 for (auto quality : qualities) { |
58 DrawImage draw_image( | 58 DrawImage draw_image( |
59 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 59 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
60 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | 60 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
61 DefaultColorSpace()); | 61 DefaultColorSpace()); |
62 | 62 |
63 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 63 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
64 EXPECT_EQ(image->uniqueID(), key.image_id()); | 64 EXPECT_EQ(image->uniqueID(), key.image_id()); |
65 EXPECT_EQ(quality, key.filter_quality()); | 65 EXPECT_EQ(quality, key.filter_quality()); |
66 EXPECT_EQ(100, key.target_size().width()); | 66 EXPECT_EQ(100, key.target_size().width()); |
67 EXPECT_EQ(100, key.target_size().height()); | 67 EXPECT_EQ(100, key.target_size().height()); |
68 EXPECT_TRUE(key.can_use_original_size_decode()); | 68 EXPECT_TRUE(key.can_use_original_size_decode()); |
69 // Since the original decode will be used, the locked_bytes is that of the | 69 // Since the original decode will be used, the locked_bytes is that of the |
70 // original image. | 70 // original image. |
71 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 71 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
72 } | 72 } |
73 } | 73 } |
74 | 74 |
75 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) { | 75 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) { |
76 sk_sp<SkImage> image = CreateImage(100, 100); | 76 sk_sp<SkImage> image = CreateImage(100, 100); |
77 bool is_decomposable = true; | 77 bool is_decomposable = true; |
78 SkFilterQuality quality = kMedium_SkFilterQuality; | 78 SkFilterQuality quality = kMedium_SkFilterQuality; |
79 | 79 |
80 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 80 DrawImage draw_image( |
81 quality, | 81 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
82 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | 82 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
83 DefaultColorSpace()); | 83 DefaultColorSpace()); |
84 | 84 |
85 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 85 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
86 EXPECT_EQ(image->uniqueID(), key.image_id()); | 86 EXPECT_EQ(image->uniqueID(), key.image_id()); |
87 EXPECT_EQ(quality, key.filter_quality()); | 87 EXPECT_EQ(quality, key.filter_quality()); |
88 EXPECT_EQ(100, key.target_size().width()); | 88 EXPECT_EQ(100, key.target_size().width()); |
89 EXPECT_EQ(100, key.target_size().height()); | 89 EXPECT_EQ(100, key.target_size().height()); |
90 EXPECT_FALSE(key.can_use_original_size_decode()); | 90 EXPECT_FALSE(key.can_use_original_size_decode()); |
91 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 91 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
92 } | 92 } |
93 | 93 |
94 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfEnlarging) { | 94 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfEnlarging) { |
95 sk_sp<SkImage> image = CreateImage(100, 100); | 95 sk_sp<SkImage> image = CreateImage(100, 100); |
96 bool is_decomposable = true; | 96 bool is_decomposable = true; |
97 SkFilterQuality quality = kMedium_SkFilterQuality; | 97 SkFilterQuality quality = kMedium_SkFilterQuality; |
98 | 98 |
99 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 99 DrawImage draw_image( |
100 quality, | 100 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
101 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 101 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
102 DefaultColorSpace()); | 102 DefaultColorSpace()); |
103 | 103 |
104 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 104 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
105 EXPECT_EQ(image->uniqueID(), key.image_id()); | 105 EXPECT_EQ(image->uniqueID(), key.image_id()); |
106 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 106 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
107 EXPECT_EQ(100, key.target_size().width()); | 107 EXPECT_EQ(100, key.target_size().width()); |
108 EXPECT_EQ(100, key.target_size().height()); | 108 EXPECT_EQ(100, key.target_size().height()); |
109 EXPECT_TRUE(key.can_use_original_size_decode()); | 109 EXPECT_TRUE(key.can_use_original_size_decode()); |
110 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 110 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
111 } | 111 } |
112 | 112 |
113 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfIdentity) { | 113 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfIdentity) { |
114 sk_sp<SkImage> image = CreateImage(100, 100); | 114 sk_sp<SkImage> image = CreateImage(100, 100); |
115 bool is_decomposable = true; | 115 bool is_decomposable = true; |
116 SkFilterQuality quality = kMedium_SkFilterQuality; | 116 SkFilterQuality quality = kMedium_SkFilterQuality; |
117 | 117 |
118 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 118 DrawImage draw_image( |
119 quality, | 119 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
120 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 120 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
121 DefaultColorSpace()); | 121 DefaultColorSpace()); |
122 | 122 |
123 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 123 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
124 EXPECT_EQ(image->uniqueID(), key.image_id()); | 124 EXPECT_EQ(image->uniqueID(), key.image_id()); |
125 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 125 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
126 EXPECT_EQ(100, key.target_size().width()); | 126 EXPECT_EQ(100, key.target_size().width()); |
127 EXPECT_EQ(100, key.target_size().height()); | 127 EXPECT_EQ(100, key.target_size().height()); |
128 EXPECT_TRUE(key.can_use_original_size_decode()); | 128 EXPECT_TRUE(key.can_use_original_size_decode()); |
129 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 129 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
130 } | 130 } |
131 | 131 |
132 TEST(SoftwareImageDecodeCacheTest, | 132 TEST(SoftwareImageDecodeCacheTest, |
133 ImageKeyMediumQualityDropToLowIfNearlyIdentity) { | 133 ImageKeyMediumQualityDropToLowIfNearlyIdentity) { |
134 sk_sp<SkImage> image = CreateImage(100, 100); | 134 sk_sp<SkImage> image = CreateImage(100, 100); |
135 bool is_decomposable = true; | 135 bool is_decomposable = true; |
136 SkFilterQuality quality = kMedium_SkFilterQuality; | 136 SkFilterQuality quality = kMedium_SkFilterQuality; |
137 | 137 |
138 DrawImage draw_image( | 138 DrawImage draw_image( |
139 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 139 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
140 CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable), | 140 quality, CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable), |
141 DefaultColorSpace()); | 141 DefaultColorSpace()); |
142 | 142 |
143 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 143 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
144 EXPECT_EQ(image->uniqueID(), key.image_id()); | 144 EXPECT_EQ(image->uniqueID(), key.image_id()); |
145 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 145 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
146 EXPECT_EQ(100, key.target_size().width()); | 146 EXPECT_EQ(100, key.target_size().width()); |
147 EXPECT_EQ(100, key.target_size().height()); | 147 EXPECT_EQ(100, key.target_size().height()); |
148 EXPECT_TRUE(key.can_use_original_size_decode()); | 148 EXPECT_TRUE(key.can_use_original_size_decode()); |
149 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 149 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
150 } | 150 } |
151 | 151 |
152 TEST(SoftwareImageDecodeCacheTest, | 152 TEST(SoftwareImageDecodeCacheTest, |
153 ImageKeyMediumQualityDropToLowIfNearlyIdentity2) { | 153 ImageKeyMediumQualityDropToLowIfNearlyIdentity2) { |
154 sk_sp<SkImage> image = CreateImage(100, 100); | 154 sk_sp<SkImage> image = CreateImage(100, 100); |
155 bool is_decomposable = true; | 155 bool is_decomposable = true; |
156 SkFilterQuality quality = kMedium_SkFilterQuality; | 156 SkFilterQuality quality = kMedium_SkFilterQuality; |
157 | 157 |
158 DrawImage draw_image( | 158 DrawImage draw_image( |
159 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 159 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
160 CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable), | 160 quality, CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable), |
161 DefaultColorSpace()); | 161 DefaultColorSpace()); |
162 | 162 |
163 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 163 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
164 EXPECT_EQ(image->uniqueID(), key.image_id()); | 164 EXPECT_EQ(image->uniqueID(), key.image_id()); |
165 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 165 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
166 EXPECT_EQ(100, key.target_size().width()); | 166 EXPECT_EQ(100, key.target_size().width()); |
167 EXPECT_EQ(100, key.target_size().height()); | 167 EXPECT_EQ(100, key.target_size().height()); |
168 EXPECT_TRUE(key.can_use_original_size_decode()); | 168 EXPECT_TRUE(key.can_use_original_size_decode()); |
169 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 169 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
170 } | 170 } |
171 | 171 |
172 TEST(SoftwareImageDecodeCacheTest, | 172 TEST(SoftwareImageDecodeCacheTest, |
173 ImageKeyMediumQualityDropToLowIfNotDecomposable) { | 173 ImageKeyMediumQualityDropToLowIfNotDecomposable) { |
174 sk_sp<SkImage> image = CreateImage(100, 100); | 174 sk_sp<SkImage> image = CreateImage(100, 100); |
175 bool is_decomposable = false; | 175 bool is_decomposable = false; |
176 SkFilterQuality quality = kMedium_SkFilterQuality; | 176 SkFilterQuality quality = kMedium_SkFilterQuality; |
177 | 177 |
178 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 178 DrawImage draw_image( |
179 quality, | 179 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
180 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | 180 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
181 DefaultColorSpace()); | 181 DefaultColorSpace()); |
182 | 182 |
183 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 183 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
184 EXPECT_EQ(image->uniqueID(), key.image_id()); | 184 EXPECT_EQ(image->uniqueID(), key.image_id()); |
185 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 185 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
186 EXPECT_EQ(100, key.target_size().width()); | 186 EXPECT_EQ(100, key.target_size().width()); |
187 EXPECT_EQ(100, key.target_size().height()); | 187 EXPECT_EQ(100, key.target_size().height()); |
188 EXPECT_TRUE(key.can_use_original_size_decode()); | 188 EXPECT_TRUE(key.can_use_original_size_decode()); |
189 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 189 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
190 } | 190 } |
191 | 191 |
192 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_5Scale) { | 192 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_5Scale) { |
193 sk_sp<SkImage> image = CreateImage(500, 200); | 193 sk_sp<SkImage> image = CreateImage(500, 200); |
194 bool is_decomposable = true; | 194 bool is_decomposable = true; |
195 SkFilterQuality quality = kMedium_SkFilterQuality; | 195 SkFilterQuality quality = kMedium_SkFilterQuality; |
196 | 196 |
197 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 197 DrawImage draw_image( |
198 quality, | 198 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
199 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 199 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
200 DefaultColorSpace()); | 200 DefaultColorSpace()); |
201 | 201 |
202 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 202 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
203 EXPECT_EQ(image->uniqueID(), key.image_id()); | 203 EXPECT_EQ(image->uniqueID(), key.image_id()); |
204 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 204 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
205 EXPECT_EQ(500, key.target_size().width()); | 205 EXPECT_EQ(500, key.target_size().width()); |
206 EXPECT_EQ(200, key.target_size().height()); | 206 EXPECT_EQ(200, key.target_size().height()); |
207 EXPECT_TRUE(key.can_use_original_size_decode()); | 207 EXPECT_TRUE(key.can_use_original_size_decode()); |
208 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); | 208 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); |
209 } | 209 } |
210 | 210 |
211 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_0cale) { | 211 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_0cale) { |
212 sk_sp<SkImage> image = CreateImage(500, 200); | 212 sk_sp<SkImage> image = CreateImage(500, 200); |
213 bool is_decomposable = true; | 213 bool is_decomposable = true; |
214 SkFilterQuality quality = kMedium_SkFilterQuality; | 214 SkFilterQuality quality = kMedium_SkFilterQuality; |
215 | 215 |
216 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 216 DrawImage draw_image( |
217 quality, | 217 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
218 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 218 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
219 DefaultColorSpace()); | 219 DefaultColorSpace()); |
220 | 220 |
221 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 221 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
222 EXPECT_EQ(image->uniqueID(), key.image_id()); | 222 EXPECT_EQ(image->uniqueID(), key.image_id()); |
223 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 223 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
224 EXPECT_EQ(500, key.target_size().width()); | 224 EXPECT_EQ(500, key.target_size().width()); |
225 EXPECT_EQ(200, key.target_size().height()); | 225 EXPECT_EQ(200, key.target_size().height()); |
226 EXPECT_TRUE(key.can_use_original_size_decode()); | 226 EXPECT_TRUE(key.can_use_original_size_decode()); |
227 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); | 227 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); |
228 } | 228 } |
229 | 229 |
230 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_75Scale) { | 230 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_75Scale) { |
231 sk_sp<SkImage> image = CreateImage(500, 200); | 231 sk_sp<SkImage> image = CreateImage(500, 200); |
232 bool is_decomposable = true; | 232 bool is_decomposable = true; |
233 SkFilterQuality quality = kMedium_SkFilterQuality; | 233 SkFilterQuality quality = kMedium_SkFilterQuality; |
234 | 234 |
235 DrawImage draw_image( | 235 DrawImage draw_image( |
236 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 236 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
237 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable), | 237 quality, CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable), |
238 DefaultColorSpace()); | 238 DefaultColorSpace()); |
239 | 239 |
240 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 240 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
241 EXPECT_EQ(image->uniqueID(), key.image_id()); | 241 EXPECT_EQ(image->uniqueID(), key.image_id()); |
242 EXPECT_EQ(quality, key.filter_quality()); | 242 EXPECT_EQ(quality, key.filter_quality()); |
243 EXPECT_EQ(500, key.target_size().width()); | 243 EXPECT_EQ(500, key.target_size().width()); |
244 EXPECT_EQ(200, key.target_size().height()); | 244 EXPECT_EQ(200, key.target_size().height()); |
245 EXPECT_FALSE(key.can_use_original_size_decode()); | 245 EXPECT_FALSE(key.can_use_original_size_decode()); |
246 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); | 246 EXPECT_EQ(500u * 200u * 4u, key.locked_bytes()); |
247 } | 247 } |
248 | 248 |
249 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_5Scale) { | 249 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_5Scale) { |
250 sk_sp<SkImage> image = CreateImage(500, 200); | 250 sk_sp<SkImage> image = CreateImage(500, 200); |
251 bool is_decomposable = true; | 251 bool is_decomposable = true; |
252 SkFilterQuality quality = kMedium_SkFilterQuality; | 252 SkFilterQuality quality = kMedium_SkFilterQuality; |
253 | 253 |
254 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 254 DrawImage draw_image( |
255 quality, | 255 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
256 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 256 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
257 DefaultColorSpace()); | 257 DefaultColorSpace()); |
258 | 258 |
259 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 259 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
260 EXPECT_EQ(image->uniqueID(), key.image_id()); | 260 EXPECT_EQ(image->uniqueID(), key.image_id()); |
261 EXPECT_EQ(quality, key.filter_quality()); | 261 EXPECT_EQ(quality, key.filter_quality()); |
262 EXPECT_EQ(250, key.target_size().width()); | 262 EXPECT_EQ(250, key.target_size().width()); |
263 EXPECT_EQ(100, key.target_size().height()); | 263 EXPECT_EQ(100, key.target_size().height()); |
264 EXPECT_FALSE(key.can_use_original_size_decode()); | 264 EXPECT_FALSE(key.can_use_original_size_decode()); |
265 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); | 265 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); |
266 } | 266 } |
267 | 267 |
268 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_49Scale) { | 268 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_49Scale) { |
269 sk_sp<SkImage> image = CreateImage(500, 200); | 269 sk_sp<SkImage> image = CreateImage(500, 200); |
270 bool is_decomposable = true; | 270 bool is_decomposable = true; |
271 SkFilterQuality quality = kMedium_SkFilterQuality; | 271 SkFilterQuality quality = kMedium_SkFilterQuality; |
272 | 272 |
273 DrawImage draw_image( | 273 DrawImage draw_image( |
274 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 274 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
275 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable), | 275 quality, CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable), |
276 DefaultColorSpace()); | 276 DefaultColorSpace()); |
277 | 277 |
278 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 278 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
279 EXPECT_EQ(image->uniqueID(), key.image_id()); | 279 EXPECT_EQ(image->uniqueID(), key.image_id()); |
280 EXPECT_EQ(quality, key.filter_quality()); | 280 EXPECT_EQ(quality, key.filter_quality()); |
281 EXPECT_EQ(250, key.target_size().width()); | 281 EXPECT_EQ(250, key.target_size().width()); |
282 EXPECT_EQ(100, key.target_size().height()); | 282 EXPECT_EQ(100, key.target_size().height()); |
283 EXPECT_FALSE(key.can_use_original_size_decode()); | 283 EXPECT_FALSE(key.can_use_original_size_decode()); |
284 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); | 284 EXPECT_EQ(250u * 100u * 4u, key.locked_bytes()); |
285 } | 285 } |
286 | 286 |
287 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_1Scale) { | 287 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_1Scale) { |
288 sk_sp<SkImage> image = CreateImage(500, 200); | 288 sk_sp<SkImage> image = CreateImage(500, 200); |
289 bool is_decomposable = true; | 289 bool is_decomposable = true; |
290 SkFilterQuality quality = kMedium_SkFilterQuality; | 290 SkFilterQuality quality = kMedium_SkFilterQuality; |
291 | 291 |
292 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 292 DrawImage draw_image( |
293 quality, | 293 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
294 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable), | 294 quality, CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable), |
295 DefaultColorSpace()); | 295 DefaultColorSpace()); |
296 | 296 |
297 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 297 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
298 EXPECT_EQ(image->uniqueID(), key.image_id()); | 298 EXPECT_EQ(image->uniqueID(), key.image_id()); |
299 EXPECT_EQ(quality, key.filter_quality()); | 299 EXPECT_EQ(quality, key.filter_quality()); |
300 EXPECT_EQ(62, key.target_size().width()); | 300 EXPECT_EQ(62, key.target_size().width()); |
301 EXPECT_EQ(25, key.target_size().height()); | 301 EXPECT_EQ(25, key.target_size().height()); |
302 EXPECT_FALSE(key.can_use_original_size_decode()); | 302 EXPECT_FALSE(key.can_use_original_size_decode()); |
303 EXPECT_EQ(62u * 25u * 4u, key.locked_bytes()); | 303 EXPECT_EQ(62u * 25u * 4u, key.locked_bytes()); |
304 } | 304 } |
305 | 305 |
306 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_01Scale) { | 306 TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_01Scale) { |
307 sk_sp<SkImage> image = CreateImage(500, 200); | 307 sk_sp<SkImage> image = CreateImage(500, 200); |
308 bool is_decomposable = true; | 308 bool is_decomposable = true; |
309 SkFilterQuality quality = kMedium_SkFilterQuality; | 309 SkFilterQuality quality = kMedium_SkFilterQuality; |
310 | 310 |
311 DrawImage draw_image( | 311 DrawImage draw_image( |
312 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 312 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
313 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable), | 313 quality, CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable), |
314 DefaultColorSpace()); | 314 DefaultColorSpace()); |
315 | 315 |
316 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 316 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
317 EXPECT_EQ(image->uniqueID(), key.image_id()); | 317 EXPECT_EQ(image->uniqueID(), key.image_id()); |
318 EXPECT_EQ(quality, key.filter_quality()); | 318 EXPECT_EQ(quality, key.filter_quality()); |
319 EXPECT_EQ(7, key.target_size().width()); | 319 EXPECT_EQ(7, key.target_size().width()); |
320 EXPECT_EQ(3, key.target_size().height()); | 320 EXPECT_EQ(3, key.target_size().height()); |
321 EXPECT_FALSE(key.can_use_original_size_decode()); | 321 EXPECT_FALSE(key.can_use_original_size_decode()); |
322 EXPECT_EQ(7u * 3u * 4u, key.locked_bytes()); | 322 EXPECT_EQ(7u * 3u * 4u, key.locked_bytes()); |
323 } | 323 } |
324 | 324 |
325 TEST(SoftwareImageDecodeCacheTest, | 325 TEST(SoftwareImageDecodeCacheTest, |
326 ImageKeyPartialDowscalesDropsHighQualityToMedium) { | 326 ImageKeyPartialDowscalesDropsHighQualityToMedium) { |
327 sk_sp<SkImage> image = CreateImage(100, 100); | 327 sk_sp<SkImage> image = CreateImage(100, 100); |
328 bool is_decomposable = true; | 328 bool is_decomposable = true; |
329 SkFilterQuality quality = kHigh_SkFilterQuality; | 329 SkFilterQuality quality = kHigh_SkFilterQuality; |
330 | 330 |
331 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 331 DrawImage draw_image( |
332 quality, | 332 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
333 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | 333 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
334 DefaultColorSpace()); | 334 DefaultColorSpace()); |
335 | 335 |
336 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 336 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
337 EXPECT_EQ(image->uniqueID(), key.image_id()); | 337 EXPECT_EQ(image->uniqueID(), key.image_id()); |
338 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 338 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
339 EXPECT_EQ(100, key.target_size().width()); | 339 EXPECT_EQ(100, key.target_size().width()); |
340 EXPECT_EQ(100, key.target_size().height()); | 340 EXPECT_EQ(100, key.target_size().height()); |
341 EXPECT_FALSE(key.can_use_original_size_decode()); | 341 EXPECT_FALSE(key.can_use_original_size_decode()); |
342 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 342 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
343 } | 343 } |
344 | 344 |
345 TEST(SoftwareImageDecodeCacheTest, | 345 TEST(SoftwareImageDecodeCacheTest, |
346 ImageKeyFullDowscalesDropsHighQualityToMedium) { | 346 ImageKeyFullDowscalesDropsHighQualityToMedium) { |
347 sk_sp<SkImage> image = CreateImage(100, 100); | 347 sk_sp<SkImage> image = CreateImage(100, 100); |
348 bool is_decomposable = true; | 348 bool is_decomposable = true; |
349 SkFilterQuality quality = kHigh_SkFilterQuality; | 349 SkFilterQuality quality = kHigh_SkFilterQuality; |
350 | 350 |
351 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 351 DrawImage draw_image( |
352 quality, | 352 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
353 CreateMatrix(SkSize::Make(0.5f, 0.2f), is_decomposable), | 353 quality, CreateMatrix(SkSize::Make(0.5f, 0.2f), is_decomposable), |
354 DefaultColorSpace()); | 354 DefaultColorSpace()); |
355 | 355 |
356 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 356 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
357 EXPECT_EQ(image->uniqueID(), key.image_id()); | 357 EXPECT_EQ(image->uniqueID(), key.image_id()); |
358 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 358 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
359 EXPECT_EQ(50, key.target_size().width()); | 359 EXPECT_EQ(50, key.target_size().width()); |
360 EXPECT_EQ(50, key.target_size().height()); | 360 EXPECT_EQ(50, key.target_size().height()); |
361 EXPECT_FALSE(key.can_use_original_size_decode()); | 361 EXPECT_FALSE(key.can_use_original_size_decode()); |
362 EXPECT_EQ(50u * 50u * 4u, key.locked_bytes()); | 362 EXPECT_EQ(50u * 50u * 4u, key.locked_bytes()); |
363 } | 363 } |
364 | 364 |
365 TEST(SoftwareImageDecodeCacheTest, ImageKeyDowscalesHighQuality) { | 365 TEST(SoftwareImageDecodeCacheTest, ImageKeyDowscalesHighQuality) { |
366 sk_sp<SkImage> image = CreateImage(100, 100); | 366 sk_sp<SkImage> image = CreateImage(100, 100); |
367 bool is_decomposable = true; | 367 bool is_decomposable = true; |
368 SkFilterQuality quality = kHigh_SkFilterQuality; | 368 SkFilterQuality quality = kHigh_SkFilterQuality; |
369 | 369 |
370 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 370 DrawImage draw_image( |
371 quality, | 371 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
372 CreateMatrix(SkSize::Make(2.5f, 1.5f), is_decomposable), | 372 quality, CreateMatrix(SkSize::Make(2.5f, 1.5f), is_decomposable), |
373 DefaultColorSpace()); | 373 DefaultColorSpace()); |
374 | 374 |
375 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 375 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
376 EXPECT_EQ(image->uniqueID(), key.image_id()); | 376 EXPECT_EQ(image->uniqueID(), key.image_id()); |
377 EXPECT_EQ(quality, key.filter_quality()); | 377 EXPECT_EQ(quality, key.filter_quality()); |
378 EXPECT_EQ(250, key.target_size().width()); | 378 EXPECT_EQ(250, key.target_size().width()); |
379 EXPECT_EQ(150, key.target_size().height()); | 379 EXPECT_EQ(150, key.target_size().height()); |
380 EXPECT_FALSE(key.can_use_original_size_decode()); | 380 EXPECT_FALSE(key.can_use_original_size_decode()); |
381 EXPECT_EQ(250u * 150u * 4u, key.locked_bytes()); | 381 EXPECT_EQ(250u * 150u * 4u, key.locked_bytes()); |
382 } | 382 } |
383 | 383 |
384 TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToMediumIfTooLarge) { | 384 TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToMediumIfTooLarge) { |
385 // Just over 64MB when scaled. | 385 // Just over 64MB when scaled. |
386 sk_sp<SkImage> image = CreateImage(4555, 2048); | 386 sk_sp<SkImage> image = CreateImage(4555, 2048); |
387 bool is_decomposable = true; | 387 bool is_decomposable = true; |
388 SkFilterQuality quality = kHigh_SkFilterQuality; | 388 SkFilterQuality quality = kHigh_SkFilterQuality; |
389 | 389 |
390 // At least one dimension should scale down, so that medium quality doesn't | 390 // At least one dimension should scale down, so that medium quality doesn't |
391 // become low. | 391 // become low. |
392 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 392 DrawImage draw_image( |
393 quality, | 393 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
394 CreateMatrix(SkSize::Make(0.9f, 2.f), is_decomposable), | 394 quality, CreateMatrix(SkSize::Make(0.9f, 2.f), is_decomposable), |
395 DefaultColorSpace()); | 395 DefaultColorSpace()); |
396 | 396 |
397 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 397 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
398 EXPECT_EQ(image->uniqueID(), key.image_id()); | 398 EXPECT_EQ(image->uniqueID(), key.image_id()); |
399 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 399 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
400 EXPECT_EQ(4555, key.target_size().width()); | 400 EXPECT_EQ(4555, key.target_size().width()); |
401 EXPECT_EQ(2048, key.target_size().height()); | 401 EXPECT_EQ(2048, key.target_size().height()); |
402 EXPECT_FALSE(key.can_use_original_size_decode()); | 402 EXPECT_FALSE(key.can_use_original_size_decode()); |
403 EXPECT_EQ(4555u * 2048u * 4u, key.locked_bytes()); | 403 EXPECT_EQ(4555u * 2048u * 4u, key.locked_bytes()); |
404 } | 404 } |
405 | 405 |
406 TEST(SoftwareImageDecodeCacheTest, | 406 TEST(SoftwareImageDecodeCacheTest, |
407 ImageKeyHighQualityDropToLowIfNotDecomposable) { | 407 ImageKeyHighQualityDropToLowIfNotDecomposable) { |
408 sk_sp<SkImage> image = CreateImage(100, 100); | 408 sk_sp<SkImage> image = CreateImage(100, 100); |
409 bool is_decomposable = false; | 409 bool is_decomposable = false; |
410 SkFilterQuality quality = kHigh_SkFilterQuality; | 410 SkFilterQuality quality = kHigh_SkFilterQuality; |
411 | 411 |
412 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 412 DrawImage draw_image( |
413 quality, | 413 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
414 CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), | 414 quality, CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable), |
415 DefaultColorSpace()); | 415 DefaultColorSpace()); |
416 | 416 |
417 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 417 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
418 EXPECT_EQ(image->uniqueID(), key.image_id()); | 418 EXPECT_EQ(image->uniqueID(), key.image_id()); |
419 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 419 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
420 EXPECT_EQ(100, key.target_size().width()); | 420 EXPECT_EQ(100, key.target_size().width()); |
421 EXPECT_EQ(100, key.target_size().height()); | 421 EXPECT_EQ(100, key.target_size().height()); |
422 EXPECT_TRUE(key.can_use_original_size_decode()); | 422 EXPECT_TRUE(key.can_use_original_size_decode()); |
423 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 423 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
424 } | 424 } |
425 | 425 |
426 TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToLowIfIdentity) { | 426 TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToLowIfIdentity) { |
427 sk_sp<SkImage> image = CreateImage(100, 100); | 427 sk_sp<SkImage> image = CreateImage(100, 100); |
428 bool is_decomposable = true; | 428 bool is_decomposable = true; |
429 SkFilterQuality quality = kHigh_SkFilterQuality; | 429 SkFilterQuality quality = kHigh_SkFilterQuality; |
430 | 430 |
431 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 431 DrawImage draw_image( |
432 quality, | 432 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
433 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 433 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
434 DefaultColorSpace()); | 434 DefaultColorSpace()); |
435 | 435 |
436 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 436 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
437 EXPECT_EQ(image->uniqueID(), key.image_id()); | 437 EXPECT_EQ(image->uniqueID(), key.image_id()); |
438 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 438 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
439 EXPECT_EQ(100, key.target_size().width()); | 439 EXPECT_EQ(100, key.target_size().width()); |
440 EXPECT_EQ(100, key.target_size().height()); | 440 EXPECT_EQ(100, key.target_size().height()); |
441 EXPECT_TRUE(key.can_use_original_size_decode()); | 441 EXPECT_TRUE(key.can_use_original_size_decode()); |
442 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 442 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
443 } | 443 } |
444 | 444 |
445 TEST(SoftwareImageDecodeCacheTest, | 445 TEST(SoftwareImageDecodeCacheTest, |
446 ImageKeyHighQualityDropToLowIfNearlyIdentity) { | 446 ImageKeyHighQualityDropToLowIfNearlyIdentity) { |
447 sk_sp<SkImage> image = CreateImage(100, 100); | 447 sk_sp<SkImage> image = CreateImage(100, 100); |
448 bool is_decomposable = true; | 448 bool is_decomposable = true; |
449 SkFilterQuality quality = kHigh_SkFilterQuality; | 449 SkFilterQuality quality = kHigh_SkFilterQuality; |
450 | 450 |
451 DrawImage draw_image( | 451 DrawImage draw_image( |
452 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 452 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
453 CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable), | 453 quality, CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable), |
454 DefaultColorSpace()); | 454 DefaultColorSpace()); |
455 | 455 |
456 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 456 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
457 EXPECT_EQ(image->uniqueID(), key.image_id()); | 457 EXPECT_EQ(image->uniqueID(), key.image_id()); |
458 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 458 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
459 EXPECT_EQ(100, key.target_size().width()); | 459 EXPECT_EQ(100, key.target_size().width()); |
460 EXPECT_EQ(100, key.target_size().height()); | 460 EXPECT_EQ(100, key.target_size().height()); |
461 EXPECT_TRUE(key.can_use_original_size_decode()); | 461 EXPECT_TRUE(key.can_use_original_size_decode()); |
462 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 462 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
463 } | 463 } |
464 | 464 |
465 TEST(SoftwareImageDecodeCacheTest, | 465 TEST(SoftwareImageDecodeCacheTest, |
466 ImageKeyHighQualityDropToLowIfNearlyIdentity2) { | 466 ImageKeyHighQualityDropToLowIfNearlyIdentity2) { |
467 sk_sp<SkImage> image = CreateImage(100, 100); | 467 sk_sp<SkImage> image = CreateImage(100, 100); |
468 bool is_decomposable = true; | 468 bool is_decomposable = true; |
469 SkFilterQuality quality = kHigh_SkFilterQuality; | 469 SkFilterQuality quality = kHigh_SkFilterQuality; |
470 | 470 |
471 DrawImage draw_image( | 471 DrawImage draw_image( |
472 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 472 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
473 CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable), | 473 quality, CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable), |
474 DefaultColorSpace()); | 474 DefaultColorSpace()); |
475 | 475 |
476 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 476 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
477 EXPECT_EQ(image->uniqueID(), key.image_id()); | 477 EXPECT_EQ(image->uniqueID(), key.image_id()); |
478 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 478 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
479 EXPECT_EQ(100, key.target_size().width()); | 479 EXPECT_EQ(100, key.target_size().width()); |
480 EXPECT_EQ(100, key.target_size().height()); | 480 EXPECT_EQ(100, key.target_size().height()); |
481 EXPECT_TRUE(key.can_use_original_size_decode()); | 481 EXPECT_TRUE(key.can_use_original_size_decode()); |
482 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 482 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
483 } | 483 } |
484 | 484 |
485 TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) { | 485 TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) { |
486 sk_sp<SkImage> image = CreateImage(100, 100); | 486 sk_sp<SkImage> image = CreateImage(100, 100); |
487 bool is_decomposable = true; | 487 bool is_decomposable = true; |
488 SkFilterQuality quality = kLow_SkFilterQuality; | 488 SkFilterQuality quality = kLow_SkFilterQuality; |
489 | 489 |
490 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 490 DrawImage draw_image( |
491 quality, | 491 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
492 CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable), | 492 quality, CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable), |
493 DefaultColorSpace()); | 493 DefaultColorSpace()); |
494 | 494 |
495 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 495 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
496 EXPECT_EQ(image->uniqueID(), key.image_id()); | 496 EXPECT_EQ(image->uniqueID(), key.image_id()); |
497 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 497 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
498 EXPECT_EQ(100, key.target_size().width()); | 498 EXPECT_EQ(100, key.target_size().width()); |
499 EXPECT_EQ(100, key.target_size().height()); | 499 EXPECT_EQ(100, key.target_size().height()); |
500 EXPECT_TRUE(key.can_use_original_size_decode()); | 500 EXPECT_TRUE(key.can_use_original_size_decode()); |
501 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 501 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
502 | 502 |
503 DrawImage another_draw_image( | 503 DrawImage another_draw_image( |
504 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 504 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
505 CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable), | 505 quality, CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable), |
506 DefaultColorSpace()); | 506 DefaultColorSpace()); |
507 | 507 |
508 auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image); | 508 auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image); |
509 EXPECT_EQ(image->uniqueID(), another_key.image_id()); | 509 EXPECT_EQ(image->uniqueID(), another_key.image_id()); |
510 EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality()); | 510 EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality()); |
511 EXPECT_EQ(100, another_key.target_size().width()); | 511 EXPECT_EQ(100, another_key.target_size().width()); |
512 EXPECT_EQ(100, another_key.target_size().height()); | 512 EXPECT_EQ(100, another_key.target_size().height()); |
513 EXPECT_TRUE(another_key.can_use_original_size_decode()); | 513 EXPECT_TRUE(another_key.can_use_original_size_decode()); |
514 EXPECT_EQ(100u * 100u * 4u, another_key.locked_bytes()); | 514 EXPECT_EQ(100u * 100u * 4u, another_key.locked_bytes()); |
515 | 515 |
516 EXPECT_TRUE(key == another_key); | 516 EXPECT_TRUE(key == another_key); |
517 } | 517 } |
518 | 518 |
519 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) { | 519 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) { |
520 sk_sp<SkImage> image = CreateImage(100, 100); | 520 sk_sp<SkImage> image = CreateImage(100, 100); |
521 bool is_decomposable = true; | 521 bool is_decomposable = true; |
522 SkFilterQuality quality = kHigh_SkFilterQuality; | 522 SkFilterQuality quality = kHigh_SkFilterQuality; |
523 | 523 |
524 DrawImage draw_image( | 524 DrawImage draw_image( |
525 image, SkIRect::MakeXYWH(25, 35, image->width(), image->height()), | 525 PaintImage(image), |
526 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 526 SkIRect::MakeXYWH(25, 35, image->width(), image->height()), quality, |
| 527 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
527 DefaultColorSpace()); | 528 DefaultColorSpace()); |
528 | 529 |
529 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 530 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
530 EXPECT_EQ(image->uniqueID(), key.image_id()); | 531 EXPECT_EQ(image->uniqueID(), key.image_id()); |
531 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); | 532 EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality()); |
532 EXPECT_EQ(100, key.target_size().width()); | 533 EXPECT_EQ(100, key.target_size().width()); |
533 EXPECT_EQ(100, key.target_size().height()); | 534 EXPECT_EQ(100, key.target_size().height()); |
534 EXPECT_EQ(gfx::Rect(25, 35, 75, 65), key.src_rect()); | 535 EXPECT_EQ(gfx::Rect(25, 35, 75, 65), key.src_rect()); |
535 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); | 536 EXPECT_EQ(100u * 100u * 4u, key.locked_bytes()); |
536 } | 537 } |
537 | 538 |
538 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRectWithScale) { | 539 TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRectWithScale) { |
539 sk_sp<SkImage> image = CreateImage(100, 100); | 540 sk_sp<SkImage> image = CreateImage(100, 100); |
540 bool is_decomposable = true; | 541 bool is_decomposable = true; |
541 SkFilterQuality quality = kHigh_SkFilterQuality; | 542 SkFilterQuality quality = kHigh_SkFilterQuality; |
542 | 543 |
543 DrawImage draw_image( | 544 DrawImage draw_image( |
544 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 545 PaintImage(image), |
545 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 546 SkIRect::MakeXYWH(20, 30, image->width(), image->height()), quality, |
| 547 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
546 DefaultColorSpace()); | 548 DefaultColorSpace()); |
547 | 549 |
548 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); | 550 auto key = ImageDecodeCacheKey::FromDrawImage(draw_image); |
549 EXPECT_EQ(image->uniqueID(), key.image_id()); | 551 EXPECT_EQ(image->uniqueID(), key.image_id()); |
550 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); | 552 EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality()); |
551 EXPECT_EQ(40, key.target_size().width()); | 553 EXPECT_EQ(40, key.target_size().width()); |
552 EXPECT_EQ(35, key.target_size().height()); | 554 EXPECT_EQ(35, key.target_size().height()); |
553 EXPECT_EQ(gfx::Rect(20, 30, 80, 70), key.src_rect()); | 555 EXPECT_EQ(gfx::Rect(20, 30, 80, 70), key.src_rect()); |
554 EXPECT_EQ(40u * 35u * 4u, key.locked_bytes()); | 556 EXPECT_EQ(40u * 35u * 4u, key.locked_bytes()); |
555 } | 557 } |
556 | 558 |
557 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImage) { | 559 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImage) { |
558 TestSoftwareImageDecodeCache cache; | 560 TestSoftwareImageDecodeCache cache; |
559 sk_sp<SkImage> image = CreateImage(100, 100); | 561 sk_sp<SkImage> image = CreateImage(100, 100); |
560 bool is_decomposable = true; | 562 bool is_decomposable = true; |
561 SkFilterQuality quality = kHigh_SkFilterQuality; | 563 SkFilterQuality quality = kHigh_SkFilterQuality; |
562 | 564 |
563 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 565 DrawImage draw_image( |
564 quality, | 566 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
565 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 567 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
566 DefaultColorSpace()); | 568 DefaultColorSpace()); |
567 scoped_refptr<TileTask> task; | 569 scoped_refptr<TileTask> task; |
568 bool need_unref = cache.GetTaskForImageAndRef( | 570 bool need_unref = cache.GetTaskForImageAndRef( |
569 draw_image, ImageDecodeCache::TracingInfo(), &task); | 571 draw_image, ImageDecodeCache::TracingInfo(), &task); |
570 EXPECT_TRUE(need_unref); | 572 EXPECT_TRUE(need_unref); |
571 EXPECT_TRUE(task); | 573 EXPECT_TRUE(task); |
572 | 574 |
573 DrawImage another_draw_image( | 575 DrawImage another_draw_image( |
574 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 576 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
575 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 577 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
576 DefaultColorSpace()); | 578 DefaultColorSpace()); |
577 scoped_refptr<TileTask> another_task; | 579 scoped_refptr<TileTask> another_task; |
578 need_unref = cache.GetTaskForImageAndRef( | 580 need_unref = cache.GetTaskForImageAndRef( |
579 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 581 another_draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
580 EXPECT_TRUE(need_unref); | 582 EXPECT_TRUE(need_unref); |
581 EXPECT_TRUE(task.get() == another_task.get()); | 583 EXPECT_TRUE(task.get() == another_task.get()); |
582 | 584 |
583 TestTileTaskRunner::ProcessTask(task.get()); | 585 TestTileTaskRunner::ProcessTask(task.get()); |
584 | 586 |
585 cache.UnrefImage(draw_image); | 587 cache.UnrefImage(draw_image); |
586 cache.UnrefImage(draw_image); | 588 cache.UnrefImage(draw_image); |
587 } | 589 } |
588 | 590 |
589 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentQuality) { | 591 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentQuality) { |
590 TestSoftwareImageDecodeCache cache; | 592 TestSoftwareImageDecodeCache cache; |
591 sk_sp<SkImage> image = CreateImage(100, 100); | 593 sk_sp<SkImage> image = CreateImage(100, 100); |
592 bool is_decomposable = true; | 594 bool is_decomposable = true; |
593 | 595 |
594 DrawImage high_quality_draw_image( | 596 DrawImage high_quality_draw_image( |
595 image, SkIRect::MakeWH(image->width(), image->height()), | 597 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
596 kHigh_SkFilterQuality, | 598 kHigh_SkFilterQuality, |
597 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 599 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
598 DefaultColorSpace()); | 600 DefaultColorSpace()); |
599 scoped_refptr<TileTask> high_quality_task; | 601 scoped_refptr<TileTask> high_quality_task; |
600 bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image, | 602 bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image, |
601 ImageDecodeCache::TracingInfo(), | 603 ImageDecodeCache::TracingInfo(), |
602 &high_quality_task); | 604 &high_quality_task); |
603 EXPECT_TRUE(need_unref); | 605 EXPECT_TRUE(need_unref); |
604 EXPECT_TRUE(high_quality_task); | 606 EXPECT_TRUE(high_quality_task); |
605 | 607 |
606 DrawImage low_quality_draw_image( | 608 DrawImage low_quality_draw_image( |
607 image, SkIRect::MakeWH(image->width(), image->height()), | 609 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
608 kLow_SkFilterQuality, | 610 kLow_SkFilterQuality, |
609 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 611 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
610 DefaultColorSpace()); | 612 DefaultColorSpace()); |
611 scoped_refptr<TileTask> low_quality_task; | 613 scoped_refptr<TileTask> low_quality_task; |
612 need_unref = cache.GetTaskForImageAndRef(low_quality_draw_image, | 614 need_unref = cache.GetTaskForImageAndRef(low_quality_draw_image, |
613 ImageDecodeCache::TracingInfo(), | 615 ImageDecodeCache::TracingInfo(), |
614 &low_quality_task); | 616 &low_quality_task); |
615 EXPECT_TRUE(need_unref); | 617 EXPECT_TRUE(need_unref); |
616 EXPECT_TRUE(low_quality_task); | 618 EXPECT_TRUE(low_quality_task); |
617 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); | 619 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); |
618 | 620 |
619 TestTileTaskRunner::ProcessTask(high_quality_task.get()); | 621 TestTileTaskRunner::ProcessTask(high_quality_task.get()); |
620 TestTileTaskRunner::ProcessTask(low_quality_task.get()); | 622 TestTileTaskRunner::ProcessTask(low_quality_task.get()); |
621 | 623 |
622 cache.UnrefImage(high_quality_draw_image); | 624 cache.UnrefImage(high_quality_draw_image); |
623 cache.UnrefImage(low_quality_draw_image); | 625 cache.UnrefImage(low_quality_draw_image); |
624 } | 626 } |
625 | 627 |
626 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) { | 628 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) { |
627 TestSoftwareImageDecodeCache cache; | 629 TestSoftwareImageDecodeCache cache; |
628 sk_sp<SkImage> image = CreateImage(100, 100); | 630 sk_sp<SkImage> image = CreateImage(100, 100); |
629 bool is_decomposable = true; | 631 bool is_decomposable = true; |
630 SkFilterQuality quality = kHigh_SkFilterQuality; | 632 SkFilterQuality quality = kHigh_SkFilterQuality; |
631 | 633 |
632 DrawImage half_size_draw_image( | 634 DrawImage half_size_draw_image( |
633 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 635 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
634 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 636 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
635 DefaultColorSpace()); | 637 DefaultColorSpace()); |
636 scoped_refptr<TileTask> half_size_task; | 638 scoped_refptr<TileTask> half_size_task; |
637 bool need_unref = cache.GetTaskForImageAndRef( | 639 bool need_unref = cache.GetTaskForImageAndRef( |
638 half_size_draw_image, ImageDecodeCache::TracingInfo(), &half_size_task); | 640 half_size_draw_image, ImageDecodeCache::TracingInfo(), &half_size_task); |
639 EXPECT_TRUE(need_unref); | 641 EXPECT_TRUE(need_unref); |
640 EXPECT_TRUE(half_size_task); | 642 EXPECT_TRUE(half_size_task); |
641 | 643 |
642 DrawImage quarter_size_draw_image( | 644 DrawImage quarter_size_draw_image( |
643 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 645 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
644 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable), | 646 quality, CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable), |
645 DefaultColorSpace()); | 647 DefaultColorSpace()); |
646 scoped_refptr<TileTask> quarter_size_task; | 648 scoped_refptr<TileTask> quarter_size_task; |
647 need_unref = cache.GetTaskForImageAndRef(quarter_size_draw_image, | 649 need_unref = cache.GetTaskForImageAndRef(quarter_size_draw_image, |
648 ImageDecodeCache::TracingInfo(), | 650 ImageDecodeCache::TracingInfo(), |
649 &quarter_size_task); | 651 &quarter_size_task); |
650 EXPECT_TRUE(need_unref); | 652 EXPECT_TRUE(need_unref); |
651 EXPECT_TRUE(quarter_size_task); | 653 EXPECT_TRUE(quarter_size_task); |
652 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); | 654 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); |
653 | 655 |
654 TestTileTaskRunner::ProcessTask(half_size_task.get()); | 656 TestTileTaskRunner::ProcessTask(half_size_task.get()); |
655 TestTileTaskRunner::ProcessTask(quarter_size_task.get()); | 657 TestTileTaskRunner::ProcessTask(quarter_size_task.get()); |
656 | 658 |
657 cache.UnrefImage(half_size_draw_image); | 659 cache.UnrefImage(half_size_draw_image); |
658 cache.UnrefImage(quarter_size_draw_image); | 660 cache.UnrefImage(quarter_size_draw_image); |
659 } | 661 } |
660 | 662 |
661 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageDifferentImage) { | 663 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageDifferentImage) { |
662 TestSoftwareImageDecodeCache cache; | 664 TestSoftwareImageDecodeCache cache; |
663 bool is_decomposable = true; | 665 bool is_decomposable = true; |
664 SkFilterQuality quality = kHigh_SkFilterQuality; | 666 SkFilterQuality quality = kHigh_SkFilterQuality; |
665 | 667 |
666 sk_sp<SkImage> first_image = CreateImage(100, 100); | 668 sk_sp<SkImage> first_image = CreateImage(100, 100); |
667 DrawImage first_draw_image( | 669 DrawImage first_draw_image( |
668 first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), | 670 PaintImage(first_image), |
669 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 671 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
| 672 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
670 DefaultColorSpace()); | 673 DefaultColorSpace()); |
671 scoped_refptr<TileTask> first_task; | 674 scoped_refptr<TileTask> first_task; |
672 bool need_unref = cache.GetTaskForImageAndRef( | 675 bool need_unref = cache.GetTaskForImageAndRef( |
673 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 676 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
674 EXPECT_TRUE(need_unref); | 677 EXPECT_TRUE(need_unref); |
675 EXPECT_TRUE(first_task); | 678 EXPECT_TRUE(first_task); |
676 | 679 |
677 sk_sp<SkImage> second_image = CreateImage(100, 100); | 680 sk_sp<SkImage> second_image = CreateImage(100, 100); |
678 DrawImage second_draw_image( | 681 DrawImage second_draw_image( |
679 second_image, | 682 PaintImage(second_image), |
680 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 683 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
681 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable), | 684 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable), |
682 DefaultColorSpace()); | 685 DefaultColorSpace()); |
683 scoped_refptr<TileTask> second_task; | 686 scoped_refptr<TileTask> second_task; |
684 need_unref = cache.GetTaskForImageAndRef( | 687 need_unref = cache.GetTaskForImageAndRef( |
685 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 688 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
686 EXPECT_TRUE(need_unref); | 689 EXPECT_TRUE(need_unref); |
687 EXPECT_TRUE(second_task); | 690 EXPECT_TRUE(second_task); |
688 EXPECT_TRUE(first_task.get() != second_task.get()); | 691 EXPECT_TRUE(first_task.get() != second_task.get()); |
689 | 692 |
(...skipping 18 matching lines...) Expand all Loading... |
708 SkFilterQuality quality = kHigh_SkFilterQuality; | 711 SkFilterQuality quality = kHigh_SkFilterQuality; |
709 | 712 |
710 gfx::ColorSpace color_space_a(gfx::ColorSpace::PrimaryID::XYZ_D50, | 713 gfx::ColorSpace color_space_a(gfx::ColorSpace::PrimaryID::XYZ_D50, |
711 gfx::ColorSpace::TransferID::IEC61966_2_1); | 714 gfx::ColorSpace::TransferID::IEC61966_2_1); |
712 gfx::ColorSpace color_space_b(gfx::ColorSpace::PrimaryID::SMPTE170M, | 715 gfx::ColorSpace color_space_b(gfx::ColorSpace::PrimaryID::SMPTE170M, |
713 gfx::ColorSpace::TransferID::IEC61966_2_1); | 716 gfx::ColorSpace::TransferID::IEC61966_2_1); |
714 gfx::ColorSpace color_space_c = gfx::ColorSpace::CreateSRGB(); | 717 gfx::ColorSpace color_space_c = gfx::ColorSpace::CreateSRGB(); |
715 | 718 |
716 sk_sp<SkImage> image = CreateImageWithColorSpace(100, 100, color_space_a); | 719 sk_sp<SkImage> image = CreateImageWithColorSpace(100, 100, color_space_a); |
717 DrawImage first_draw_image( | 720 DrawImage first_draw_image( |
718 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 721 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
719 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), color_space_b); | 722 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
| 723 color_space_b); |
720 scoped_refptr<TileTask> first_task; | 724 scoped_refptr<TileTask> first_task; |
721 bool need_unref = cache.GetTaskForImageAndRef( | 725 bool need_unref = cache.GetTaskForImageAndRef( |
722 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); | 726 first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
723 EXPECT_TRUE(need_unref); | 727 EXPECT_TRUE(need_unref); |
724 EXPECT_TRUE(first_task); | 728 EXPECT_TRUE(first_task); |
725 | 729 |
726 DrawImage second_draw_image( | 730 DrawImage second_draw_image( |
727 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 731 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
728 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), color_space_c); | 732 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
| 733 color_space_c); |
729 scoped_refptr<TileTask> second_task; | 734 scoped_refptr<TileTask> second_task; |
730 need_unref = cache.GetTaskForImageAndRef( | 735 need_unref = cache.GetTaskForImageAndRef( |
731 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); | 736 second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
732 EXPECT_TRUE(need_unref); | 737 EXPECT_TRUE(need_unref); |
733 EXPECT_TRUE(second_task); | 738 EXPECT_TRUE(second_task); |
734 EXPECT_TRUE(first_task.get() != second_task.get()); | 739 EXPECT_TRUE(first_task.get() != second_task.get()); |
735 | 740 |
736 DrawImage third_draw_image( | 741 DrawImage third_draw_image( |
737 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 742 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
738 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), color_space_b); | 743 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
| 744 color_space_b); |
739 scoped_refptr<TileTask> third_task; | 745 scoped_refptr<TileTask> third_task; |
740 need_unref = cache.GetTaskForImageAndRef( | 746 need_unref = cache.GetTaskForImageAndRef( |
741 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); | 747 third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
742 EXPECT_TRUE(need_unref); | 748 EXPECT_TRUE(need_unref); |
743 EXPECT_TRUE(third_task); | 749 EXPECT_TRUE(third_task); |
744 EXPECT_TRUE(first_task.get() == third_task.get()); | 750 EXPECT_TRUE(first_task.get() == third_task.get()); |
745 | 751 |
746 TestTileTaskRunner::ProcessTask(first_task.get()); | 752 TestTileTaskRunner::ProcessTask(first_task.get()); |
747 TestTileTaskRunner::ProcessTask(second_task.get()); | 753 TestTileTaskRunner::ProcessTask(second_task.get()); |
748 | 754 |
749 cache.UnrefImage(first_draw_image); | 755 cache.UnrefImage(first_draw_image); |
750 cache.UnrefImage(second_draw_image); | 756 cache.UnrefImage(second_draw_image); |
751 cache.UnrefImage(third_draw_image); | 757 cache.UnrefImage(third_draw_image); |
752 } | 758 } |
753 | 759 |
754 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyDecoded) { | 760 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyDecoded) { |
755 TestSoftwareImageDecodeCache cache; | 761 TestSoftwareImageDecodeCache cache; |
756 bool is_decomposable = true; | 762 bool is_decomposable = true; |
757 SkFilterQuality quality = kHigh_SkFilterQuality; | 763 SkFilterQuality quality = kHigh_SkFilterQuality; |
758 | 764 |
759 sk_sp<SkImage> image = CreateImage(100, 100); | 765 sk_sp<SkImage> image = CreateImage(100, 100); |
760 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 766 DrawImage draw_image( |
761 quality, | 767 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
762 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 768 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
763 DefaultColorSpace()); | 769 DefaultColorSpace()); |
764 scoped_refptr<TileTask> task; | 770 scoped_refptr<TileTask> task; |
765 bool need_unref = cache.GetTaskForImageAndRef( | 771 bool need_unref = cache.GetTaskForImageAndRef( |
766 draw_image, ImageDecodeCache::TracingInfo(), &task); | 772 draw_image, ImageDecodeCache::TracingInfo(), &task); |
767 EXPECT_TRUE(need_unref); | 773 EXPECT_TRUE(need_unref); |
768 EXPECT_TRUE(task); | 774 EXPECT_TRUE(task); |
769 | 775 |
770 TestTileTaskRunner::ScheduleTask(task.get()); | 776 TestTileTaskRunner::ScheduleTask(task.get()); |
771 TestTileTaskRunner::RunTask(task.get()); | 777 TestTileTaskRunner::RunTask(task.get()); |
772 | 778 |
773 scoped_refptr<TileTask> another_task; | 779 scoped_refptr<TileTask> another_task; |
774 need_unref = cache.GetTaskForImageAndRef( | 780 need_unref = cache.GetTaskForImageAndRef( |
775 draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 781 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
776 EXPECT_TRUE(need_unref); | 782 EXPECT_TRUE(need_unref); |
777 EXPECT_FALSE(another_task); | 783 EXPECT_FALSE(another_task); |
778 | 784 |
779 TestTileTaskRunner::CompleteTask(task.get()); | 785 TestTileTaskRunner::CompleteTask(task.get()); |
780 | 786 |
781 cache.UnrefImage(draw_image); | 787 cache.UnrefImage(draw_image); |
782 cache.UnrefImage(draw_image); | 788 cache.UnrefImage(draw_image); |
783 } | 789 } |
784 | 790 |
785 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyPrerolled) { | 791 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyPrerolled) { |
786 TestSoftwareImageDecodeCache cache; | 792 TestSoftwareImageDecodeCache cache; |
787 bool is_decomposable = true; | 793 bool is_decomposable = true; |
788 SkFilterQuality quality = kLow_SkFilterQuality; | 794 SkFilterQuality quality = kLow_SkFilterQuality; |
789 | 795 |
790 sk_sp<SkImage> image = CreateImage(100, 100); | 796 sk_sp<SkImage> image = CreateImage(100, 100); |
791 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 797 DrawImage draw_image( |
792 quality, | 798 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
793 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 799 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
794 DefaultColorSpace()); | 800 DefaultColorSpace()); |
795 scoped_refptr<TileTask> task; | 801 scoped_refptr<TileTask> task; |
796 bool need_unref = cache.GetTaskForImageAndRef( | 802 bool need_unref = cache.GetTaskForImageAndRef( |
797 draw_image, ImageDecodeCache::TracingInfo(), &task); | 803 draw_image, ImageDecodeCache::TracingInfo(), &task); |
798 EXPECT_TRUE(need_unref); | 804 EXPECT_TRUE(need_unref); |
799 EXPECT_TRUE(task); | 805 EXPECT_TRUE(task); |
800 | 806 |
801 TestTileTaskRunner::ScheduleTask(task.get()); | 807 TestTileTaskRunner::ScheduleTask(task.get()); |
802 TestTileTaskRunner::RunTask(task.get()); | 808 TestTileTaskRunner::RunTask(task.get()); |
803 | 809 |
804 scoped_refptr<TileTask> another_task; | 810 scoped_refptr<TileTask> another_task; |
(...skipping 14 matching lines...) Expand all Loading... |
819 cache.UnrefImage(draw_image); | 825 cache.UnrefImage(draw_image); |
820 cache.UnrefImage(draw_image); | 826 cache.UnrefImage(draw_image); |
821 } | 827 } |
822 | 828 |
823 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) { | 829 TEST(SoftwareImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) { |
824 TestSoftwareImageDecodeCache cache; | 830 TestSoftwareImageDecodeCache cache; |
825 bool is_decomposable = true; | 831 bool is_decomposable = true; |
826 SkFilterQuality quality = kHigh_SkFilterQuality; | 832 SkFilterQuality quality = kHigh_SkFilterQuality; |
827 | 833 |
828 sk_sp<SkImage> image = CreateImage(100, 100); | 834 sk_sp<SkImage> image = CreateImage(100, 100); |
829 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 835 DrawImage draw_image( |
830 quality, | 836 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
831 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 837 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
832 DefaultColorSpace()); | 838 DefaultColorSpace()); |
833 scoped_refptr<TileTask> task; | 839 scoped_refptr<TileTask> task; |
834 bool need_unref = cache.GetTaskForImageAndRef( | 840 bool need_unref = cache.GetTaskForImageAndRef( |
835 draw_image, ImageDecodeCache::TracingInfo(), &task); | 841 draw_image, ImageDecodeCache::TracingInfo(), &task); |
836 EXPECT_TRUE(need_unref); | 842 EXPECT_TRUE(need_unref); |
837 EXPECT_TRUE(task); | 843 EXPECT_TRUE(task); |
838 | 844 |
839 scoped_refptr<TileTask> another_task; | 845 scoped_refptr<TileTask> another_task; |
840 need_unref = cache.GetTaskForImageAndRef( | 846 need_unref = cache.GetTaskForImageAndRef( |
841 draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 847 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
842 EXPECT_TRUE(need_unref); | 848 EXPECT_TRUE(need_unref); |
(...skipping 20 matching lines...) Expand all Loading... |
863 cache.UnrefImage(draw_image); | 869 cache.UnrefImage(draw_image); |
864 } | 870 } |
865 | 871 |
866 TEST(SoftwareImageDecodeCacheTest, | 872 TEST(SoftwareImageDecodeCacheTest, |
867 GetTaskForImageCanceledWhileReffedGetsNewTask) { | 873 GetTaskForImageCanceledWhileReffedGetsNewTask) { |
868 TestSoftwareImageDecodeCache cache; | 874 TestSoftwareImageDecodeCache cache; |
869 bool is_decomposable = true; | 875 bool is_decomposable = true; |
870 SkFilterQuality quality = kHigh_SkFilterQuality; | 876 SkFilterQuality quality = kHigh_SkFilterQuality; |
871 | 877 |
872 sk_sp<SkImage> image = CreateImage(100, 100); | 878 sk_sp<SkImage> image = CreateImage(100, 100); |
873 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 879 DrawImage draw_image( |
874 quality, | 880 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
875 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 881 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
876 DefaultColorSpace()); | 882 DefaultColorSpace()); |
877 scoped_refptr<TileTask> task; | 883 scoped_refptr<TileTask> task; |
878 bool need_unref = cache.GetTaskForImageAndRef( | 884 bool need_unref = cache.GetTaskForImageAndRef( |
879 draw_image, ImageDecodeCache::TracingInfo(), &task); | 885 draw_image, ImageDecodeCache::TracingInfo(), &task); |
880 EXPECT_TRUE(need_unref); | 886 EXPECT_TRUE(need_unref); |
881 EXPECT_TRUE(task); | 887 EXPECT_TRUE(task); |
882 | 888 |
883 scoped_refptr<TileTask> another_task; | 889 scoped_refptr<TileTask> another_task; |
884 need_unref = cache.GetTaskForImageAndRef( | 890 need_unref = cache.GetTaskForImageAndRef( |
885 draw_image, ImageDecodeCache::TracingInfo(), &another_task); | 891 draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
886 EXPECT_TRUE(need_unref); | 892 EXPECT_TRUE(need_unref); |
(...skipping 19 matching lines...) Expand all Loading... |
906 cache.UnrefImage(draw_image); | 912 cache.UnrefImage(draw_image); |
907 cache.UnrefImage(draw_image); | 913 cache.UnrefImage(draw_image); |
908 } | 914 } |
909 | 915 |
910 TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDraw) { | 916 TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDraw) { |
911 TestSoftwareImageDecodeCache cache; | 917 TestSoftwareImageDecodeCache cache; |
912 bool is_decomposable = true; | 918 bool is_decomposable = true; |
913 SkFilterQuality quality = kHigh_SkFilterQuality; | 919 SkFilterQuality quality = kHigh_SkFilterQuality; |
914 | 920 |
915 sk_sp<SkImage> image = CreateImage(100, 100); | 921 sk_sp<SkImage> image = CreateImage(100, 100); |
916 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 922 DrawImage draw_image( |
917 quality, | 923 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
918 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 924 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
919 DefaultColorSpace()); | 925 DefaultColorSpace()); |
920 scoped_refptr<TileTask> task; | 926 scoped_refptr<TileTask> task; |
921 bool need_unref = cache.GetTaskForImageAndRef( | 927 bool need_unref = cache.GetTaskForImageAndRef( |
922 draw_image, ImageDecodeCache::TracingInfo(), &task); | 928 draw_image, ImageDecodeCache::TracingInfo(), &task); |
923 EXPECT_TRUE(need_unref); | 929 EXPECT_TRUE(need_unref); |
924 EXPECT_TRUE(task); | 930 EXPECT_TRUE(task); |
925 | 931 |
926 TestTileTaskRunner::ProcessTask(task.get()); | 932 TestTileTaskRunner::ProcessTask(task.get()); |
927 | 933 |
928 DecodedDrawImage decoded_draw_image = | 934 DecodedDrawImage decoded_draw_image = |
929 cache.GetDecodedImageForDraw(draw_image); | 935 cache.GetDecodedImageForDraw(draw_image); |
(...skipping 11 matching lines...) Expand all Loading... |
941 } | 947 } |
942 | 948 |
943 TEST(SoftwareImageDecodeCacheTest, | 949 TEST(SoftwareImageDecodeCacheTest, |
944 GetDecodedImageForDrawWithNonContainedSrcRect) { | 950 GetDecodedImageForDrawWithNonContainedSrcRect) { |
945 TestSoftwareImageDecodeCache cache; | 951 TestSoftwareImageDecodeCache cache; |
946 bool is_decomposable = true; | 952 bool is_decomposable = true; |
947 SkFilterQuality quality = kHigh_SkFilterQuality; | 953 SkFilterQuality quality = kHigh_SkFilterQuality; |
948 | 954 |
949 sk_sp<SkImage> image = CreateImage(100, 100); | 955 sk_sp<SkImage> image = CreateImage(100, 100); |
950 DrawImage draw_image( | 956 DrawImage draw_image( |
951 image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 957 PaintImage(image), |
952 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 958 SkIRect::MakeXYWH(20, 30, image->width(), image->height()), quality, |
| 959 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
953 DefaultColorSpace()); | 960 DefaultColorSpace()); |
954 scoped_refptr<TileTask> task; | 961 scoped_refptr<TileTask> task; |
955 bool need_unref = cache.GetTaskForImageAndRef( | 962 bool need_unref = cache.GetTaskForImageAndRef( |
956 draw_image, ImageDecodeCache::TracingInfo(), &task); | 963 draw_image, ImageDecodeCache::TracingInfo(), &task); |
957 EXPECT_TRUE(need_unref); | 964 EXPECT_TRUE(need_unref); |
958 EXPECT_TRUE(task); | 965 EXPECT_TRUE(task); |
959 | 966 |
960 TestTileTaskRunner::ProcessTask(task.get()); | 967 TestTileTaskRunner::ProcessTask(task.get()); |
961 | 968 |
962 DecodedDrawImage decoded_draw_image = | 969 DecodedDrawImage decoded_draw_image = |
(...skipping 10 matching lines...) Expand all Loading... |
973 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 980 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
974 cache.UnrefImage(draw_image); | 981 cache.UnrefImage(draw_image); |
975 } | 982 } |
976 | 983 |
977 TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) { | 984 TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) { |
978 TestSoftwareImageDecodeCache cache; | 985 TestSoftwareImageDecodeCache cache; |
979 bool is_decomposable = true; | 986 bool is_decomposable = true; |
980 SkFilterQuality quality = kHigh_SkFilterQuality; | 987 SkFilterQuality quality = kHigh_SkFilterQuality; |
981 | 988 |
982 sk_sp<SkImage> image = CreateImage(100, 100); | 989 sk_sp<SkImage> image = CreateImage(100, 100); |
983 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 990 DrawImage draw_image( |
984 quality, | 991 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
985 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 992 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
986 DefaultColorSpace()); | 993 DefaultColorSpace()); |
987 | 994 |
988 DecodedDrawImage decoded_draw_image = | 995 DecodedDrawImage decoded_draw_image = |
989 cache.GetDecodedImageForDraw(draw_image); | 996 cache.GetDecodedImageForDraw(draw_image); |
990 EXPECT_TRUE(decoded_draw_image.image()); | 997 EXPECT_TRUE(decoded_draw_image.image()); |
991 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 998 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
992 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 999 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
993 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 1000 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
994 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 1001 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
995 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1002 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
996 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 1003 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
997 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 1004 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
998 | 1005 |
999 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1006 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1000 } | 1007 } |
1001 | 1008 |
1002 TEST(SoftwareImageDecodeCacheTest, | 1009 TEST(SoftwareImageDecodeCacheTest, |
1003 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { | 1010 GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
1004 TestSoftwareImageDecodeCache cache; | 1011 TestSoftwareImageDecodeCache cache; |
1005 bool is_decomposable = true; | 1012 bool is_decomposable = true; |
1006 SkFilterQuality quality = kHigh_SkFilterQuality; | 1013 SkFilterQuality quality = kHigh_SkFilterQuality; |
1007 | 1014 |
1008 sk_sp<SkImage> image = CreateImage(100, 100); | 1015 sk_sp<SkImage> image = CreateImage(100, 100); |
1009 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1016 DrawImage draw_image( |
1010 quality, | 1017 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1011 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1018 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1012 DefaultColorSpace()); | 1019 DefaultColorSpace()); |
1013 | 1020 |
1014 DecodedDrawImage decoded_draw_image = | 1021 DecodedDrawImage decoded_draw_image = |
1015 cache.GetDecodedImageForDraw(draw_image); | 1022 cache.GetDecodedImageForDraw(draw_image); |
1016 EXPECT_TRUE(decoded_draw_image.image()); | 1023 EXPECT_TRUE(decoded_draw_image.image()); |
1017 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 1024 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
1018 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 1025 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
1019 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 1026 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
1020 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 1027 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
1021 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1028 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1022 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 1029 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
1023 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 1030 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
1024 | 1031 |
1025 DecodedDrawImage another_decoded_draw_image = | 1032 DecodedDrawImage another_decoded_draw_image = |
1026 cache.GetDecodedImageForDraw(draw_image); | 1033 cache.GetDecodedImageForDraw(draw_image); |
1027 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), | 1034 EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
1028 another_decoded_draw_image.image()->uniqueID()); | 1035 another_decoded_draw_image.image()->uniqueID()); |
1029 | 1036 |
1030 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1037 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1031 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 1038 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
1032 } | 1039 } |
1033 | 1040 |
1034 TEST(SoftwareImageDecodeCacheTest, | 1041 TEST(SoftwareImageDecodeCacheTest, |
1035 GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) { | 1042 GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) { |
1036 TestSoftwareImageDecodeCache cache; | 1043 TestSoftwareImageDecodeCache cache; |
1037 bool is_decomposable = true; | 1044 bool is_decomposable = true; |
1038 SkFilterQuality quality = kHigh_SkFilterQuality; | 1045 SkFilterQuality quality = kHigh_SkFilterQuality; |
1039 | 1046 |
1040 sk_sp<SkImage> image = CreateImage(100, 100); | 1047 sk_sp<SkImage> image = CreateImage(100, 100); |
1041 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1048 DrawImage draw_image( |
1042 quality, | 1049 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1043 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1050 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1044 DefaultColorSpace()); | 1051 DefaultColorSpace()); |
1045 | 1052 |
1046 DecodedDrawImage decoded_draw_image = | 1053 DecodedDrawImage decoded_draw_image = |
1047 cache.GetDecodedImageForDraw(draw_image); | 1054 cache.GetDecodedImageForDraw(draw_image); |
1048 EXPECT_TRUE(decoded_draw_image.image()); | 1055 EXPECT_TRUE(decoded_draw_image.image()); |
1049 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 1056 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
1050 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 1057 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
1051 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 1058 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
1052 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 1059 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
1053 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1060 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1054 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 1061 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
(...skipping 22 matching lines...) Expand all Loading... |
1077 cache.UnrefImage(draw_image); | 1084 cache.UnrefImage(draw_image); |
1078 } | 1085 } |
1079 | 1086 |
1080 TEST(SoftwareImageDecodeCacheTest, | 1087 TEST(SoftwareImageDecodeCacheTest, |
1081 GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) { | 1088 GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) { |
1082 TestSoftwareImageDecodeCache cache; | 1089 TestSoftwareImageDecodeCache cache; |
1083 bool is_decomposable = true; | 1090 bool is_decomposable = true; |
1084 SkFilterQuality quality = kHigh_SkFilterQuality; | 1091 SkFilterQuality quality = kHigh_SkFilterQuality; |
1085 | 1092 |
1086 sk_sp<SkImage> image = CreateImage(100, 100); | 1093 sk_sp<SkImage> image = CreateImage(100, 100); |
1087 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1094 DrawImage draw_image( |
1088 quality, | 1095 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1089 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1096 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1090 DefaultColorSpace()); | 1097 DefaultColorSpace()); |
1091 | 1098 |
1092 DecodedDrawImage decoded_draw_image = | 1099 DecodedDrawImage decoded_draw_image = |
1093 cache.GetDecodedImageForDraw(draw_image); | 1100 cache.GetDecodedImageForDraw(draw_image); |
1094 EXPECT_TRUE(decoded_draw_image.image()); | 1101 EXPECT_TRUE(decoded_draw_image.image()); |
1095 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 1102 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
1096 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 1103 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
1097 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 1104 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
1098 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 1105 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
1099 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1106 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1100 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 1107 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
(...skipping 22 matching lines...) Expand all Loading... |
1123 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); | 1130 cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
1124 cache.UnrefImage(draw_image); | 1131 cache.UnrefImage(draw_image); |
1125 } | 1132 } |
1126 | 1133 |
1127 TEST(SoftwareImageDecodeCacheTest, ZeroSizedImagesAreSkipped) { | 1134 TEST(SoftwareImageDecodeCacheTest, ZeroSizedImagesAreSkipped) { |
1128 TestSoftwareImageDecodeCache cache; | 1135 TestSoftwareImageDecodeCache cache; |
1129 bool is_decomposable = true; | 1136 bool is_decomposable = true; |
1130 SkFilterQuality quality = kHigh_SkFilterQuality; | 1137 SkFilterQuality quality = kHigh_SkFilterQuality; |
1131 | 1138 |
1132 sk_sp<SkImage> image = CreateImage(100, 100); | 1139 sk_sp<SkImage> image = CreateImage(100, 100); |
1133 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1140 DrawImage draw_image( |
1134 quality, | 1141 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1135 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable), | 1142 quality, CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable), |
1136 DefaultColorSpace()); | 1143 DefaultColorSpace()); |
1137 | 1144 |
1138 scoped_refptr<TileTask> task; | 1145 scoped_refptr<TileTask> task; |
1139 bool need_unref = cache.GetTaskForImageAndRef( | 1146 bool need_unref = cache.GetTaskForImageAndRef( |
1140 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1147 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1141 EXPECT_FALSE(task); | 1148 EXPECT_FALSE(task); |
1142 EXPECT_FALSE(need_unref); | 1149 EXPECT_FALSE(need_unref); |
1143 | 1150 |
1144 DecodedDrawImage decoded_draw_image = | 1151 DecodedDrawImage decoded_draw_image = |
1145 cache.GetDecodedImageForDraw(draw_image); | 1152 cache.GetDecodedImageForDraw(draw_image); |
1146 EXPECT_FALSE(decoded_draw_image.image()); | 1153 EXPECT_FALSE(decoded_draw_image.image()); |
1147 | 1154 |
1148 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1155 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1149 } | 1156 } |
1150 | 1157 |
1151 TEST(SoftwareImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) { | 1158 TEST(SoftwareImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) { |
1152 TestSoftwareImageDecodeCache cache; | 1159 TestSoftwareImageDecodeCache cache; |
1153 bool is_decomposable = true; | 1160 bool is_decomposable = true; |
1154 SkFilterQuality quality = kHigh_SkFilterQuality; | 1161 SkFilterQuality quality = kHigh_SkFilterQuality; |
1155 | 1162 |
1156 sk_sp<SkImage> image = CreateImage(100, 100); | 1163 sk_sp<SkImage> image = CreateImage(100, 100); |
1157 DrawImage draw_image( | 1164 DrawImage draw_image( |
1158 image, SkIRect::MakeXYWH(150, 150, image->width(), image->height()), | 1165 PaintImage(image), |
1159 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 1166 SkIRect::MakeXYWH(150, 150, image->width(), image->height()), quality, |
| 1167 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
1160 DefaultColorSpace()); | 1168 DefaultColorSpace()); |
1161 | 1169 |
1162 scoped_refptr<TileTask> task; | 1170 scoped_refptr<TileTask> task; |
1163 bool need_unref = cache.GetTaskForImageAndRef( | 1171 bool need_unref = cache.GetTaskForImageAndRef( |
1164 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1172 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1165 EXPECT_FALSE(task); | 1173 EXPECT_FALSE(task); |
1166 EXPECT_FALSE(need_unref); | 1174 EXPECT_FALSE(need_unref); |
1167 | 1175 |
1168 DecodedDrawImage decoded_draw_image = | 1176 DecodedDrawImage decoded_draw_image = |
1169 cache.GetDecodedImageForDraw(draw_image); | 1177 cache.GetDecodedImageForDraw(draw_image); |
1170 EXPECT_FALSE(decoded_draw_image.image()); | 1178 EXPECT_FALSE(decoded_draw_image.image()); |
1171 | 1179 |
1172 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1180 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1173 } | 1181 } |
1174 | 1182 |
1175 TEST(SoftwareImageDecodeCacheTest, LowQualityFilterIsHandled) { | 1183 TEST(SoftwareImageDecodeCacheTest, LowQualityFilterIsHandled) { |
1176 TestSoftwareImageDecodeCache cache; | 1184 TestSoftwareImageDecodeCache cache; |
1177 bool is_decomposable = true; | 1185 bool is_decomposable = true; |
1178 SkFilterQuality quality = kLow_SkFilterQuality; | 1186 SkFilterQuality quality = kLow_SkFilterQuality; |
1179 | 1187 |
1180 sk_sp<SkImage> image = CreateImage(100, 100); | 1188 sk_sp<SkImage> image = CreateImage(100, 100); |
1181 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1189 DrawImage draw_image( |
1182 quality, | 1190 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1183 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 1191 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
1184 DefaultColorSpace()); | 1192 DefaultColorSpace()); |
1185 | 1193 |
1186 scoped_refptr<TileTask> task; | 1194 scoped_refptr<TileTask> task; |
1187 bool need_unref = cache.GetTaskForImageAndRef( | 1195 bool need_unref = cache.GetTaskForImageAndRef( |
1188 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1196 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1189 EXPECT_TRUE(task); | 1197 EXPECT_TRUE(task); |
1190 EXPECT_TRUE(need_unref); | 1198 EXPECT_TRUE(need_unref); |
1191 | 1199 |
1192 TestTileTaskRunner::ProcessTask(task.get()); | 1200 TestTileTaskRunner::ProcessTask(task.get()); |
1193 | 1201 |
1194 DecodedDrawImage decoded_draw_image = | 1202 DecodedDrawImage decoded_draw_image = |
1195 cache.GetDecodedImageForDraw(draw_image); | 1203 cache.GetDecodedImageForDraw(draw_image); |
1196 EXPECT_TRUE(decoded_draw_image.image()); | 1204 EXPECT_TRUE(decoded_draw_image.image()); |
1197 // If we decoded the image and cached it, it would be stored in a different | 1205 // If we decoded the image and cached it, it would be stored in a different |
1198 // SkImage object. | 1206 // SkImage object. |
1199 EXPECT_TRUE(decoded_draw_image.image() != image); | 1207 EXPECT_TRUE(decoded_draw_image.image() != image); |
1200 | 1208 |
1201 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1209 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1202 cache.UnrefImage(draw_image); | 1210 cache.UnrefImage(draw_image); |
1203 } | 1211 } |
1204 | 1212 |
1205 TEST(SoftwareImageDecodeCacheTest, LowQualityScaledSubrectIsHandled) { | 1213 TEST(SoftwareImageDecodeCacheTest, LowQualityScaledSubrectIsHandled) { |
1206 TestSoftwareImageDecodeCache cache; | 1214 TestSoftwareImageDecodeCache cache; |
1207 bool is_decomposable = true; | 1215 bool is_decomposable = true; |
1208 SkFilterQuality quality = kLow_SkFilterQuality; | 1216 SkFilterQuality quality = kLow_SkFilterQuality; |
1209 | 1217 |
1210 sk_sp<SkImage> image = CreateImage(100, 100); | 1218 sk_sp<SkImage> image = CreateImage(100, 100); |
1211 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1219 DrawImage draw_image(PaintImage(image), SkIRect::MakeXYWH(10, 10, 80, 80), |
| 1220 quality, |
1212 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1221 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1213 DefaultColorSpace()); | 1222 DefaultColorSpace()); |
1214 | 1223 |
1215 scoped_refptr<TileTask> task; | 1224 scoped_refptr<TileTask> task; |
1216 bool need_unref = cache.GetTaskForImageAndRef( | 1225 bool need_unref = cache.GetTaskForImageAndRef( |
1217 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1226 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1218 EXPECT_TRUE(task); | 1227 EXPECT_TRUE(task); |
1219 EXPECT_TRUE(need_unref); | 1228 EXPECT_TRUE(need_unref); |
1220 | 1229 |
1221 TestTileTaskRunner::ProcessTask(task.get()); | 1230 TestTileTaskRunner::ProcessTask(task.get()); |
(...skipping 10 matching lines...) Expand all Loading... |
1232 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1241 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1233 cache.UnrefImage(draw_image); | 1242 cache.UnrefImage(draw_image); |
1234 } | 1243 } |
1235 | 1244 |
1236 TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) { | 1245 TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) { |
1237 TestSoftwareImageDecodeCache cache; | 1246 TestSoftwareImageDecodeCache cache; |
1238 bool is_decomposable = true; | 1247 bool is_decomposable = true; |
1239 SkFilterQuality quality = kNone_SkFilterQuality; | 1248 SkFilterQuality quality = kNone_SkFilterQuality; |
1240 | 1249 |
1241 sk_sp<SkImage> image = CreateImage(100, 100); | 1250 sk_sp<SkImage> image = CreateImage(100, 100); |
1242 DrawImage draw_image(image, SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1251 DrawImage draw_image(PaintImage(image), SkIRect::MakeXYWH(10, 10, 80, 80), |
| 1252 quality, |
1243 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1253 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1244 DefaultColorSpace()); | 1254 DefaultColorSpace()); |
1245 | 1255 |
1246 scoped_refptr<TileTask> task; | 1256 scoped_refptr<TileTask> task; |
1247 bool need_unref = cache.GetTaskForImageAndRef( | 1257 bool need_unref = cache.GetTaskForImageAndRef( |
1248 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1258 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1249 EXPECT_TRUE(task); | 1259 EXPECT_TRUE(task); |
1250 EXPECT_TRUE(need_unref); | 1260 EXPECT_TRUE(need_unref); |
1251 | 1261 |
1252 TestTileTaskRunner::ProcessTask(task.get()); | 1262 TestTileTaskRunner::ProcessTask(task.get()); |
(...skipping 10 matching lines...) Expand all Loading... |
1263 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1273 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1264 cache.UnrefImage(draw_image); | 1274 cache.UnrefImage(draw_image); |
1265 } | 1275 } |
1266 | 1276 |
1267 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt01_5ScaleIsHandled) { | 1277 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt01_5ScaleIsHandled) { |
1268 TestSoftwareImageDecodeCache cache; | 1278 TestSoftwareImageDecodeCache cache; |
1269 bool is_decomposable = true; | 1279 bool is_decomposable = true; |
1270 SkFilterQuality quality = kMedium_SkFilterQuality; | 1280 SkFilterQuality quality = kMedium_SkFilterQuality; |
1271 | 1281 |
1272 sk_sp<SkImage> image = CreateImage(500, 200); | 1282 sk_sp<SkImage> image = CreateImage(500, 200); |
1273 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1283 DrawImage draw_image( |
1274 quality, | 1284 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1275 CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), | 1285 quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable), |
1276 DefaultColorSpace()); | 1286 DefaultColorSpace()); |
1277 | 1287 |
1278 scoped_refptr<TileTask> task; | 1288 scoped_refptr<TileTask> task; |
1279 bool need_unref = cache.GetTaskForImageAndRef( | 1289 bool need_unref = cache.GetTaskForImageAndRef( |
1280 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1290 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1281 EXPECT_TRUE(task); | 1291 EXPECT_TRUE(task); |
1282 EXPECT_TRUE(need_unref); | 1292 EXPECT_TRUE(need_unref); |
1283 | 1293 |
1284 TestTileTaskRunner::ProcessTask(task.get()); | 1294 TestTileTaskRunner::ProcessTask(task.get()); |
1285 | 1295 |
1286 DecodedDrawImage decoded_draw_image = | 1296 DecodedDrawImage decoded_draw_image = |
1287 cache.GetDecodedImageForDraw(draw_image); | 1297 cache.GetDecodedImageForDraw(draw_image); |
1288 EXPECT_TRUE(decoded_draw_image.image()); | 1298 EXPECT_TRUE(decoded_draw_image.image()); |
1289 // If we decoded the image and cached it, it would be stored in a different | 1299 // If we decoded the image and cached it, it would be stored in a different |
1290 // SkImageObject. | 1300 // SkImageObject. |
1291 EXPECT_TRUE(decoded_draw_image.image() != image); | 1301 EXPECT_TRUE(decoded_draw_image.image() != image); |
1292 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1302 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1293 EXPECT_EQ(500, decoded_draw_image.image()->width()); | 1303 EXPECT_EQ(500, decoded_draw_image.image()->width()); |
1294 EXPECT_EQ(200, decoded_draw_image.image()->height()); | 1304 EXPECT_EQ(200, decoded_draw_image.image()->height()); |
1295 | 1305 |
1296 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1306 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1297 cache.UnrefImage(draw_image); | 1307 cache.UnrefImage(draw_image); |
1298 } | 1308 } |
1299 | 1309 |
1300 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt1_0ScaleIsHandled) { | 1310 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt1_0ScaleIsHandled) { |
1301 TestSoftwareImageDecodeCache cache; | 1311 TestSoftwareImageDecodeCache cache; |
1302 bool is_decomposable = true; | 1312 bool is_decomposable = true; |
1303 SkFilterQuality quality = kMedium_SkFilterQuality; | 1313 SkFilterQuality quality = kMedium_SkFilterQuality; |
1304 | 1314 |
1305 sk_sp<SkImage> image = CreateImage(500, 200); | 1315 sk_sp<SkImage> image = CreateImage(500, 200); |
1306 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1316 DrawImage draw_image( |
1307 quality, | 1317 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1308 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), | 1318 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable), |
1309 DefaultColorSpace()); | 1319 DefaultColorSpace()); |
1310 | 1320 |
1311 scoped_refptr<TileTask> task; | 1321 scoped_refptr<TileTask> task; |
1312 bool need_unref = cache.GetTaskForImageAndRef( | 1322 bool need_unref = cache.GetTaskForImageAndRef( |
1313 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1323 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1314 EXPECT_TRUE(task); | 1324 EXPECT_TRUE(task); |
1315 EXPECT_TRUE(need_unref); | 1325 EXPECT_TRUE(need_unref); |
1316 | 1326 |
1317 TestTileTaskRunner::ProcessTask(task.get()); | 1327 TestTileTaskRunner::ProcessTask(task.get()); |
1318 | 1328 |
1319 DecodedDrawImage decoded_draw_image = | 1329 DecodedDrawImage decoded_draw_image = |
(...skipping 10 matching lines...) Expand all Loading... |
1330 cache.UnrefImage(draw_image); | 1340 cache.UnrefImage(draw_image); |
1331 } | 1341 } |
1332 | 1342 |
1333 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_75ScaleIsHandled) { | 1343 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_75ScaleIsHandled) { |
1334 TestSoftwareImageDecodeCache cache; | 1344 TestSoftwareImageDecodeCache cache; |
1335 bool is_decomposable = true; | 1345 bool is_decomposable = true; |
1336 SkFilterQuality quality = kMedium_SkFilterQuality; | 1346 SkFilterQuality quality = kMedium_SkFilterQuality; |
1337 | 1347 |
1338 sk_sp<SkImage> image = CreateImage(500, 200); | 1348 sk_sp<SkImage> image = CreateImage(500, 200); |
1339 DrawImage draw_image( | 1349 DrawImage draw_image( |
1340 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1350 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1341 CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable), | 1351 quality, CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable), |
1342 DefaultColorSpace()); | 1352 DefaultColorSpace()); |
1343 | 1353 |
1344 scoped_refptr<TileTask> task; | 1354 scoped_refptr<TileTask> task; |
1345 bool need_unref = cache.GetTaskForImageAndRef( | 1355 bool need_unref = cache.GetTaskForImageAndRef( |
1346 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1356 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1347 EXPECT_TRUE(task); | 1357 EXPECT_TRUE(task); |
1348 EXPECT_TRUE(need_unref); | 1358 EXPECT_TRUE(need_unref); |
1349 | 1359 |
1350 TestTileTaskRunner::ProcessTask(task.get()); | 1360 TestTileTaskRunner::ProcessTask(task.get()); |
1351 | 1361 |
(...skipping 10 matching lines...) Expand all Loading... |
1362 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1372 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1363 cache.UnrefImage(draw_image); | 1373 cache.UnrefImage(draw_image); |
1364 } | 1374 } |
1365 | 1375 |
1366 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_5ScaleIsHandled) { | 1376 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_5ScaleIsHandled) { |
1367 TestSoftwareImageDecodeCache cache; | 1377 TestSoftwareImageDecodeCache cache; |
1368 bool is_decomposable = true; | 1378 bool is_decomposable = true; |
1369 SkFilterQuality quality = kMedium_SkFilterQuality; | 1379 SkFilterQuality quality = kMedium_SkFilterQuality; |
1370 | 1380 |
1371 sk_sp<SkImage> image = CreateImage(500, 200); | 1381 sk_sp<SkImage> image = CreateImage(500, 200); |
1372 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1382 DrawImage draw_image( |
1373 quality, | 1383 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1374 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1384 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1375 DefaultColorSpace()); | 1385 DefaultColorSpace()); |
1376 | 1386 |
1377 scoped_refptr<TileTask> task; | 1387 scoped_refptr<TileTask> task; |
1378 bool need_unref = cache.GetTaskForImageAndRef( | 1388 bool need_unref = cache.GetTaskForImageAndRef( |
1379 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1389 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1380 EXPECT_TRUE(task); | 1390 EXPECT_TRUE(task); |
1381 EXPECT_TRUE(need_unref); | 1391 EXPECT_TRUE(need_unref); |
1382 | 1392 |
1383 TestTileTaskRunner::ProcessTask(task.get()); | 1393 TestTileTaskRunner::ProcessTask(task.get()); |
1384 | 1394 |
1385 DecodedDrawImage decoded_draw_image = | 1395 DecodedDrawImage decoded_draw_image = |
(...skipping 10 matching lines...) Expand all Loading... |
1396 cache.UnrefImage(draw_image); | 1406 cache.UnrefImage(draw_image); |
1397 } | 1407 } |
1398 | 1408 |
1399 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_49ScaleIsHandled) { | 1409 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_49ScaleIsHandled) { |
1400 TestSoftwareImageDecodeCache cache; | 1410 TestSoftwareImageDecodeCache cache; |
1401 bool is_decomposable = true; | 1411 bool is_decomposable = true; |
1402 SkFilterQuality quality = kMedium_SkFilterQuality; | 1412 SkFilterQuality quality = kMedium_SkFilterQuality; |
1403 | 1413 |
1404 sk_sp<SkImage> image = CreateImage(500, 200); | 1414 sk_sp<SkImage> image = CreateImage(500, 200); |
1405 DrawImage draw_image( | 1415 DrawImage draw_image( |
1406 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1416 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1407 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable), | 1417 quality, CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable), |
1408 DefaultColorSpace()); | 1418 DefaultColorSpace()); |
1409 | 1419 |
1410 scoped_refptr<TileTask> task; | 1420 scoped_refptr<TileTask> task; |
1411 bool need_unref = cache.GetTaskForImageAndRef( | 1421 bool need_unref = cache.GetTaskForImageAndRef( |
1412 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1422 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1413 EXPECT_TRUE(task); | 1423 EXPECT_TRUE(task); |
1414 EXPECT_TRUE(need_unref); | 1424 EXPECT_TRUE(need_unref); |
1415 | 1425 |
1416 TestTileTaskRunner::ProcessTask(task.get()); | 1426 TestTileTaskRunner::ProcessTask(task.get()); |
1417 | 1427 |
(...skipping 10 matching lines...) Expand all Loading... |
1428 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1438 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1429 cache.UnrefImage(draw_image); | 1439 cache.UnrefImage(draw_image); |
1430 } | 1440 } |
1431 | 1441 |
1432 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_1ScaleIsHandled) { | 1442 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_1ScaleIsHandled) { |
1433 TestSoftwareImageDecodeCache cache; | 1443 TestSoftwareImageDecodeCache cache; |
1434 bool is_decomposable = true; | 1444 bool is_decomposable = true; |
1435 SkFilterQuality quality = kMedium_SkFilterQuality; | 1445 SkFilterQuality quality = kMedium_SkFilterQuality; |
1436 | 1446 |
1437 sk_sp<SkImage> image = CreateImage(500, 200); | 1447 sk_sp<SkImage> image = CreateImage(500, 200); |
1438 DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), | 1448 DrawImage draw_image( |
1439 quality, | 1449 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1440 CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable), | 1450 quality, CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable), |
1441 DefaultColorSpace()); | 1451 DefaultColorSpace()); |
1442 | 1452 |
1443 scoped_refptr<TileTask> task; | 1453 scoped_refptr<TileTask> task; |
1444 bool need_unref = cache.GetTaskForImageAndRef( | 1454 bool need_unref = cache.GetTaskForImageAndRef( |
1445 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1455 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1446 EXPECT_TRUE(task); | 1456 EXPECT_TRUE(task); |
1447 EXPECT_TRUE(need_unref); | 1457 EXPECT_TRUE(need_unref); |
1448 | 1458 |
1449 TestTileTaskRunner::ProcessTask(task.get()); | 1459 TestTileTaskRunner::ProcessTask(task.get()); |
1450 | 1460 |
1451 DecodedDrawImage decoded_draw_image = | 1461 DecodedDrawImage decoded_draw_image = |
(...skipping 10 matching lines...) Expand all Loading... |
1462 cache.UnrefImage(draw_image); | 1472 cache.UnrefImage(draw_image); |
1463 } | 1473 } |
1464 | 1474 |
1465 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_01ScaleIsHandled) { | 1475 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_01ScaleIsHandled) { |
1466 TestSoftwareImageDecodeCache cache; | 1476 TestSoftwareImageDecodeCache cache; |
1467 bool is_decomposable = true; | 1477 bool is_decomposable = true; |
1468 SkFilterQuality quality = kMedium_SkFilterQuality; | 1478 SkFilterQuality quality = kMedium_SkFilterQuality; |
1469 | 1479 |
1470 sk_sp<SkImage> image = CreateImage(500, 200); | 1480 sk_sp<SkImage> image = CreateImage(500, 200); |
1471 DrawImage draw_image( | 1481 DrawImage draw_image( |
1472 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1482 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1473 CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable), | 1483 quality, CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable), |
1474 DefaultColorSpace()); | 1484 DefaultColorSpace()); |
1475 | 1485 |
1476 scoped_refptr<TileTask> task; | 1486 scoped_refptr<TileTask> task; |
1477 bool need_unref = cache.GetTaskForImageAndRef( | 1487 bool need_unref = cache.GetTaskForImageAndRef( |
1478 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1488 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1479 EXPECT_TRUE(task); | 1489 EXPECT_TRUE(task); |
1480 EXPECT_TRUE(need_unref); | 1490 EXPECT_TRUE(need_unref); |
1481 | 1491 |
1482 TestTileTaskRunner::ProcessTask(task.get()); | 1492 TestTileTaskRunner::ProcessTask(task.get()); |
1483 | 1493 |
(...skipping 11 matching lines...) Expand all Loading... |
1495 cache.UnrefImage(draw_image); | 1505 cache.UnrefImage(draw_image); |
1496 } | 1506 } |
1497 | 1507 |
1498 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_001ScaleIsHandled) { | 1508 TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_001ScaleIsHandled) { |
1499 TestSoftwareImageDecodeCache cache; | 1509 TestSoftwareImageDecodeCache cache; |
1500 bool is_decomposable = true; | 1510 bool is_decomposable = true; |
1501 SkFilterQuality quality = kMedium_SkFilterQuality; | 1511 SkFilterQuality quality = kMedium_SkFilterQuality; |
1502 | 1512 |
1503 sk_sp<SkImage> image = CreateImage(500, 200); | 1513 sk_sp<SkImage> image = CreateImage(500, 200); |
1504 DrawImage draw_image( | 1514 DrawImage draw_image( |
1505 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1515 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1506 CreateMatrix(SkSize::Make(0.001f, 0.001f), is_decomposable), | 1516 quality, CreateMatrix(SkSize::Make(0.001f, 0.001f), is_decomposable), |
1507 DefaultColorSpace()); | 1517 DefaultColorSpace()); |
1508 | 1518 |
1509 scoped_refptr<TileTask> task; | 1519 scoped_refptr<TileTask> task; |
1510 bool need_unref = cache.GetTaskForImageAndRef( | 1520 bool need_unref = cache.GetTaskForImageAndRef( |
1511 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1521 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1512 EXPECT_FALSE(task); | 1522 EXPECT_FALSE(task); |
1513 EXPECT_FALSE(need_unref); | 1523 EXPECT_FALSE(need_unref); |
1514 | 1524 |
1515 DecodedDrawImage decoded_draw_image = | 1525 DecodedDrawImage decoded_draw_image = |
1516 cache.GetDecodedImageForDraw(draw_image); | 1526 cache.GetDecodedImageForDraw(draw_image); |
1517 EXPECT_FALSE(decoded_draw_image.image()); | 1527 EXPECT_FALSE(decoded_draw_image.image()); |
1518 | 1528 |
1519 cache.DrawWithImageFinished(draw_image, decoded_draw_image); | 1529 cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
1520 } | 1530 } |
1521 | 1531 |
1522 TEST(SoftwareImageDecodeCacheTest, | 1532 TEST(SoftwareImageDecodeCacheTest, |
1523 MediumQualityImagesAreTheSameAt0_5And0_49Scale) { | 1533 MediumQualityImagesAreTheSameAt0_5And0_49Scale) { |
1524 TestSoftwareImageDecodeCache cache; | 1534 TestSoftwareImageDecodeCache cache; |
1525 bool is_decomposable = true; | 1535 bool is_decomposable = true; |
1526 SkFilterQuality quality = kMedium_SkFilterQuality; | 1536 SkFilterQuality quality = kMedium_SkFilterQuality; |
1527 | 1537 |
1528 sk_sp<SkImage> image = CreateImage(500, 200); | 1538 sk_sp<SkImage> image = CreateImage(500, 200); |
1529 DrawImage draw_image_50( | 1539 DrawImage draw_image_50( |
1530 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1540 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1531 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), | 1541 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable), |
1532 DefaultColorSpace()); | 1542 DefaultColorSpace()); |
1533 DrawImage draw_image_49( | 1543 DrawImage draw_image_49( |
1534 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1544 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1535 CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable), | 1545 quality, CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable), |
1536 DefaultColorSpace()); | 1546 DefaultColorSpace()); |
1537 | 1547 |
1538 scoped_refptr<TileTask> task_50; | 1548 scoped_refptr<TileTask> task_50; |
1539 bool need_unref_50 = cache.GetTaskForImageAndRef( | 1549 bool need_unref_50 = cache.GetTaskForImageAndRef( |
1540 draw_image_50, ImageDecodeCache::TracingInfo(), &task_50); | 1550 draw_image_50, ImageDecodeCache::TracingInfo(), &task_50); |
1541 EXPECT_TRUE(task_50); | 1551 EXPECT_TRUE(task_50); |
1542 EXPECT_TRUE(need_unref_50); | 1552 EXPECT_TRUE(need_unref_50); |
1543 scoped_refptr<TileTask> task_49; | 1553 scoped_refptr<TileTask> task_49; |
1544 bool need_unref_49 = cache.GetTaskForImageAndRef( | 1554 bool need_unref_49 = cache.GetTaskForImageAndRef( |
1545 draw_image_49, ImageDecodeCache::TracingInfo(), &task_49); | 1555 draw_image_49, ImageDecodeCache::TracingInfo(), &task_49); |
(...skipping 28 matching lines...) Expand all Loading... |
1574 } | 1584 } |
1575 | 1585 |
1576 TEST(SoftwareImageDecodeCacheTest, ClearCache) { | 1586 TEST(SoftwareImageDecodeCacheTest, ClearCache) { |
1577 TestSoftwareImageDecodeCache cache; | 1587 TestSoftwareImageDecodeCache cache; |
1578 bool is_decomposable = true; | 1588 bool is_decomposable = true; |
1579 SkFilterQuality quality = kHigh_SkFilterQuality; | 1589 SkFilterQuality quality = kHigh_SkFilterQuality; |
1580 | 1590 |
1581 for (int i = 0; i < 10; ++i) { | 1591 for (int i = 0; i < 10; ++i) { |
1582 sk_sp<SkImage> image = CreateImage(100, 100); | 1592 sk_sp<SkImage> image = CreateImage(100, 100); |
1583 DrawImage draw_image( | 1593 DrawImage draw_image( |
1584 image, SkIRect::MakeWH(image->width(), image->height()), quality, | 1594 PaintImage(image), SkIRect::MakeWH(image->width(), image->height()), |
1585 CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), | 1595 quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable), |
1586 DefaultColorSpace()); | 1596 DefaultColorSpace()); |
1587 scoped_refptr<TileTask> task; | 1597 scoped_refptr<TileTask> task; |
1588 bool need_unref = cache.GetTaskForImageAndRef( | 1598 bool need_unref = cache.GetTaskForImageAndRef( |
1589 draw_image, ImageDecodeCache::TracingInfo(), &task); | 1599 draw_image, ImageDecodeCache::TracingInfo(), &task); |
1590 EXPECT_TRUE(need_unref); | 1600 EXPECT_TRUE(need_unref); |
1591 EXPECT_TRUE(task); | 1601 EXPECT_TRUE(task); |
1592 TestTileTaskRunner::ProcessTask(task.get()); | 1602 TestTileTaskRunner::ProcessTask(task.get()); |
1593 cache.UnrefImage(draw_image); | 1603 cache.UnrefImage(draw_image); |
1594 } | 1604 } |
1595 | 1605 |
1596 EXPECT_EQ(10u, cache.GetNumCacheEntriesForTesting()); | 1606 EXPECT_EQ(10u, cache.GetNumCacheEntriesForTesting()); |
1597 | 1607 |
1598 // Tell our cache to clear resources. | 1608 // Tell our cache to clear resources. |
1599 cache.ClearCache(); | 1609 cache.ClearCache(); |
1600 | 1610 |
1601 EXPECT_EQ(0u, cache.GetNumCacheEntriesForTesting()); | 1611 EXPECT_EQ(0u, cache.GetNumCacheEntriesForTesting()); |
1602 } | 1612 } |
1603 | 1613 |
1604 } // namespace | 1614 } // namespace |
1605 } // namespace cc | 1615 } // namespace cc |
OLD | NEW |