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 |
262 TEST_F(CheckerImageTrackerTest, CancelsScheduledDecodes) { | |
263 SetUpTracker(true); | |
264 | |
265 DrawImage checkerable_image1 = CreateImage(ImageType::CHECKERABLE); | |
266 DrawImage checkerable_image2 = CreateImage(ImageType::CHECKERABLE); | |
267 std::vector<DrawImage> draw_images; | |
vmpstr
2017/04/20 20:59:32
std::vector<DrawImage> draw_images = {checkerable_
Khushal
2017/04/20 21:54:22
Done.
| |
268 draw_images.push_back(checkerable_image1); | |
269 draw_images.push_back(checkerable_image2); | |
270 | |
271 CheckerImageTracker::ImageDecodeQueue image_decode_queue; | |
272 image_decode_queue = | |
273 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); | |
274 EXPECT_EQ(image_decode_queue.size(), 2U); | |
275 checker_image_tracker_->ScheduleImageDecodeQueue( | |
276 std::move(image_decode_queue)); | |
277 | |
278 // Only the first image in the queue should have been decoded. | |
279 EXPECT_EQ(image_controller_.decodes_requested().size(), 1U); | |
280 EXPECT_EQ(image_controller_.decodes_requested().count( | |
281 checkerable_image1.image()->uniqueID()), | |
282 1U); | |
283 | |
284 // Rebuild the queue before the tracker is notified of decode completion, | |
285 // removing the second image and adding a new one. | |
289 draw_images.clear(); | 286 draw_images.clear(); |
290 checkered_images.clear(); | 287 DrawImage checkerable_image3 = CreateImage(ImageType::CHECKERABLE); |
291 draw_images.push_back(checkerable_image1); | 288 draw_images.push_back(checkerable_image1); |
vmpstr
2017/04/20 20:59:32
nit: remove the clear, and then = std::vector<Draw
Khushal
2017/04/20 21:54:22
Done.
| |
292 checker_image_tracker_->FilterImagesForCheckeringForTile( | 289 draw_images.push_back(checkerable_image3); |
293 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | 290 image_decode_queue = |
294 EXPECT_EQ(draw_images.size(), 1U); | 291 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
295 EXPECT_EQ(checkered_images.size(), 0U); | 292 |
293 // The queue has 2 decodes because we are still checkering on the first one. | |
294 EXPECT_EQ(image_decode_queue.size(), 2U); | |
295 checker_image_tracker_->ScheduleImageDecodeQueue( | |
296 std::move(image_decode_queue)); | |
297 | |
298 // We still have only one decode because the tracker keeps only one decode | |
299 // pending at a time. | |
300 EXPECT_EQ(image_controller_.decodes_requested().size(), 1U); | |
vmpstr
2017/04/20 20:59:32
Verify which one like above
Khushal
2017/04/20 21:54:22
Done.
| |
301 | |
302 // Trigger completion for all decodes. Only 2 images should have been decoded | |
303 // since the second image was cancelled. | |
304 base::RunLoop().RunUntilIdle(); | |
305 EXPECT_EQ(image_controller_.decodes_requested().size(), 2U); | |
306 EXPECT_EQ(image_controller_.decodes_requested().count( | |
307 checkerable_image3.image()->uniqueID()), | |
308 1U); | |
309 EXPECT_EQ(image_controller_.num_of_locked_images(), 2); | |
vmpstr
2017/04/20 20:59:32
Do you need to unlock anything at shutdown or will
Khushal
2017/04/20 21:54:21
The tracker unlocks everything in the dtor. There
| |
296 } | 310 } |
297 | 311 |
298 } // namespace | 312 } // namespace |
299 } // namespace cc | 313 } // namespace cc |
OLD | NEW |