OLD | NEW |
---|---|
(Empty) | |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include "cc/tiles/checker_image_tracker.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/memory/ptr_util.h" | |
9 #include "base/run_loop.h" | |
10 #include "base/threading/thread_task_runner_handle.h" | |
11 #include "cc/test/skia_common.h" | |
12 #include "cc/tiles/image_controller.h" | |
13 #include "testing/gtest/include/gtest/gtest.h" | |
14 | |
15 namespace cc { | |
16 namespace { | |
17 | |
18 class TestImageController : public ImageController { | |
19 public: | |
20 TestImageController() | |
21 : ImageController(base::ThreadTaskRunnerHandle::Get().get(), | |
22 base::ThreadTaskRunnerHandle::Get()) {} | |
vmpstr
2017/02/13 22:49:31
Hmm on shutdown I thought one of the threads waits
Khushal
2017/02/14 05:10:22
It doesn't go to stop the worker because we never
| |
23 | |
24 ~TestImageController() override { DCHECK_EQ(locked_images_.size(), 0U); } | |
25 | |
26 int num_of_locked_images() const { return locked_images_.size(); } | |
27 | |
28 void UnlockImageDecode(ImageDecodeRequestId id) override { | |
29 DCHECK_EQ(locked_images_.count(id), 1U); | |
30 locked_images_.erase(id); | |
31 } | |
32 | |
33 ImageDecodeRequestId QueueImageDecode( | |
34 sk_sp<const SkImage> image, | |
35 const ImageDecodedCallback& callback) override { | |
36 ImageDecodeRequestId request_id = next_image_request_id_++; | |
37 locked_images_.insert(request_id); | |
38 | |
39 // Post the callback asynchronously to match the behaviour in | |
40 // ImageController. | |
41 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
vmpstr
2017/02/13 22:49:31
You can use the underlying worker here, just make
Khushal
2017/02/14 05:10:23
Done.
| |
42 FROM_HERE, base::Bind(callback, request_id)); | |
43 | |
44 return request_id; | |
45 } | |
46 | |
47 private: | |
48 ImageDecodeRequestId next_image_request_id_ = 1U; | |
49 std::unordered_set<ImageDecodeRequestId> locked_images_; | |
50 }; | |
51 | |
52 class CheckerImageTrackerTest : public testing::Test, | |
53 public CheckerImageTrackerClient { | |
54 public: | |
55 void SetUpTracker(bool enabled) { | |
vmpstr
2017/02/13 22:49:31
rename the variable to something better like "chec
Khushal
2017/02/14 05:10:22
Done.
| |
56 checker_image_tracker_ = base::MakeUnique<CheckerImageTracker>( | |
57 &image_controller_, this, enabled); | |
58 } | |
59 | |
60 DrawImage CreateImage(bool checkerable) { | |
61 int width = checkerable ? 512 : 16; | |
vmpstr
2017/02/13 22:49:31
Make the constants kConstants at the top; s/width/
Khushal
2017/02/14 05:10:23
Done.
| |
62 sk_sp<SkImage> image = CreateDiscardableImage(gfx::Size(width, width)); | |
63 return DrawImage(image, SkIRect::MakeWH(image->width(), image->height()), | |
64 kNone_SkFilterQuality, SkMatrix::I()); | |
65 } | |
66 | |
67 // CheckerImageTrackerClient implementation. | |
68 void NeedsInvalidationForCheckerImagedTiles() override { | |
69 invalidation_request_pending_ = true; | |
70 } | |
71 | |
72 protected: | |
73 TestImageController image_controller_; | |
74 std::unique_ptr<CheckerImageTracker> checker_image_tracker_; | |
75 | |
76 bool invalidation_request_pending_ = false; | |
77 }; | |
78 | |
79 TEST_F(CheckerImageTrackerTest, Disabled) { | |
vmpstr
2017/02/13 22:49:31
s/Disabled/CheckerImagesDisabled/
Khushal
2017/02/14 05:10:22
Done.
| |
80 // Ensures that the tracker doesn't filter any images for checkering if it is | |
81 // disabled. | |
82 SetUpTracker(false); | |
83 | |
84 std::vector<DrawImage> draw_images; | |
85 ImageIdFlatSet checkered_images; | |
86 draw_images.push_back(CreateImage(true)); | |
87 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
88 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
89 EXPECT_EQ(draw_images.size(), 1U); | |
90 EXPECT_EQ(checkered_images.size(), 0U); | |
91 EXPECT_EQ(image_controller_.num_of_locked_images(), 0); | |
92 } | |
93 | |
94 TEST_F(CheckerImageTrackerTest, UpdatesImagesAtomically) { | |
95 // Ensures that the tracker updates images atomically for each frame. | |
96 SetUpTracker(true); | |
97 | |
98 DrawImage checkerable_image = CreateImage(true); | |
vmpstr
2017/02/13 22:49:31
instead of true/false, maybe make an enum with two
Khushal
2017/02/14 05:10:23
Done.
| |
99 DrawImage non_checkerable_image = CreateImage(false); | |
100 ImageIdFlatSet checkered_images; | |
101 std::vector<DrawImage> draw_images; | |
102 | |
103 // First request to filter images. | |
104 draw_images.clear(); | |
vmpstr
2017/02/13 22:49:31
don't need to clear if you just create it :)
Khushal
2017/02/14 05:10:23
I just copied this block everywhere. :P
Done.
| |
105 draw_images.push_back(checkerable_image); | |
106 draw_images.push_back(non_checkerable_image); | |
107 draw_images.push_back(checkerable_image); | |
108 checkered_images.clear(); | |
vmpstr
2017/02/13 22:49:31
same here
Khushal
2017/02/14 05:10:22
Done.
| |
109 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
110 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
111 | |
112 EXPECT_EQ(draw_images.size(), 1U); | |
113 EXPECT_EQ(draw_images[0].image(), non_checkerable_image.image()); | |
114 EXPECT_EQ(checkered_images.size(), 1U); | |
115 EXPECT_EQ(checkered_images.count(checkerable_image.image()->uniqueID()), 1U); | |
116 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | |
117 | |
118 // Run pending task to indicate completion of decode request to the tracker. | |
119 // This should send an impl-side invalidation request to the client. The | |
120 // images must remain locked until the sync tree to which the invalidations | |
121 // are added is activated. | |
122 base::RunLoop().RunUntilIdle(); | |
123 EXPECT_TRUE(invalidation_request_pending_); | |
124 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | |
125 | |
126 // Continue checkering the image until the set of images to invalidate is | |
127 // pulled. | |
128 draw_images.clear(); | |
129 draw_images.push_back(checkerable_image); | |
130 checkered_images.clear(); | |
131 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
132 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
133 EXPECT_EQ(draw_images.size(), 0U); | |
134 EXPECT_EQ(checkered_images.size(), 1U); | |
135 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | |
136 | |
137 std::unordered_set<ImageId> invalidated_images = | |
138 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | |
139 | |
140 // Use the same set of draw images to ensure that they are not checkered on | |
141 // the pending tree now. | |
142 draw_images.clear(); | |
143 draw_images.push_back(checkerable_image); | |
144 draw_images.push_back(non_checkerable_image); | |
145 checkered_images.clear(); | |
146 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
147 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
148 EXPECT_EQ(draw_images.size(), 2U); | |
149 EXPECT_EQ(checkered_images.size(), 0U); | |
150 | |
151 // Use this set to make the same request from the active tree, we should | |
152 // continue checkering this image on the active tree until activation. | |
153 draw_images.clear(); | |
154 draw_images.push_back(checkerable_image); | |
155 draw_images.push_back(non_checkerable_image); | |
156 checkered_images.clear(); | |
157 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
158 &draw_images, &checkered_images, WhichTree::ACTIVE_TREE); | |
159 EXPECT_EQ(draw_images.size(), 1U); | |
160 EXPECT_EQ(draw_images[0].image(), non_checkerable_image.image()); | |
161 EXPECT_EQ(checkered_images.size(), 1U); | |
162 EXPECT_EQ(checkered_images.count(checkerable_image.image()->uniqueID()), 1U); | |
163 | |
164 // Activate the sync tree. The images should be unlocked upon activation. | |
165 EXPECT_EQ(image_controller_.num_of_locked_images(), 1); | |
166 checker_image_tracker_->DidActivateSyncTree(); | |
167 } | |
168 | |
169 TEST_F(CheckerImageTrackerTest, NoConsecutiveCheckeringForImage) { | |
170 // Ensures that if an image is decoded and invalidated once, it is not | |
171 // checkered again in subsequent frames. | |
172 SetUpTracker(true); | |
173 | |
174 DrawImage checkerable_image = CreateImage(true); | |
175 DrawImage non_checkerable_image = CreateImage(false); | |
176 ImageIdFlatSet checkered_images; | |
177 std::vector<DrawImage> draw_images; | |
178 | |
179 draw_images.clear(); | |
180 draw_images.push_back(checkerable_image); | |
181 checkered_images.clear(); | |
182 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
183 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
184 EXPECT_EQ(draw_images.size(), 0U); | |
185 EXPECT_EQ(checkered_images.size(), 1U); | |
186 | |
187 // Trigger decode completion, take images to invalidate and activate the sync | |
188 // tree. | |
189 base::RunLoop().RunUntilIdle(); | |
190 checker_image_tracker_->TakeImagesToInvalidateOnSyncTree(); | |
191 checker_image_tracker_->DidActivateSyncTree(); | |
192 | |
193 // Subsequent requests for this image should not be checkered. | |
194 draw_images.clear(); | |
195 draw_images.push_back(checkerable_image); | |
196 checkered_images.clear(); | |
197 checker_image_tracker_->FilterImagesForCheckeringForTile( | |
198 &draw_images, &checkered_images, WhichTree::PENDING_TREE); | |
199 EXPECT_EQ(draw_images.size(), 1U); | |
200 EXPECT_EQ(checkered_images.size(), 0U); | |
201 } | |
202 | |
203 } // namespace | |
vmpstr
2017/02/13 22:49:31
I think we might need a few more tests, like thing
Khushal
2017/02/14 05:10:22
I added one more test for checkering on pending an
| |
204 } // namespace cc | |
OLD | NEW |