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 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
76 DrawImage CreateImage(ImageType image_type) { | 76 DrawImage CreateImage(ImageType image_type) { |
77 int dimension = image_type == ImageType::CHECKERABLE | 77 int dimension = image_type == ImageType::CHECKERABLE |
78 ? kCheckerableImageDimension | 78 ? kCheckerableImageDimension |
79 : kNonCheckerableImageDimension; | 79 : kNonCheckerableImageDimension; |
80 sk_sp<SkImage> image = | 80 sk_sp<SkImage> image = |
81 CreateDiscardableImage(gfx::Size(dimension, dimension)); | 81 CreateDiscardableImage(gfx::Size(dimension, dimension)); |
82 return DrawImage(image, SkIRect::MakeWH(image->width(), image->height()), | 82 return DrawImage(image, SkIRect::MakeWH(image->width(), image->height()), |
83 kNone_SkFilterQuality, SkMatrix::I()); | 83 kNone_SkFilterQuality, SkMatrix::I()); |
84 } | 84 } |
85 | 85 |
| 86 CheckerImageTracker::ImageDecodeQueue BuildImageDecodeQueue( |
| 87 std::vector<DrawImage> draw_images, |
| 88 WhichTree tree) { |
| 89 CheckerImageTracker::ImageDecodeQueue decode_queue; |
| 90 for (auto draw_image : draw_images) { |
| 91 sk_sp<const SkImage> image = draw_image.image(); |
| 92 if (checker_image_tracker_->ShouldCheckerImage(image, tree)) |
| 93 decode_queue.push_back(image); |
| 94 } |
| 95 return decode_queue; |
| 96 } |
| 97 |
86 // CheckerImageTrackerClient implementation. | 98 // CheckerImageTrackerClient implementation. |
87 void NeedsInvalidationForCheckerImagedTiles() override { | 99 void NeedsInvalidationForCheckerImagedTiles() override { |
88 invalidation_request_pending_ = true; | 100 invalidation_request_pending_ = true; |
89 } | 101 } |
90 | 102 |
91 protected: | 103 protected: |
92 TestImageController image_controller_; | 104 TestImageController image_controller_; |
93 std::unique_ptr<CheckerImageTracker> checker_image_tracker_; | 105 std::unique_ptr<CheckerImageTracker> checker_image_tracker_; |
94 | 106 |
95 bool invalidation_request_pending_ = false; | 107 bool invalidation_request_pending_ = false; |
96 }; | 108 }; |
97 | 109 |
98 TEST_F(CheckerImageTrackerTest, CheckerImagesDisabled) { | 110 TEST_F(CheckerImageTrackerTest, CheckerImagesDisabled) { |
99 // Ensures that the tracker doesn't filter any images for checkering if it is | 111 // Ensures that the tracker doesn't filter any images for checkering if it is |
100 // disabled. | 112 // disabled. |
101 SetUpTracker(false); | 113 SetUpTracker(false); |
102 | 114 |
103 std::vector<DrawImage> draw_images; | |
104 ImageIdFlatSet checkered_images; | 115 ImageIdFlatSet checkered_images; |
105 draw_images.push_back(CreateImage(ImageType::CHECKERABLE)); | 116 DrawImage draw_image = CreateImage(ImageType::CHECKERABLE); |
106 checker_image_tracker_->FilterImagesForCheckeringForTile( | 117 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
107 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 118 draw_image.image(), WhichTree::PENDING_TREE)); |
108 EXPECT_EQ(draw_images.size(), 1U); | |
109 EXPECT_EQ(checkered_images.size(), 0U); | |
110 EXPECT_EQ(image_controller_.num_of_locked_images(), 0); | 119 EXPECT_EQ(image_controller_.num_of_locked_images(), 0); |
111 } | 120 } |
112 | 121 |
113 TEST_F(CheckerImageTrackerTest, UpdatesImagesAtomically) { | 122 TEST_F(CheckerImageTrackerTest, UpdatesImagesAtomically) { |
114 // Ensures that the tracker updates images atomically for each frame. | 123 // Ensures that the tracker updates images atomically for each frame. |
115 SetUpTracker(true); | 124 SetUpTracker(true); |
116 | 125 |
117 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); | 126 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); |
118 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); | 127 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); |
119 ImageIdFlatSet checkered_images; | |
120 std::vector<DrawImage> draw_images; | 128 std::vector<DrawImage> draw_images; |
| 129 CheckerImageTracker::ImageDecodeQueue image_decode_queue; |
121 | 130 |
122 // First request to filter images. | 131 // First request to filter images. |
123 draw_images.push_back(checkerable_image); | 132 draw_images.push_back(checkerable_image); |
124 draw_images.push_back(non_checkerable_image); | 133 draw_images.push_back(non_checkerable_image); |
125 draw_images.push_back(checkerable_image); | 134 draw_images.push_back(checkerable_image); |
126 checker_image_tracker_->FilterImagesForCheckeringForTile( | 135 image_decode_queue = |
127 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 136 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
128 | 137 |
129 EXPECT_EQ(draw_images.size(), 1U); | 138 EXPECT_EQ(image_decode_queue.size(), 2U); |
130 EXPECT_EQ(draw_images[0].image(), non_checkerable_image.image()); | 139 EXPECT_EQ(image_decode_queue[0], checkerable_image.image()); |
131 EXPECT_EQ(checkered_images.size(), 1U); | 140 EXPECT_EQ(image_decode_queue[1], checkerable_image.image()); |
132 EXPECT_EQ(checkered_images.count(checkerable_image.image()->uniqueID()), 1U); | 141 |
| 142 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
133 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 143 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
134 | 144 |
135 // Run pending task to indicate completion of decode request to the tracker. | 145 // Run pending task to indicate completion of decode request to the tracker. |
136 // This should send an impl-side invalidation request to the client. The | 146 // This should send an impl-side invalidation request to the client. The |
137 // images must remain locked until the sync tree to which the invalidations | 147 // images must remain locked until the sync tree to which the invalidations |
138 // are added is activated. | 148 // are added is activated. |
139 base::RunLoop().RunUntilIdle(); | 149 base::RunLoop().RunUntilIdle(); |
140 EXPECT_TRUE(invalidation_request_pending_); | 150 EXPECT_TRUE(invalidation_request_pending_); |
141 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 151 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
142 | 152 |
143 // Continue checkering the image until the set of images to invalidate is | 153 // Continue checkering the image until the set of images to invalidate is |
144 // pulled. | 154 // pulled. |
145 draw_images.clear(); | 155 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
146 draw_images.push_back(checkerable_image); | 156 checkerable_image.image(), WhichTree::PENDING_TREE)); |
147 checkered_images.clear(); | |
148 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
149 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
150 EXPECT_EQ(draw_images.size(), 0U); | |
151 EXPECT_EQ(checkered_images.size(), 1U); | |
152 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | |
153 | 157 |
154 ImageIdFlatSet invalidated_images = | 158 ImageIdFlatSet invalidated_images = |
155 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | 159 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); |
156 EXPECT_EQ(invalidated_images.size(), 1U); | 160 EXPECT_EQ(invalidated_images.size(), 1U); |
157 EXPECT_EQ(invalidated_images.count(checkerable_image.image()->uniqueID()), | 161 EXPECT_EQ(invalidated_images.count(checkerable_image.image()->uniqueID()), |
158 1U); | 162 1U); |
159 | 163 |
160 // Use the same set of draw images to ensure that they are not checkered on | 164 // Use the same set of draw images to ensure that they are not checkered on |
161 // the pending tree now. | 165 // the pending tree now. |
162 draw_images.clear(); | 166 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
163 draw_images.push_back(checkerable_image); | 167 checkerable_image.image(), WhichTree::PENDING_TREE)); |
164 draw_images.push_back(non_checkerable_image); | 168 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
165 checkered_images.clear(); | 169 non_checkerable_image.image(), WhichTree::PENDING_TREE)); |
166 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
167 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
168 EXPECT_EQ(draw_images.size(), 2U); | |
169 EXPECT_EQ(checkered_images.size(), 0U); | |
170 | 170 |
171 // Use this set to make the same request from the active tree, we should | 171 // Use this set to make the same request from the active tree, we should |
172 // continue checkering this image on the active tree until activation. | 172 // continue checkering this image on the active tree until activation. |
173 draw_images.clear(); | 173 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
174 draw_images.push_back(checkerable_image); | 174 checkerable_image.image(), WhichTree::ACTIVE_TREE)); |
175 draw_images.push_back(non_checkerable_image); | 175 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
176 checkered_images.clear(); | 176 non_checkerable_image.image(), WhichTree::ACTIVE_TREE)); |
177 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
178 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
179 EXPECT_EQ(draw_images.size(), 1U); | |
180 EXPECT_EQ(draw_images[0].image(), non_checkerable_image.image()); | |
181 EXPECT_EQ(checkered_images.size(), 1U); | |
182 EXPECT_EQ(checkered_images.count(checkerable_image.image()->uniqueID()), 1U); | |
183 | 177 |
184 // Activate the sync tree. The images should be unlocked upon activation. | 178 // Activate the sync tree. The images should be unlocked upon activation. |
185 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 179 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
186 checker_image_tracker_->DidActivateSyncTree(); | 180 checker_image_tracker_->DidActivateSyncTree(); |
187 } | 181 } |
188 | 182 |
189 TEST_F(CheckerImageTrackerTest, NoConsecutiveCheckeringForImage) { | 183 TEST_F(CheckerImageTrackerTest, NoConsecutiveCheckeringForImage) { |
190 // Ensures that if an image is decoded and invalidated once, it is not | 184 // Ensures that if an image is decoded and invalidated once, it is not |
191 // checkered again in subsequent frames. | 185 // checkered again in subsequent frames. |
192 SetUpTracker(true); | 186 SetUpTracker(true); |
193 | 187 |
194 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); | 188 DrawImage checkerable_image = CreateImage(ImageType::CHECKERABLE); |
195 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); | 189 DrawImage non_checkerable_image = CreateImage(ImageType::NON_CHECKERABLE); |
196 ImageIdFlatSet checkered_images; | |
197 std::vector<DrawImage> draw_images; | 190 std::vector<DrawImage> draw_images; |
198 | 191 |
199 draw_images.clear(); | 192 draw_images.clear(); |
200 draw_images.push_back(checkerable_image); | 193 draw_images.push_back(checkerable_image); |
201 checkered_images.clear(); | 194 CheckerImageTracker::ImageDecodeQueue image_decode_queue = |
202 checker_image_tracker_->FilterImagesForCheckeringForTile( | 195 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
203 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 196 EXPECT_EQ(image_decode_queue.size(), 1U); |
204 EXPECT_EQ(draw_images.size(), 0U); | 197 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
205 EXPECT_EQ(checkered_images.size(), 1U); | |
206 | 198 |
207 // Trigger decode completion, take images to invalidate and activate the sync | 199 // Trigger decode completion, take images to invalidate and activate the sync |
208 // tree. | 200 // tree. |
209 base::RunLoop().RunUntilIdle(); | 201 base::RunLoop().RunUntilIdle(); |
210 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | 202 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); |
211 checker_image_tracker_->DidActivateSyncTree(); | 203 checker_image_tracker_->DidActivateSyncTree(); |
212 | 204 |
213 // Subsequent requests for this image should not be checkered. | 205 // Subsequent requests for this image should not be checkered. |
214 draw_images.clear(); | 206 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
215 draw_images.push_back(checkerable_image); | 207 checkerable_image.image(), WhichTree::PENDING_TREE)); |
216 checkered_images.clear(); | |
217 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
218 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
219 EXPECT_EQ(draw_images.size(), 1U); | |
220 EXPECT_EQ(checkered_images.size(), 0U); | |
221 } | 208 } |
222 | 209 |
223 TEST_F(CheckerImageTrackerTest, | 210 TEST_F(CheckerImageTrackerTest, |
224 TracksCheckeredImagesSeperatelyInConsecutiveFrames) { | 211 TracksCheckeredImagesSeperatelyInConsecutiveFrames) { |
225 // Ensures that the set of images being checkered on the pending tree, and the | 212 // Ensures that the set of images being checkered on the pending tree, and the |
226 // active tree are tracked correctly. | 213 // active tree are tracked correctly. |
227 SetUpTracker(true); | 214 SetUpTracker(true); |
228 | 215 |
229 DrawImage checkerable_image1 = CreateImage(ImageType::CHECKERABLE); | 216 DrawImage checkerable_image1 = CreateImage(ImageType::CHECKERABLE); |
230 ImageIdFlatSet checkered_images; | |
231 std::vector<DrawImage> draw_images; | 217 std::vector<DrawImage> draw_images; |
| 218 CheckerImageTracker::ImageDecodeQueue image_decode_queue; |
232 | 219 |
233 // First request to filter images on the pending and active tree. | 220 // First request to filter images on the pending and active tree. |
234 draw_images.push_back(checkerable_image1); | 221 draw_images.push_back(checkerable_image1); |
235 checker_image_tracker_->FilterImagesForCheckeringForTile( | 222 image_decode_queue = |
236 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | 223 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
237 EXPECT_EQ(draw_images.size(), 0U); | 224 EXPECT_EQ(image_decode_queue.size(), 1U); |
238 EXPECT_EQ(checkered_images.size(), 1U); | 225 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
239 | 226 |
240 // The image is also checkered on the active tree while a decode request is | 227 // The image is also checkered on the active tree while a decode request is |
241 // pending. | 228 // pending. |
242 draw_images.clear(); | 229 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
243 checkered_images.clear(); | 230 checkerable_image1.image(), WhichTree::ACTIVE_TREE)); |
244 draw_images.push_back(checkerable_image1); | |
245 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
246 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
247 EXPECT_EQ(draw_images.size(), 0U); | |
248 EXPECT_EQ(checkered_images.size(), 1U); | |
249 | 231 |
250 // Trigger decode completion and take images to invalidate on the sync tree. | 232 // Trigger decode completion and take images to invalidate on the sync tree. |
251 base::RunLoop().RunUntilIdle(); | 233 base::RunLoop().RunUntilIdle(); |
252 EXPECT_TRUE(invalidation_request_pending_); | 234 EXPECT_TRUE(invalidation_request_pending_); |
253 ImageIdFlatSet invalidated_images = | 235 ImageIdFlatSet invalidated_images = |
254 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | 236 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); |
255 EXPECT_EQ(invalidated_images.size(), 1U); | 237 EXPECT_EQ(invalidated_images.size(), 1U); |
256 EXPECT_EQ(invalidated_images.count(checkerable_image1.image()->uniqueID()), | 238 EXPECT_EQ(invalidated_images.count(checkerable_image1.image()->uniqueID()), |
257 1U); | 239 1U); |
258 | 240 |
259 // Second request to filter the same image on the pending and active tree. It | 241 // Second request to filter the same image on the pending and active tree. It |
260 // should be checkered on the active tree, but not the pending tree. | 242 // should be checkered on the active tree, but not the pending tree. |
261 draw_images.clear(); | 243 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
262 checkered_images.clear(); | 244 checkerable_image1.image(), WhichTree::ACTIVE_TREE)); |
263 draw_images.push_back(checkerable_image1); | 245 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
264 checker_image_tracker_->FilterImagesForCheckeringForTile( | 246 checkerable_image1.image(), WhichTree::PENDING_TREE)); |
265 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
266 EXPECT_EQ(draw_images.size(), 1U); | |
267 EXPECT_EQ(checkered_images.size(), 0U); | |
268 | |
269 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
270 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
271 EXPECT_EQ(draw_images.size(), 0U); | |
272 EXPECT_EQ(checkered_images.size(), 1U); | |
273 | 247 |
274 // New checkerable image on the pending tree. | 248 // New checkerable image on the pending tree. |
275 DrawImage checkerable_image2 = CreateImage(ImageType::CHECKERABLE); | 249 DrawImage checkerable_image2 = CreateImage(ImageType::CHECKERABLE); |
276 draw_images.clear(); | 250 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
277 checkered_images.clear(); | 251 checkerable_image2.image(), WhichTree::PENDING_TREE)); |
278 draw_images.push_back(checkerable_image2); | |
279 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
280 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
281 EXPECT_EQ(draw_images.size(), 0U); | |
282 EXPECT_EQ(checkered_images.size(), 1U); | |
283 | 252 |
284 // Activate the sync tree. The initial image should no longer be checkered on | 253 // Activate the sync tree. The initial image should no longer be checkered on |
285 // the active tree. | 254 // the active tree. |
286 checker_image_tracker_->DidActivateSyncTree(); | 255 checker_image_tracker_->DidActivateSyncTree(); |
287 | 256 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
288 draw_images.clear(); | 257 checkerable_image1.image(), WhichTree::ACTIVE_TREE)); |
289 checkered_images.clear(); | |
290 draw_images.push_back(checkerable_image1); | |
291 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
292 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
293 EXPECT_EQ(draw_images.size(), 1U); | |
294 EXPECT_EQ(checkered_images.size(), 0U); | |
295 } | 258 } |
296 | 259 |
297 } // namespace | 260 } // namespace |
298 } // namespace cc | 261 } // namespace cc |
OLD | NEW |