OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 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/checker_image_tracker.h" | 5 #include "cc/tiles/checker_image_tracker.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "base/run_loop.h" | 9 #include "base/run_loop.h" |
10 #include "base/threading/thread_task_runner_handle.h" | 10 #include "base/threading/thread_task_runner_handle.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 public: | 22 public: |
23 // We can use the same thread for the image worker because all use of it in | 23 // We can use the same thread for the image worker because all use of it in |
24 // the ImageController is over-ridden here. | 24 // the ImageController is over-ridden here. |
25 TestImageController() | 25 TestImageController() |
26 : ImageController(base::ThreadTaskRunnerHandle::Get().get(), | 26 : ImageController(base::ThreadTaskRunnerHandle::Get().get(), |
27 base::ThreadTaskRunnerHandle::Get()) {} | 27 base::ThreadTaskRunnerHandle::Get()) {} |
28 | 28 |
29 ~TestImageController() override { DCHECK_EQ(locked_images_.size(), 0U); } | 29 ~TestImageController() override { DCHECK_EQ(locked_images_.size(), 0U); } |
30 | 30 |
31 int num_of_locked_images() const { return locked_images_.size(); } | 31 int num_of_locked_images() const { return locked_images_.size(); } |
| 32 const ImageIdFlatSet& decodes_requested() const { return decodes_requested_; } |
32 | 33 |
33 void UnlockImageDecode(ImageDecodeRequestId id) override { | 34 void UnlockImageDecode(ImageDecodeRequestId id) override { |
34 DCHECK_EQ(locked_images_.count(id), 1U); | 35 DCHECK_EQ(locked_images_.count(id), 1U); |
35 locked_images_.erase(id); | 36 locked_images_.erase(id); |
36 } | 37 } |
37 | 38 |
38 ImageDecodeRequestId QueueImageDecode( | 39 ImageDecodeRequestId QueueImageDecode( |
39 sk_sp<const SkImage> image, | 40 sk_sp<const SkImage> image, |
40 const ImageDecodedCallback& callback) override { | 41 const ImageDecodedCallback& callback) override { |
41 ImageDecodeRequestId request_id = next_image_request_id_++; | 42 ImageDecodeRequestId request_id = next_image_request_id_++; |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
77 int dimension = image_type == ImageType::CHECKERABLE | 78 int dimension = image_type == ImageType::CHECKERABLE |
78 ? kCheckerableImageDimension | 79 ? kCheckerableImageDimension |
79 : kNonCheckerableImageDimension; | 80 : kNonCheckerableImageDimension; |
80 sk_sp<SkImage> image = | 81 sk_sp<SkImage> image = |
81 CreateDiscardableImage(gfx::Size(dimension, dimension)); | 82 CreateDiscardableImage(gfx::Size(dimension, dimension)); |
82 gfx::ColorSpace target_color_space = gfx::ColorSpace::CreateSRGB(); | 83 gfx::ColorSpace target_color_space = gfx::ColorSpace::CreateSRGB(); |
83 return DrawImage(image, SkIRect::MakeWH(image->width(), image->height()), | 84 return DrawImage(image, SkIRect::MakeWH(image->width(), image->height()), |
84 kNone_SkFilterQuality, SkMatrix::I(), target_color_space); | 85 kNone_SkFilterQuality, SkMatrix::I(), target_color_space); |
85 } | 86 } |
86 | 87 |
| 88 CheckerImageTracker::ImageDecodeQueue BuildImageDecodeQueue( |
| 89 std::vector<DrawImage> draw_images, |
| 90 WhichTree tree) { |
| 91 CheckerImageTracker::ImageDecodeQueue decode_queue; |
| 92 for (auto draw_image : draw_images) { |
| 93 sk_sp<const SkImage> image = draw_image.image(); |
| 94 if (checker_image_tracker_->ShouldCheckerImage(image, tree)) |
| 95 decode_queue.push_back(image); |
| 96 } |
| 97 return decode_queue; |
| 98 } |
| 99 |
87 // CheckerImageTrackerClient implementation. | 100 // CheckerImageTrackerClient implementation. |
88 void NeedsInvalidationForCheckerImagedTiles() override { | 101 void NeedsInvalidationForCheckerImagedTiles() override { |
89 invalidation_request_pending_ = true; | 102 invalidation_request_pending_ = true; |
90 } | 103 } |
91 | 104 |
92 protected: | 105 protected: |
93 TestImageController image_controller_; | 106 TestImageController image_controller_; |
94 std::unique_ptr<CheckerImageTracker> checker_image_tracker_; | 107 std::unique_ptr<CheckerImageTracker> checker_image_tracker_; |
95 | 108 |
96 bool invalidation_request_pending_ = false; | 109 bool invalidation_request_pending_ = false; |
97 }; | 110 }; |
98 | 111 |
99 TEST_F(CheckerImageTrackerTest, CheckerImagesDisabled) { | 112 TEST_F(CheckerImageTrackerTest, CheckerImagesDisabled) { |
100 // Ensures that the tracker doesn't filter any images for checkering if it is | 113 // Ensures that the tracker doesn't filter any images for checkering if it is |
101 // disabled. | 114 // disabled. |
102 SetUpTracker(false); | 115 SetUpTracker(false); |
103 | 116 |
104 std::vector<DrawImage> draw_images; | |
105 ImageIdFlatSet checkered_images; | 117 ImageIdFlatSet checkered_images; |
106 draw_images.push_back(CreateImage(ImageType::CHECKERABLE)); | 118 DrawImage draw_image = CreateImage(ImageType::CHECKERABLE); |
107 checker_image_tracker_->FilterImagesForCheckeringForTile( | 119 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
108 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 120 draw_image.image(), WhichTree::PENDING_TREE)); |
109 EXPECT_EQ(draw_images.size(), 1U); | |
110 EXPECT_EQ(checkered_images.size(), 0U); | |
111 EXPECT_EQ(image_controller_.num_of_locked_images(), 0); | 121 EXPECT_EQ(image_controller_.num_of_locked_images(), 0); |
112 } | 122 } |
113 | 123 |
114 TEST_F(CheckerImageTrackerTest, UpdatesImagesAtomically) { | 124 TEST_F(CheckerImageTrackerTest, UpdatesImagesAtomically) { |
115 // Ensures that the tracker updates images atomically for each frame. | 125 // Ensures that the tracker updates images atomically for each frame. |
116 SetUpTracker(true); | 126 SetUpTracker(true); |
117 | 127 |
118 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); | 128 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); |
119 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); | 129 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); |
120 ImageIdFlatSet checkered_images; | |
121 std::vector<DrawImage> draw_images; | 130 std::vector<DrawImage> draw_images; |
| 131 CheckerImageTracker::ImageDecodeQueue image_decode_queue; |
122 | 132 |
123 // First request to filter images. | 133 // First request to filter images. |
124 draw_images.push_back(checkerable_image); | 134 draw_images.push_back(checkerable_image); |
125 draw_images.push_back(non_checkerable_image); | 135 draw_images.push_back(non_checkerable_image); |
126 draw_images.push_back(checkerable_image); | 136 draw_images.push_back(checkerable_image); |
127 checker_image_tracker_->FilterImagesForCheckeringForTile( | 137 image_decode_queue = |
128 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 138 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
129 | 139 |
130 EXPECT_EQ(draw_images.size(), 1U); | 140 EXPECT_EQ(image_decode_queue.size(), 2U); |
131 EXPECT_EQ(draw_images[0].image(), non_checkerable_image.image()); | 141 EXPECT_EQ(image_decode_queue[0], checkerable_image.image()); |
132 EXPECT_EQ(checkered_images.size(), 1U); | 142 EXPECT_EQ(image_decode_queue[1], checkerable_image.image()); |
133 EXPECT_EQ(checkered_images.count(checkerable_image.image()->uniqueID()), 1U); | 143 |
| 144 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
134 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 145 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
135 | 146 |
136 // Run pending task to indicate completion of decode request to the tracker. | 147 // Run pending task to indicate completion of decode request to the tracker. |
137 // This should send an impl-side invalidation request to the client. The | 148 // This should send an impl-side invalidation request to the client. The |
138 // images must remain locked until the sync tree to which the invalidations | 149 // images must remain locked until the sync tree to which the invalidations |
139 // are added is activated. | 150 // are added is activated. |
140 base::RunLoop().RunUntilIdle(); | 151 base::RunLoop().RunUntilIdle(); |
141 EXPECT_TRUE(invalidation_request_pending_); | 152 EXPECT_TRUE(invalidation_request_pending_); |
142 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 153 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
143 | 154 |
144 // Continue checkering the image until the set of images to invalidate is | 155 // Continue checkering the image until the set of images to invalidate is |
145 // pulled. | 156 // pulled. |
146 draw_images.clear(); | 157 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
147 draw_images.push_back(checkerable_image); | 158 checkerable_image.image(), WhichTree::PENDING_TREE)); |
148 checkered_images.clear(); | |
149 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
150 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
151 EXPECT_EQ(draw_images.size(), 0U); | |
152 EXPECT_EQ(checkered_images.size(), 1U); | |
153 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | |
154 | 159 |
155 ImageIdFlatSet invalidated_images = | 160 ImageIdFlatSet invalidated_images = |
156 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | 161 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); |
157 EXPECT_EQ(invalidated_images.size(), 1U); | 162 EXPECT_EQ(invalidated_images.size(), 1U); |
158 EXPECT_EQ(invalidated_images.count(checkerable_image.image()->uniqueID()), | 163 EXPECT_EQ(invalidated_images.count(checkerable_image.image()->uniqueID()), |
159 1U); | 164 1U); |
160 | 165 |
161 // Use the same set of draw images to ensure that they are not checkered on | 166 // Use the same set of draw images to ensure that they are not checkered on |
162 // the pending tree now. | 167 // the pending tree now. |
163 draw_images.clear(); | 168 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
164 draw_images.push_back(checkerable_image); | 169 checkerable_image.image(), WhichTree::PENDING_TREE)); |
165 draw_images.push_back(non_checkerable_image); | 170 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
166 checkered_images.clear(); | 171 non_checkerable_image.image(), WhichTree::PENDING_TREE)); |
167 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
168 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
169 EXPECT_EQ(draw_images.size(), 2U); | |
170 EXPECT_EQ(checkered_images.size(), 0U); | |
171 | 172 |
172 // Use this set to make the same request from the active tree, we should | 173 // Use this set to make the same request from the active tree, we should |
173 // continue checkering this image on the active tree until activation. | 174 // continue checkering this image on the active tree until activation. |
174 draw_images.clear(); | 175 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
175 draw_images.push_back(checkerable_image); | 176 checkerable_image.image(), WhichTree::ACTIVE_TREE)); |
176 draw_images.push_back(non_checkerable_image); | 177 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
177 checkered_images.clear(); | 178 non_checkerable_image.image(), WhichTree::ACTIVE_TREE)); |
178 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
179 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
180 EXPECT_EQ(draw_images.size(), 1U); | |
181 EXPECT_EQ(draw_images[0].image(), non_checkerable_image.image()); | |
182 EXPECT_EQ(checkered_images.size(), 1U); | |
183 EXPECT_EQ(checkered_images.count(checkerable_image.image()->uniqueID()), 1U); | |
184 | 179 |
185 // Activate the sync tree. The images should be unlocked upon activation. | 180 // Activate the sync tree. The images should be unlocked upon activation. |
186 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 181 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
187 checker_image_tracker_->DidActivateSyncTree(); | 182 checker_image_tracker_->DidActivateSyncTree(); |
188 } | 183 } |
189 | 184 |
190 TEST_F(CheckerImageTrackerTest, NoConsecutiveCheckeringForImage) { | 185 TEST_F(CheckerImageTrackerTest, NoConsecutiveCheckeringForImage) { |
191 // Ensures that if an image is decoded and invalidated once, it is not | 186 // Ensures that if an image is decoded and invalidated once, it is not |
192 // checkered again in subsequent frames. | 187 // checkered again in subsequent frames. |
193 SetUpTracker(true); | 188 SetUpTracker(true); |
194 | 189 |
195 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); | 190 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); |
196 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); | 191 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); |
197 ImageIdFlatSet checkered_images; | |
198 std::vector<DrawImage> draw_images; | 192 std::vector<DrawImage> draw_images; |
199 | 193 |
200 draw_images.clear(); | 194 draw_images.clear(); |
201 draw_images.push_back(checkerable_image); | 195 draw_images.push_back(checkerable_image); |
202 checkered_images.clear(); | 196 CheckerImageTracker::ImageDecodeQueue image_decode_queue = |
203 checker_image_tracker_->FilterImagesForCheckeringForTile( | 197 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
204 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 198 EXPECT_EQ(image_decode_queue.size(), 1U); |
205 EXPECT_EQ(draw_images.size(), 0U); | 199 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
206 EXPECT_EQ(checkered_images.size(), 1U); | |
207 | 200 |
208 // Trigger decode completion, take images to invalidate and activate the sync | 201 // Trigger decode completion, take images to invalidate and activate the sync |
209 // tree. | 202 // tree. |
210 base::RunLoop().RunUntilIdle(); | 203 base::RunLoop().RunUntilIdle(); |
211 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | 204 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); |
212 checker_image_tracker_->DidActivateSyncTree(); | 205 checker_image_tracker_->DidActivateSyncTree(); |
213 | 206 |
214 // Subsequent requests for this image should not be checkered. | 207 // Subsequent requests for this image should not be checkered. |
215 draw_images.clear(); | 208 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
216 draw_images.push_back(checkerable_image); | 209 checkerable_image.image(), WhichTree::PENDING_TREE)); |
217 checkered_images.clear(); | |
218 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
219 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
220 EXPECT_EQ(draw_images.size(), 1U); | |
221 EXPECT_EQ(checkered_images.size(), 0U); | |
222 } | 210 } |
223 | 211 |
224 TEST_F(CheckerImageTrackerTest, | 212 TEST_F(CheckerImageTrackerTest, |
225 TracksCheckeredImagesSeperatelyInConsecutiveFrames) { | 213 TracksCheckeredImagesSeperatelyInConsecutiveFrames) { |
226 // Ensures that the set of images being checkered on the pending tree, and the | 214 // Ensures that the set of images being checkered on the pending tree, and the |
227 // active tree are tracked correctly. | 215 // active tree are tracked correctly. |
228 SetUpTracker(true); | 216 SetUpTracker(true); |
229 | 217 |
230 DrawImage checkerable_image1 = CreateImage(ImageType::CHECKERABLE); | 218 DrawImage checkerable_image1 = CreateImage(ImageType::CHECKERABLE); |
231 ImageIdFlatSet checkered_images; | |
232 std::vector<DrawImage> draw_images; | 219 std::vector<DrawImage> draw_images; |
| 220 CheckerImageTracker::ImageDecodeQueue image_decode_queue; |
233 | 221 |
234 // First request to filter images on the pending and active tree. | 222 // First request to filter images on the pending and active tree. |
235 draw_images.push_back(checkerable_image1); | 223 draw_images.push_back(checkerable_image1); |
236 checker_image_tracker_->FilterImagesForCheckeringForTile( | 224 image_decode_queue = |
237 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 225 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
238 EXPECT_EQ(draw_images.size(), 0U); | 226 EXPECT_EQ(image_decode_queue.size(), 1U); |
239 EXPECT_EQ(checkered_images.size(), 1U); | 227 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
240 | 228 |
241 // The image is also checkered on the active tree while a decode request is | 229 // The image is also checkered on the active tree while a decode request is |
242 // pending. | 230 // pending. |
243 draw_images.clear(); | 231 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
244 checkered_images.clear(); | 232 checkerable_image1.image(), WhichTree::ACTIVE_TREE)); |
245 draw_images.push_back(checkerable_image1); | |
246 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
247 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
248 EXPECT_EQ(draw_images.size(), 0U); | |
249 EXPECT_EQ(checkered_images.size(), 1U); | |
250 | 233 |
251 // Trigger decode completion and take images to invalidate on the sync tree. | 234 // Trigger decode completion and take images to invalidate on the sync tree. |
252 base::RunLoop().RunUntilIdle(); | 235 base::RunLoop().RunUntilIdle(); |
253 EXPECT_TRUE(invalidation_request_pending_); | 236 EXPECT_TRUE(invalidation_request_pending_); |
254 ImageIdFlatSet invalidated_images = | 237 ImageIdFlatSet invalidated_images = |
255 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | 238 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); |
256 EXPECT_EQ(invalidated_images.size(), 1U); | 239 EXPECT_EQ(invalidated_images.size(), 1U); |
257 EXPECT_EQ(invalidated_images.count(checkerable_image1.image()->uniqueID()), | 240 EXPECT_EQ(invalidated_images.count(checkerable_image1.image()->uniqueID()), |
258 1U); | 241 1U); |
259 | 242 |
260 // Second request to filter the same image on the pending and active tree. It | 243 // Second request to filter the same image on the pending and active tree. It |
261 // should be checkered on the active tree, but not the pending tree. | 244 // should be checkered on the active tree, but not the pending tree. |
262 draw_images.clear(); | 245 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
263 checkered_images.clear(); | 246 checkerable_image1.image(), WhichTree::ACTIVE_TREE)); |
264 draw_images.push_back(checkerable_image1); | 247 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
265 checker_image_tracker_->FilterImagesForCheckeringForTile( | 248 checkerable_image1.image(), WhichTree::PENDING_TREE)); |
266 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
267 EXPECT_EQ(draw_images.size(), 1U); | |
268 EXPECT_EQ(checkered_images.size(), 0U); | |
269 | |
270 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
271 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
272 EXPECT_EQ(draw_images.size(), 0U); | |
273 EXPECT_EQ(checkered_images.size(), 1U); | |
274 | 249 |
275 // New checkerable image on the pending tree. | 250 // New checkerable image on the pending tree. |
276 DrawImage checkerable_image2 = CreateImage(ImageType::CHECKERABLE); | 251 DrawImage checkerable_image2 = CreateImage(ImageType::CHECKERABLE); |
277 draw_images.clear(); | 252 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
278 checkered_images.clear(); | 253 checkerable_image2.image(), WhichTree::PENDING_TREE)); |
279 draw_images.push_back(checkerable_image2); | |
280 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
281 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
282 EXPECT_EQ(draw_images.size(), 0U); | |
283 EXPECT_EQ(checkered_images.size(), 1U); | |
284 | 254 |
285 // Activate the sync tree. The initial image should no longer be checkered on | 255 // Activate the sync tree. The initial image should no longer be checkered on |
286 // the active tree. | 256 // the active tree. |
287 checker_image_tracker_->DidActivateSyncTree(); | 257 checker_image_tracker_->DidActivateSyncTree(); |
| 258 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
| 259 checkerable_image1.image(), WhichTree::ACTIVE_TREE)); |
| 260 } |
288 | 261 |
289 draw_images.clear(); | 262 TEST_F(CheckerImageTrackerTest, CancelsScheduledDecodes) { |
290 checkered_images.clear(); | 263 SetUpTracker(true); |
291 draw_images.push_back(checkerable_image1); | 264 |
292 checker_image_tracker_->FilterImagesForCheckeringForTile( | 265 DrawImage checkerable_image1 = CreateImage(ImageType::CHECKERABLE); |
293 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | 266 DrawImage checkerable_image2 = CreateImage(ImageType::CHECKERABLE); |
294 EXPECT_EQ(draw_images.size(), 1U); | 267 std::vector<DrawImage> draw_images = {checkerable_image1, checkerable_image2}; |
295 EXPECT_EQ(checkered_images.size(), 0U); | 268 |
| 269 CheckerImageTracker::ImageDecodeQueue image_decode_queue; |
| 270 image_decode_queue = |
| 271 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
| 272 EXPECT_EQ(image_decode_queue.size(), 2U); |
| 273 checker_image_tracker_->ScheduleImageDecodeQueue( |
| 274 std::move(image_decode_queue)); |
| 275 |
| 276 // Only the first image in the queue should have been decoded. |
| 277 EXPECT_EQ(image_controller_.decodes_requested().size(), 1U); |
| 278 EXPECT_EQ(image_controller_.decodes_requested().count( |
| 279 checkerable_image1.image()->uniqueID()), |
| 280 1U); |
| 281 |
| 282 // Rebuild the queue before the tracker is notified of decode completion, |
| 283 // removing the second image and adding a new one. |
| 284 DrawImage checkerable_image3 = CreateImage(ImageType::CHECKERABLE); |
| 285 draw_images = {checkerable_image1, checkerable_image3}; |
| 286 image_decode_queue = |
| 287 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
| 288 |
| 289 // The queue has 2 decodes because we are still checkering on the first one. |
| 290 EXPECT_EQ(image_decode_queue.size(), 2U); |
| 291 checker_image_tracker_->ScheduleImageDecodeQueue( |
| 292 std::move(image_decode_queue)); |
| 293 |
| 294 // We still have only one decode because the tracker keeps only one decode |
| 295 // pending at a time. |
| 296 EXPECT_EQ(image_controller_.decodes_requested().size(), 1U); |
| 297 EXPECT_EQ(image_controller_.decodes_requested().count( |
| 298 checkerable_image1.image()->uniqueID()), |
| 299 1U); |
| 300 |
| 301 // Trigger completion for all decodes. Only 2 images should have been decoded |
| 302 // since the second image was cancelled. |
| 303 base::RunLoop().RunUntilIdle(); |
| 304 EXPECT_EQ(image_controller_.decodes_requested().size(), 2U); |
| 305 EXPECT_EQ(image_controller_.decodes_requested().count( |
| 306 checkerable_image3.image()->uniqueID()), |
| 307 1U); |
| 308 EXPECT_EQ(image_controller_.num_of_locked_images(), 2); |
296 } | 309 } |
297 | 310 |
298 } // namespace | 311 } // namespace |
299 } // namespace cc | 312 } // namespace cc |
OLD | NEW |