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 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
78 public: | 78 public: |
79 enum class ImageType { | 79 enum class ImageType { |
80 CHECKERABLE, | 80 CHECKERABLE, |
81 SMALL_NON_CHECKERABLE, | 81 SMALL_NON_CHECKERABLE, |
82 LARGE_NON_CHECKERABLE | 82 LARGE_NON_CHECKERABLE |
83 }; | 83 }; |
84 | 84 |
85 void SetUpTracker(bool checker_images_enabled) { | 85 void SetUpTracker(bool checker_images_enabled) { |
86 checker_image_tracker_ = base::MakeUnique<CheckerImageTracker>( | 86 checker_image_tracker_ = base::MakeUnique<CheckerImageTracker>( |
87 &image_controller_, this, checker_images_enabled); | 87 &image_controller_, this, checker_images_enabled); |
| 88 checker_image_tracker_->SetMaxDecodePriorityAllowed( |
| 89 CheckerImageTracker::DecodeType::kPreDecode); |
88 } | 90 } |
89 | 91 |
90 void TearDown() override { checker_image_tracker_.reset(); } | 92 void TearDown() override { checker_image_tracker_.reset(); } |
91 | 93 |
92 DrawImage CreateImage( | 94 DrawImage CreateImage( |
93 ImageType image_type, | 95 ImageType image_type, |
94 PaintImage::AnimationType animation = PaintImage::AnimationType::STATIC, | 96 PaintImage::AnimationType animation = PaintImage::AnimationType::STATIC, |
95 PaintImage::CompletionState completion = | 97 PaintImage::CompletionState completion = |
96 PaintImage::CompletionState::DONE, | 98 PaintImage::CompletionState::DONE, |
97 bool is_multipart = false) { | 99 bool is_multipart = false) { |
(...skipping 17 matching lines...) Expand all Loading... |
115 SkIRect::MakeWH(dimension, dimension), | 117 SkIRect::MakeWH(dimension, dimension), |
116 kNone_SkFilterQuality, SkMatrix::I(), gfx::ColorSpace()); | 118 kNone_SkFilterQuality, SkMatrix::I(), gfx::ColorSpace()); |
117 } | 119 } |
118 | 120 |
119 CheckerImageTracker::ImageDecodeQueue BuildImageDecodeQueue( | 121 CheckerImageTracker::ImageDecodeQueue BuildImageDecodeQueue( |
120 std::vector<DrawImage> images, | 122 std::vector<DrawImage> images, |
121 WhichTree tree) { | 123 WhichTree tree) { |
122 CheckerImageTracker::ImageDecodeQueue decode_queue; | 124 CheckerImageTracker::ImageDecodeQueue decode_queue; |
123 for (const auto& image : images) { | 125 for (const auto& image : images) { |
124 if (checker_image_tracker_->ShouldCheckerImage(image, tree)) | 126 if (checker_image_tracker_->ShouldCheckerImage(image, tree)) |
125 decode_queue.push_back(image.paint_image()); | 127 decode_queue.push_back(CheckerImageTracker::ImageDecodeRequest( |
| 128 image.paint_image(), CheckerImageTracker::DecodeType::kRaster)); |
126 } | 129 } |
127 return decode_queue; | 130 return decode_queue; |
128 } | 131 } |
129 | 132 |
130 // CheckerImageTrackerClient implementation. | 133 // CheckerImageTrackerClient implementation. |
131 void NeedsInvalidationForCheckerImagedTiles() override { | 134 void NeedsInvalidationForCheckerImagedTiles() override { |
132 invalidation_request_pending_ = true; | 135 invalidation_request_pending_ = true; |
133 } | 136 } |
134 | 137 |
135 protected: | 138 protected: |
(...skipping 27 matching lines...) Expand all Loading... |
163 CheckerImageTracker::ImageDecodeQueue image_decode_queue; | 166 CheckerImageTracker::ImageDecodeQueue image_decode_queue; |
164 | 167 |
165 // First request to filter images. | 168 // First request to filter images. |
166 std::vector<DrawImage> draw_images = { | 169 std::vector<DrawImage> draw_images = { |
167 checkerable_image, small_non_checkerable_image, | 170 checkerable_image, small_non_checkerable_image, |
168 large_non_checkerable_image, checkerable_image}; | 171 large_non_checkerable_image, checkerable_image}; |
169 image_decode_queue = | 172 image_decode_queue = |
170 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); | 173 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
171 | 174 |
172 ASSERT_EQ(2u, image_decode_queue.size()); | 175 ASSERT_EQ(2u, image_decode_queue.size()); |
173 EXPECT_EQ(checkerable_image.paint_image(), image_decode_queue[0]); | 176 EXPECT_EQ(checkerable_image.paint_image(), image_decode_queue[0].paint_image); |
174 EXPECT_EQ(checkerable_image.paint_image(), image_decode_queue[1]); | 177 EXPECT_EQ(checkerable_image.paint_image(), image_decode_queue[1].paint_image); |
175 | 178 |
176 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); | 179 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
177 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | 180 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); |
178 | 181 |
179 // Run pending task to indicate completion of decode request to the tracker. | 182 // Run pending task to indicate completion of decode request to the tracker. |
180 // This should send an impl-side invalidation request to the client. The | 183 // This should send an impl-side invalidation request to the client. The |
181 // images must remain locked until the sync tree to which the invalidations | 184 // images must remain locked until the sync tree to which the invalidations |
182 // are added is activated. | 185 // are added is activated. |
183 base::RunLoop().RunUntilIdle(); | 186 base::RunLoop().RunUntilIdle(); |
184 EXPECT_TRUE(invalidation_request_pending_); | 187 EXPECT_TRUE(invalidation_request_pending_); |
(...skipping 224 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
409 CreateImage(ImageType::CHECKERABLE, PaintImage::AnimationType::STATIC, | 412 CreateImage(ImageType::CHECKERABLE, PaintImage::AnimationType::STATIC, |
410 PaintImage::CompletionState::PARTIALLY_DONE); | 413 PaintImage::CompletionState::PARTIALLY_DONE); |
411 DrawImage video_image = | 414 DrawImage video_image = |
412 CreateImage(ImageType::CHECKERABLE, PaintImage::AnimationType::VIDEO); | 415 CreateImage(ImageType::CHECKERABLE, PaintImage::AnimationType::VIDEO); |
413 std::vector<DrawImage> draw_images = {static_image, animated_image, | 416 std::vector<DrawImage> draw_images = {static_image, animated_image, |
414 partial_image, video_image}; | 417 partial_image, video_image}; |
415 | 418 |
416 CheckerImageTracker::ImageDecodeQueue image_decode_queue = | 419 CheckerImageTracker::ImageDecodeQueue image_decode_queue = |
417 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); | 420 BuildImageDecodeQueue(draw_images, WhichTree::PENDING_TREE); |
418 EXPECT_EQ(image_decode_queue.size(), 1U); | 421 EXPECT_EQ(image_decode_queue.size(), 1U); |
419 EXPECT_EQ(image_decode_queue[0], static_image.paint_image()); | 422 EXPECT_EQ(image_decode_queue[0].paint_image, static_image.paint_image()); |
420 | 423 |
421 // Change the partial image to complete and try again. It should sstill not | 424 // Change the partial image to complete and try again. It should sstill not |
422 // be checkered. | 425 // be checkered. |
423 gfx::Size image_size = gfx::Size(partial_image.image()->width(), | 426 gfx::Size image_size = gfx::Size(partial_image.image()->width(), |
424 partial_image.image()->height()); | 427 partial_image.image()->height()); |
425 DrawImage completed_paint_image = | 428 DrawImage completed_paint_image = |
426 DrawImage(PaintImage(partial_image.paint_image().stable_id(), | 429 DrawImage(PaintImage(partial_image.paint_image().stable_id(), |
427 CreateDiscardableImage(image_size)), | 430 CreateDiscardableImage(image_size)), |
428 SkIRect::MakeWH(image_size.width(), image_size.height()), | 431 SkIRect::MakeWH(image_size.width(), image_size.height()), |
429 kNone_SkFilterQuality, SkMatrix::I(), gfx::ColorSpace()); | 432 kNone_SkFilterQuality, SkMatrix::I(), gfx::ColorSpace()); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
481 CreateImage(ImageType::CHECKERABLE, PaintImage::AnimationType::STATIC, | 484 CreateImage(ImageType::CHECKERABLE, PaintImage::AnimationType::STATIC, |
482 PaintImage::CompletionState::DONE, true); | 485 PaintImage::CompletionState::DONE, true); |
483 EXPECT_TRUE(multi_part_image.paint_image().is_multipart()); | 486 EXPECT_TRUE(multi_part_image.paint_image().is_multipart()); |
484 | 487 |
485 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( | 488 EXPECT_TRUE(checker_image_tracker_->ShouldCheckerImage( |
486 image, WhichTree::PENDING_TREE)); | 489 image, WhichTree::PENDING_TREE)); |
487 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( | 490 EXPECT_FALSE(checker_image_tracker_->ShouldCheckerImage( |
488 multi_part_image, WhichTree::PENDING_TREE)); | 491 multi_part_image, WhichTree::PENDING_TREE)); |
489 } | 492 } |
490 | 493 |
| 494 TEST_F(CheckerImageTrackerTest, RespectsDecodePriority) { |
| 495 SetUpTracker(true); |
| 496 |
| 497 DrawImage image1 = CreateImage(ImageType::CHECKERABLE); |
| 498 DrawImage image2 = CreateImage(ImageType::CHECKERABLE); |
| 499 DrawImage image3 = CreateImage(ImageType::CHECKERABLE); |
| 500 DrawImage image4 = CreateImage(ImageType::CHECKERABLE); |
| 501 CheckerImageTracker::ImageDecodeQueue image_decode_queue = |
| 502 BuildImageDecodeQueue({image1, image2, image3, image4}, |
| 503 WhichTree::PENDING_TREE); |
| 504 |
| 505 // Mark the last 2 images as pre-decode. |
| 506 EXPECT_EQ(image_decode_queue.size(), 4u); |
| 507 image_decode_queue[2].type = CheckerImageTracker::DecodeType::kPreDecode; |
| 508 image_decode_queue[3].type = CheckerImageTracker::DecodeType::kPreDecode; |
| 509 |
| 510 // No decodes allowed. Nothing should be scheduled. |
| 511 EXPECT_EQ(image_controller_.decoded_images().size(), 0u); |
| 512 checker_image_tracker_->SetNoDecodesAllowed(); |
| 513 checker_image_tracker_->ScheduleImageDecodeQueue(image_decode_queue); |
| 514 EXPECT_EQ(image_controller_.decoded_images().size(), 0u); |
| 515 |
| 516 // Raster decodes allowed. Only those should be scheduled. |
| 517 checker_image_tracker_->SetMaxDecodePriorityAllowed( |
| 518 CheckerImageTracker::DecodeType::kRaster); |
| 519 base::RunLoop().RunUntilIdle(); |
| 520 EXPECT_EQ(image_controller_.decoded_images().size(), 2u); |
| 521 EXPECT_EQ(image_controller_.decoded_images()[0], image1); |
| 522 EXPECT_EQ(image_controller_.decoded_images()[1], image2); |
| 523 |
| 524 // All decodes allowed. The complete queue should be flushed. |
| 525 checker_image_tracker_->SetMaxDecodePriorityAllowed( |
| 526 CheckerImageTracker::DecodeType::kPreDecode); |
| 527 base::RunLoop().RunUntilIdle(); |
| 528 EXPECT_EQ(image_controller_.decoded_images()[0], image1); |
| 529 EXPECT_EQ(image_controller_.decoded_images()[1], image2); |
| 530 EXPECT_EQ(image_controller_.decoded_images()[2], image3); |
| 531 EXPECT_EQ(image_controller_.decoded_images()[3], image4); |
| 532 } |
| 533 |
491 } // namespace | 534 } // namespace |
492 } // namespace cc | 535 } // namespace cc |
OLD | NEW |