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