OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/resources/resource_pool.h" | 5 #include "cc/resources/resource_pool.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
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 26 matching lines...) Expand all Loading... |
37 std::unique_ptr<FakeOutputSurface> output_surface_; | 37 std::unique_ptr<FakeOutputSurface> output_surface_; |
38 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; | 38 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; |
39 std::unique_ptr<ResourceProvider> resource_provider_; | 39 std::unique_ptr<ResourceProvider> resource_provider_; |
40 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | 40 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; |
41 std::unique_ptr<ResourcePool> resource_pool_; | 41 std::unique_ptr<ResourcePool> resource_pool_; |
42 }; | 42 }; |
43 | 43 |
44 TEST_F(ResourcePoolTest, AcquireRelease) { | 44 TEST_F(ResourcePoolTest, AcquireRelease) { |
45 gfx::Size size(100, 100); | 45 gfx::Size size(100, 100); |
46 ResourceFormat format = RGBA_8888; | 46 ResourceFormat format = RGBA_8888; |
47 Resource* resource = resource_pool_->AcquireResource(size, format); | 47 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); |
| 48 Resource* resource = |
| 49 resource_pool_->AcquireResource(size, format, color_space); |
48 EXPECT_EQ(size, resource->size()); | 50 EXPECT_EQ(size, resource->size()); |
49 EXPECT_EQ(format, resource->format()); | 51 EXPECT_EQ(format, resource->format()); |
50 EXPECT_TRUE(resource_provider_->CanLockForWrite(resource->id())); | 52 EXPECT_TRUE(resource_provider_->CanLockForWrite(resource->id())); |
51 | 53 |
52 resource_pool_->ReleaseResource(resource); | 54 resource_pool_->ReleaseResource(resource); |
53 } | 55 } |
54 | 56 |
55 TEST_F(ResourcePoolTest, AccountingSingleResource) { | 57 TEST_F(ResourcePoolTest, AccountingSingleResource) { |
56 // Limits high enough to not be hit by this test. | 58 // Limits high enough to not be hit by this test. |
57 size_t bytes_limit = 10 * 1024 * 1024; | 59 size_t bytes_limit = 10 * 1024 * 1024; |
58 size_t count_limit = 100; | 60 size_t count_limit = 100; |
59 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 61 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
60 | 62 |
61 gfx::Size size(100, 100); | 63 gfx::Size size(100, 100); |
62 ResourceFormat format = RGBA_8888; | 64 ResourceFormat format = RGBA_8888; |
| 65 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); |
63 size_t resource_bytes = | 66 size_t resource_bytes = |
64 ResourceUtil::UncheckedSizeInBytes<size_t>(size, format); | 67 ResourceUtil::UncheckedSizeInBytes<size_t>(size, format); |
65 Resource* resource = resource_pool_->AcquireResource(size, format); | 68 Resource* resource = |
| 69 resource_pool_->AcquireResource(size, format, color_space); |
66 | 70 |
67 EXPECT_EQ(resource_bytes, resource_pool_->GetTotalMemoryUsageForTesting()); | 71 EXPECT_EQ(resource_bytes, resource_pool_->GetTotalMemoryUsageForTesting()); |
68 EXPECT_EQ(resource_bytes, resource_pool_->memory_usage_bytes()); | 72 EXPECT_EQ(resource_bytes, resource_pool_->memory_usage_bytes()); |
69 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); | 73 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); |
70 EXPECT_EQ(1u, resource_pool_->resource_count()); | 74 EXPECT_EQ(1u, resource_pool_->resource_count()); |
71 EXPECT_EQ(0u, resource_pool_->GetBusyResourceCountForTesting()); | 75 EXPECT_EQ(0u, resource_pool_->GetBusyResourceCountForTesting()); |
72 | 76 |
73 resource_pool_->ReleaseResource(resource); | 77 resource_pool_->ReleaseResource(resource); |
74 EXPECT_EQ(resource_bytes, resource_pool_->GetTotalMemoryUsageForTesting()); | 78 EXPECT_EQ(resource_bytes, resource_pool_->GetTotalMemoryUsageForTesting()); |
75 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); | 79 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); |
(...skipping 16 matching lines...) Expand all Loading... |
92 } | 96 } |
93 | 97 |
94 TEST_F(ResourcePoolTest, SimpleResourceReuse) { | 98 TEST_F(ResourcePoolTest, SimpleResourceReuse) { |
95 // Limits high enough to not be hit by this test. | 99 // Limits high enough to not be hit by this test. |
96 size_t bytes_limit = 10 * 1024 * 1024; | 100 size_t bytes_limit = 10 * 1024 * 1024; |
97 size_t count_limit = 100; | 101 size_t count_limit = 100; |
98 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 102 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
99 | 103 |
100 gfx::Size size(100, 100); | 104 gfx::Size size(100, 100); |
101 ResourceFormat format = RGBA_8888; | 105 ResourceFormat format = RGBA_8888; |
| 106 gfx::ColorSpace color_space1; |
| 107 gfx::ColorSpace color_space2 = gfx::ColorSpace::CreateSRGB(); |
102 | 108 |
103 Resource* resource = resource_pool_->AcquireResource(size, format); | 109 Resource* resource = |
| 110 resource_pool_->AcquireResource(size, format, color_space1); |
104 resource_pool_->ReleaseResource(resource); | 111 resource_pool_->ReleaseResource(resource); |
105 resource_pool_->CheckBusyResources(); | 112 resource_pool_->CheckBusyResources(); |
106 EXPECT_EQ(1u, resource_provider_->num_resources()); | 113 EXPECT_EQ(1u, resource_provider_->num_resources()); |
107 | 114 |
108 // Same size/format should re-use resource. | 115 // Same size/format should re-use resource. |
109 resource = resource_pool_->AcquireResource(size, format); | 116 resource = resource_pool_->AcquireResource(size, format, color_space1); |
110 EXPECT_EQ(1u, resource_provider_->num_resources()); | 117 EXPECT_EQ(1u, resource_provider_->num_resources()); |
111 resource_pool_->ReleaseResource(resource); | 118 resource_pool_->ReleaseResource(resource); |
112 resource_pool_->CheckBusyResources(); | 119 resource_pool_->CheckBusyResources(); |
113 EXPECT_EQ(1u, resource_provider_->num_resources()); | 120 EXPECT_EQ(1u, resource_provider_->num_resources()); |
114 | 121 |
115 // Different size/format should alloate new resource. | 122 // Different size/format should allocate new resource. |
116 resource = resource_pool_->AcquireResource(gfx::Size(50, 50), LUMINANCE_8); | 123 resource = resource_pool_->AcquireResource(gfx::Size(50, 50), LUMINANCE_8, |
| 124 color_space1); |
117 EXPECT_EQ(2u, resource_provider_->num_resources()); | 125 EXPECT_EQ(2u, resource_provider_->num_resources()); |
118 resource_pool_->ReleaseResource(resource); | 126 resource_pool_->ReleaseResource(resource); |
119 resource_pool_->CheckBusyResources(); | 127 resource_pool_->CheckBusyResources(); |
120 EXPECT_EQ(2u, resource_provider_->num_resources()); | 128 EXPECT_EQ(2u, resource_provider_->num_resources()); |
| 129 |
| 130 // Different color space should allocate new resource. |
| 131 resource = resource_pool_->AcquireResource(size, format, color_space2); |
| 132 EXPECT_EQ(3u, resource_provider_->num_resources()); |
| 133 resource_pool_->ReleaseResource(resource); |
| 134 resource_pool_->CheckBusyResources(); |
| 135 EXPECT_EQ(3u, resource_provider_->num_resources()); |
121 } | 136 } |
122 | 137 |
123 TEST_F(ResourcePoolTest, LostResource) { | 138 TEST_F(ResourcePoolTest, LostResource) { |
124 // Limits high enough to not be hit by this test. | 139 // Limits high enough to not be hit by this test. |
125 size_t bytes_limit = 10 * 1024 * 1024; | 140 size_t bytes_limit = 10 * 1024 * 1024; |
126 size_t count_limit = 100; | 141 size_t count_limit = 100; |
127 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 142 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
128 | 143 |
129 gfx::Size size(100, 100); | 144 gfx::Size size(100, 100); |
130 ResourceFormat format = RGBA_8888; | 145 ResourceFormat format = RGBA_8888; |
| 146 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); |
131 | 147 |
132 Resource* resource = resource_pool_->AcquireResource(size, format); | 148 Resource* resource = |
| 149 resource_pool_->AcquireResource(size, format, color_space); |
133 EXPECT_EQ(1u, resource_provider_->num_resources()); | 150 EXPECT_EQ(1u, resource_provider_->num_resources()); |
134 | 151 |
135 resource_provider_->LoseResourceForTesting(resource->id()); | 152 resource_provider_->LoseResourceForTesting(resource->id()); |
136 resource_pool_->ReleaseResource(resource); | 153 resource_pool_->ReleaseResource(resource); |
137 resource_pool_->CheckBusyResources(); | 154 resource_pool_->CheckBusyResources(); |
138 EXPECT_EQ(0u, resource_provider_->num_resources()); | 155 EXPECT_EQ(0u, resource_provider_->num_resources()); |
139 } | 156 } |
140 | 157 |
141 TEST_F(ResourcePoolTest, BusyResourcesEventuallyFreed) { | 158 TEST_F(ResourcePoolTest, BusyResourcesEventuallyFreed) { |
142 // Limits high enough to not be hit by this test. | 159 // Limits high enough to not be hit by this test. |
143 size_t bytes_limit = 10 * 1024 * 1024; | 160 size_t bytes_limit = 10 * 1024 * 1024; |
144 size_t count_limit = 100; | 161 size_t count_limit = 100; |
145 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 162 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
146 | 163 |
147 // Set a quick resource expiration delay so that this test doesn't take long | 164 // Set a quick resource expiration delay so that this test doesn't take long |
148 // to run. | 165 // to run. |
149 resource_pool_->SetResourceExpirationDelayForTesting( | 166 resource_pool_->SetResourceExpirationDelayForTesting( |
150 base::TimeDelta::FromMilliseconds(10)); | 167 base::TimeDelta::FromMilliseconds(10)); |
151 | 168 |
152 gfx::Size size(100, 100); | 169 gfx::Size size(100, 100); |
153 ResourceFormat format = RGBA_8888; | 170 ResourceFormat format = RGBA_8888; |
| 171 gfx::ColorSpace color_space; |
154 | 172 |
155 Resource* resource = resource_pool_->AcquireResource(size, format); | 173 Resource* resource = |
| 174 resource_pool_->AcquireResource(size, format, color_space); |
156 EXPECT_EQ(1u, resource_provider_->num_resources()); | 175 EXPECT_EQ(1u, resource_provider_->num_resources()); |
157 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); | 176 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); |
158 EXPECT_EQ(1u, resource_pool_->resource_count()); | 177 EXPECT_EQ(1u, resource_pool_->resource_count()); |
159 | 178 |
160 resource_pool_->ReleaseResource(resource); | 179 resource_pool_->ReleaseResource(resource); |
161 EXPECT_EQ(1u, resource_provider_->num_resources()); | 180 EXPECT_EQ(1u, resource_provider_->num_resources()); |
162 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); | 181 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); |
163 EXPECT_EQ(0u, resource_pool_->memory_usage_bytes()); | 182 EXPECT_EQ(0u, resource_pool_->memory_usage_bytes()); |
164 EXPECT_EQ(1u, resource_pool_->GetBusyResourceCountForTesting()); | 183 EXPECT_EQ(1u, resource_pool_->GetBusyResourceCountForTesting()); |
165 | 184 |
(...skipping 15 matching lines...) Expand all Loading... |
181 size_t count_limit = 100; | 200 size_t count_limit = 100; |
182 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 201 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
183 | 202 |
184 // Set a quick resource expiration delay so that this test doesn't take long | 203 // Set a quick resource expiration delay so that this test doesn't take long |
185 // to run. | 204 // to run. |
186 resource_pool_->SetResourceExpirationDelayForTesting( | 205 resource_pool_->SetResourceExpirationDelayForTesting( |
187 base::TimeDelta::FromMilliseconds(100)); | 206 base::TimeDelta::FromMilliseconds(100)); |
188 | 207 |
189 gfx::Size size(100, 100); | 208 gfx::Size size(100, 100); |
190 ResourceFormat format = RGBA_8888; | 209 ResourceFormat format = RGBA_8888; |
| 210 gfx::ColorSpace color_space; |
191 | 211 |
192 Resource* resource = resource_pool_->AcquireResource(size, format); | 212 Resource* resource = |
| 213 resource_pool_->AcquireResource(size, format, color_space); |
193 EXPECT_EQ(1u, resource_provider_->num_resources()); | 214 EXPECT_EQ(1u, resource_provider_->num_resources()); |
194 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); | 215 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); |
195 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); | 216 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); |
196 EXPECT_EQ(1u, resource_pool_->resource_count()); | 217 EXPECT_EQ(1u, resource_pool_->resource_count()); |
197 | 218 |
198 resource_pool_->ReleaseResource(resource); | 219 resource_pool_->ReleaseResource(resource); |
199 EXPECT_EQ(1u, resource_provider_->num_resources()); | 220 EXPECT_EQ(1u, resource_provider_->num_resources()); |
200 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); | 221 EXPECT_EQ(40000u, resource_pool_->GetTotalMemoryUsageForTesting()); |
201 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); | 222 EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting()); |
202 EXPECT_EQ(1u, resource_pool_->GetBusyResourceCountForTesting()); | 223 EXPECT_EQ(1u, resource_pool_->GetBusyResourceCountForTesting()); |
(...skipping 13 matching lines...) Expand all Loading... |
216 base::TimeDelta::FromMillisecondsD(200)); | 237 base::TimeDelta::FromMillisecondsD(200)); |
217 run_loop.Run(); | 238 run_loop.Run(); |
218 | 239 |
219 EXPECT_EQ(0u, resource_provider_->num_resources()); | 240 EXPECT_EQ(0u, resource_provider_->num_resources()); |
220 EXPECT_EQ(0u, resource_pool_->GetTotalMemoryUsageForTesting()); | 241 EXPECT_EQ(0u, resource_pool_->GetTotalMemoryUsageForTesting()); |
221 } | 242 } |
222 | 243 |
223 TEST_F(ResourcePoolTest, UpdateContentId) { | 244 TEST_F(ResourcePoolTest, UpdateContentId) { |
224 gfx::Size size(100, 100); | 245 gfx::Size size(100, 100); |
225 ResourceFormat format = RGBA_8888; | 246 ResourceFormat format = RGBA_8888; |
| 247 gfx::ColorSpace color_space; |
226 uint64_t content_id = 42; | 248 uint64_t content_id = 42; |
227 uint64_t new_content_id = 43; | 249 uint64_t new_content_id = 43; |
228 gfx::Rect new_invalidated_rect(20, 20, 10, 10); | 250 gfx::Rect new_invalidated_rect(20, 20, 10, 10); |
229 | 251 |
230 Resource* resource = resource_pool_->AcquireResource(size, format); | 252 Resource* resource = |
| 253 resource_pool_->AcquireResource(size, format, color_space); |
231 resource_pool_->OnContentReplaced(resource->id(), content_id); | 254 resource_pool_->OnContentReplaced(resource->id(), content_id); |
232 resource_pool_->ReleaseResource(resource); | 255 resource_pool_->ReleaseResource(resource); |
233 resource_pool_->CheckBusyResources(); | 256 resource_pool_->CheckBusyResources(); |
234 | 257 |
235 // Ensure that we can retrieve the resource based on |content_id|. | 258 // Ensure that we can retrieve the resource based on |content_id|. |
236 gfx::Rect invalidated_rect; | 259 gfx::Rect invalidated_rect; |
237 Resource* reacquired_resource = | 260 Resource* reacquired_resource = |
238 resource_pool_->TryAcquireResourceForPartialRaster( | 261 resource_pool_->TryAcquireResourceForPartialRaster( |
239 new_content_id, new_invalidated_rect, content_id, &invalidated_rect); | 262 new_content_id, new_invalidated_rect, content_id, &invalidated_rect); |
240 EXPECT_EQ(resource, reacquired_resource); | 263 EXPECT_EQ(resource, reacquired_resource); |
241 EXPECT_EQ(new_invalidated_rect, invalidated_rect); | 264 EXPECT_EQ(new_invalidated_rect, invalidated_rect); |
242 resource_pool_->ReleaseResource(reacquired_resource); | 265 resource_pool_->ReleaseResource(reacquired_resource); |
243 } | 266 } |
244 | 267 |
245 TEST_F(ResourcePoolTest, UpdateContentIdAndInvalidatedRect) { | 268 TEST_F(ResourcePoolTest, UpdateContentIdAndInvalidatedRect) { |
246 gfx::Size size(100, 100); | 269 gfx::Size size(100, 100); |
247 ResourceFormat format = RGBA_8888; | 270 ResourceFormat format = RGBA_8888; |
| 271 gfx::ColorSpace color_space; |
248 uint64_t content_ids[] = {42, 43, 44}; | 272 uint64_t content_ids[] = {42, 43, 44}; |
249 gfx::Rect invalidated_rect(20, 20, 10, 10); | 273 gfx::Rect invalidated_rect(20, 20, 10, 10); |
250 gfx::Rect second_invalidated_rect(25, 25, 10, 10); | 274 gfx::Rect second_invalidated_rect(25, 25, 10, 10); |
251 gfx::Rect expected_total_invalidated_rect(20, 20, 15, 15); | 275 gfx::Rect expected_total_invalidated_rect(20, 20, 15, 15); |
252 | 276 |
253 // Acquire a new resource with the first content id. | 277 // Acquire a new resource with the first content id. |
254 Resource* resource = resource_pool_->AcquireResource(size, format); | 278 Resource* resource = |
| 279 resource_pool_->AcquireResource(size, format, color_space); |
255 resource_pool_->OnContentReplaced(resource->id(), content_ids[0]); | 280 resource_pool_->OnContentReplaced(resource->id(), content_ids[0]); |
256 | 281 |
257 // Attempt to acquire this resource. It is in use, so its ID and invalidated | 282 // Attempt to acquire this resource. It is in use, so its ID and invalidated |
258 // rect should be updated, but a new resource will be returned. | 283 // rect should be updated, but a new resource will be returned. |
259 gfx::Rect new_invalidated_rect; | 284 gfx::Rect new_invalidated_rect; |
260 Resource* reacquired_resource = | 285 Resource* reacquired_resource = |
261 resource_pool_->TryAcquireResourceForPartialRaster( | 286 resource_pool_->TryAcquireResourceForPartialRaster( |
262 content_ids[1], invalidated_rect, content_ids[0], | 287 content_ids[1], invalidated_rect, content_ids[0], |
263 &new_invalidated_rect); | 288 &new_invalidated_rect); |
264 EXPECT_EQ(nullptr, reacquired_resource); | 289 EXPECT_EQ(nullptr, reacquired_resource); |
(...skipping 15 matching lines...) Expand all Loading... |
280 reacquired_resource = resource_pool_->TryAcquireResourceForPartialRaster( | 305 reacquired_resource = resource_pool_->TryAcquireResourceForPartialRaster( |
281 content_ids[2], second_invalidated_rect, content_ids[1], | 306 content_ids[2], second_invalidated_rect, content_ids[1], |
282 &total_invalidated_rect); | 307 &total_invalidated_rect); |
283 EXPECT_EQ(resource, reacquired_resource); | 308 EXPECT_EQ(resource, reacquired_resource); |
284 EXPECT_EQ(expected_total_invalidated_rect, total_invalidated_rect); | 309 EXPECT_EQ(expected_total_invalidated_rect, total_invalidated_rect); |
285 resource_pool_->ReleaseResource(reacquired_resource); | 310 resource_pool_->ReleaseResource(reacquired_resource); |
286 } | 311 } |
287 | 312 |
288 } // namespace | 313 } // namespace |
289 } // namespace cc | 314 } // namespace cc |
OLD | NEW |