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 11 matching lines...) Expand all Loading... | |
22 void SetUp() override { | 22 void SetUp() override { |
23 context_provider_ = TestContextProvider::Create(); | 23 context_provider_ = TestContextProvider::Create(); |
24 context_provider_->BindToCurrentThread(); | 24 context_provider_->BindToCurrentThread(); |
25 shared_bitmap_manager_.reset(new TestSharedBitmapManager); | 25 shared_bitmap_manager_.reset(new TestSharedBitmapManager); |
26 resource_provider_ = FakeResourceProvider::Create( | 26 resource_provider_ = FakeResourceProvider::Create( |
27 context_provider_.get(), shared_bitmap_manager_.get()); | 27 context_provider_.get(), shared_bitmap_manager_.get()); |
28 task_runner_ = base::ThreadTaskRunnerHandle::Get(); | 28 task_runner_ = base::ThreadTaskRunnerHandle::Get(); |
29 resource_pool_ = | 29 resource_pool_ = |
30 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), | 30 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), |
31 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 31 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
32 ResourcePool::kDefaultExpirationDelay); | 32 ResourcePool::kDefaultExpirationDelay, false); |
33 } | 33 } |
34 | 34 |
35 protected: | 35 protected: |
36 void CheckAndReturnResource(Resource* resource) { | |
37 EXPECT_NE(nullptr, resource); | |
38 resource_pool_->ReleaseResource(resource); | |
39 resource_pool_->CheckBusyResources(); | |
40 } | |
41 | |
36 scoped_refptr<TestContextProvider> context_provider_; | 42 scoped_refptr<TestContextProvider> context_provider_; |
37 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; | 43 std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_; |
38 std::unique_ptr<ResourceProvider> resource_provider_; | 44 std::unique_ptr<ResourceProvider> resource_provider_; |
39 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | 45 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; |
40 std::unique_ptr<ResourcePool> resource_pool_; | 46 std::unique_ptr<ResourcePool> resource_pool_; |
41 }; | 47 }; |
42 | 48 |
43 TEST_F(ResourcePoolTest, AcquireRelease) { | 49 TEST_F(ResourcePoolTest, AcquireRelease) { |
44 gfx::Size size(100, 100); | 50 gfx::Size size(100, 100); |
45 ResourceFormat format = RGBA_8888; | 51 ResourceFormat format = RGBA_8888; |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
98 // Limits high enough to not be hit by this test. | 104 // Limits high enough to not be hit by this test. |
99 size_t bytes_limit = 10 * 1024 * 1024; | 105 size_t bytes_limit = 10 * 1024 * 1024; |
100 size_t count_limit = 100; | 106 size_t count_limit = 100; |
101 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 107 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
102 | 108 |
103 gfx::Size size(100, 100); | 109 gfx::Size size(100, 100); |
104 ResourceFormat format = RGBA_8888; | 110 ResourceFormat format = RGBA_8888; |
105 gfx::ColorSpace color_space1; | 111 gfx::ColorSpace color_space1; |
106 gfx::ColorSpace color_space2 = gfx::ColorSpace::CreateSRGB(); | 112 gfx::ColorSpace color_space2 = gfx::ColorSpace::CreateSRGB(); |
107 | 113 |
108 Resource* resource = | 114 CheckAndReturnResource( |
109 resource_pool_->AcquireResource(size, format, color_space1); | 115 resource_pool_->AcquireResource(size, format, color_space1)); |
110 resource_pool_->ReleaseResource(resource); | |
111 resource_pool_->CheckBusyResources(); | |
112 EXPECT_EQ(1u, resource_provider_->num_resources()); | 116 EXPECT_EQ(1u, resource_provider_->num_resources()); |
113 | 117 |
114 // Same size/format should re-use resource. | 118 // Same size/format should re-use resource. |
115 resource = resource_pool_->AcquireResource(size, format, color_space1); | 119 Resource* resource = |
120 resource_pool_->AcquireResource(size, format, color_space1); | |
116 EXPECT_EQ(1u, resource_provider_->num_resources()); | 121 EXPECT_EQ(1u, resource_provider_->num_resources()); |
117 resource_pool_->ReleaseResource(resource); | 122 CheckAndReturnResource(resource); |
118 resource_pool_->CheckBusyResources(); | |
119 EXPECT_EQ(1u, resource_provider_->num_resources()); | 123 EXPECT_EQ(1u, resource_provider_->num_resources()); |
120 | 124 |
121 // Different size/format should allocate new resource. | 125 // Different size/format should allocate new resource. |
122 resource = resource_pool_->AcquireResource(gfx::Size(50, 50), LUMINANCE_8, | 126 resource = resource_pool_->AcquireResource(gfx::Size(50, 50), LUMINANCE_8, |
123 color_space1); | 127 color_space1); |
124 EXPECT_EQ(2u, resource_provider_->num_resources()); | 128 EXPECT_EQ(2u, resource_provider_->num_resources()); |
125 resource_pool_->ReleaseResource(resource); | 129 CheckAndReturnResource(resource); |
126 resource_pool_->CheckBusyResources(); | |
127 EXPECT_EQ(2u, resource_provider_->num_resources()); | 130 EXPECT_EQ(2u, resource_provider_->num_resources()); |
128 | 131 |
129 // Different color space should allocate new resource. | 132 // Different color space should allocate new resource. |
130 resource = resource_pool_->AcquireResource(size, format, color_space2); | 133 resource = resource_pool_->AcquireResource(size, format, color_space2); |
131 EXPECT_EQ(3u, resource_provider_->num_resources()); | 134 EXPECT_EQ(3u, resource_provider_->num_resources()); |
132 resource_pool_->ReleaseResource(resource); | 135 CheckAndReturnResource(resource); |
133 resource_pool_->CheckBusyResources(); | |
134 EXPECT_EQ(3u, resource_provider_->num_resources()); | 136 EXPECT_EQ(3u, resource_provider_->num_resources()); |
135 } | 137 } |
136 | 138 |
137 TEST_F(ResourcePoolTest, LostResource) { | 139 TEST_F(ResourcePoolTest, LostResource) { |
138 // Limits high enough to not be hit by this test. | 140 // Limits high enough to not be hit by this test. |
139 size_t bytes_limit = 10 * 1024 * 1024; | 141 size_t bytes_limit = 10 * 1024 * 1024; |
140 size_t count_limit = 100; | 142 size_t count_limit = 100; |
141 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 143 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
142 | 144 |
143 gfx::Size size(100, 100); | 145 gfx::Size size(100, 100); |
144 ResourceFormat format = RGBA_8888; | 146 ResourceFormat format = RGBA_8888; |
145 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); | 147 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); |
146 | 148 |
147 Resource* resource = | 149 Resource* resource = |
148 resource_pool_->AcquireResource(size, format, color_space); | 150 resource_pool_->AcquireResource(size, format, color_space); |
149 EXPECT_EQ(1u, resource_provider_->num_resources()); | 151 EXPECT_EQ(1u, resource_provider_->num_resources()); |
150 | 152 |
151 resource_provider_->LoseResourceForTesting(resource->id()); | 153 resource_provider_->LoseResourceForTesting(resource->id()); |
152 resource_pool_->ReleaseResource(resource); | 154 resource_pool_->ReleaseResource(resource); |
153 resource_pool_->CheckBusyResources(); | 155 resource_pool_->CheckBusyResources(); |
154 EXPECT_EQ(0u, resource_provider_->num_resources()); | 156 EXPECT_EQ(0u, resource_provider_->num_resources()); |
155 } | 157 } |
156 | 158 |
157 TEST_F(ResourcePoolTest, BusyResourcesEventuallyFreed) { | 159 TEST_F(ResourcePoolTest, BusyResourcesEventuallyFreed) { |
158 // Set a quick resource expiration delay so that this test doesn't take long | 160 // Set a quick resource expiration delay so that this test doesn't take long |
159 // to run. | 161 // to run. |
160 resource_pool_ = | 162 resource_pool_ = |
161 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), | 163 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), |
162 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 164 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
163 base::TimeDelta::FromMilliseconds(10)); | 165 base::TimeDelta::FromMilliseconds(10), false); |
164 | 166 |
165 // Limits high enough to not be hit by this test. | 167 // Limits high enough to not be hit by this test. |
166 size_t bytes_limit = 10 * 1024 * 1024; | 168 size_t bytes_limit = 10 * 1024 * 1024; |
167 size_t count_limit = 100; | 169 size_t count_limit = 100; |
168 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 170 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
169 | 171 |
170 gfx::Size size(100, 100); | 172 gfx::Size size(100, 100); |
171 ResourceFormat format = RGBA_8888; | 173 ResourceFormat format = RGBA_8888; |
172 gfx::ColorSpace color_space; | 174 gfx::ColorSpace color_space; |
173 | 175 |
(...skipping 20 matching lines...) Expand all Loading... | |
194 EXPECT_EQ(0u, resource_pool_->GetTotalMemoryUsageForTesting()); | 196 EXPECT_EQ(0u, resource_pool_->GetTotalMemoryUsageForTesting()); |
195 EXPECT_EQ(0u, resource_pool_->memory_usage_bytes()); | 197 EXPECT_EQ(0u, resource_pool_->memory_usage_bytes()); |
196 } | 198 } |
197 | 199 |
198 TEST_F(ResourcePoolTest, UnusedResourcesEventuallyFreed) { | 200 TEST_F(ResourcePoolTest, UnusedResourcesEventuallyFreed) { |
199 // Set a quick resource expiration delay so that this test doesn't take long | 201 // Set a quick resource expiration delay so that this test doesn't take long |
200 // to run. | 202 // to run. |
201 resource_pool_ = | 203 resource_pool_ = |
202 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), | 204 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), |
203 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 205 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
204 base::TimeDelta::FromMilliseconds(100)); | 206 base::TimeDelta::FromMilliseconds(100), false); |
205 | 207 |
206 // Limits high enough to not be hit by this test. | 208 // Limits high enough to not be hit by this test. |
207 size_t bytes_limit = 10 * 1024 * 1024; | 209 size_t bytes_limit = 10 * 1024 * 1024; |
208 size_t count_limit = 100; | 210 size_t count_limit = 100; |
209 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 211 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
210 | 212 |
211 gfx::Size size(100, 100); | 213 gfx::Size size(100, 100); |
212 ResourceFormat format = RGBA_8888; | 214 ResourceFormat format = RGBA_8888; |
213 gfx::ColorSpace color_space; | 215 gfx::ColorSpace color_space; |
214 | 216 |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
310 &total_invalidated_rect); | 312 &total_invalidated_rect); |
311 EXPECT_EQ(resource, reacquired_resource); | 313 EXPECT_EQ(resource, reacquired_resource); |
312 EXPECT_EQ(expected_total_invalidated_rect, total_invalidated_rect); | 314 EXPECT_EQ(expected_total_invalidated_rect, total_invalidated_rect); |
313 resource_pool_->ReleaseResource(reacquired_resource); | 315 resource_pool_->ReleaseResource(reacquired_resource); |
314 } | 316 } |
315 | 317 |
316 TEST_F(ResourcePoolTest, ReuseResource) { | 318 TEST_F(ResourcePoolTest, ReuseResource) { |
317 ResourceFormat format = RGBA_8888; | 319 ResourceFormat format = RGBA_8888; |
318 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); | 320 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB(); |
319 | 321 |
320 // Create unused resources with sizes close to 100, 100. | 322 // Create unused resource with size 100x100. |
321 resource_pool_->ReleaseResource( | 323 CheckAndReturnResource( |
322 resource_pool_->CreateResource(gfx::Size(99, 100), format, color_space)); | 324 resource_pool_->CreateResource(gfx::Size(100, 100), format, color_space)); |
323 resource_pool_->ReleaseResource( | |
324 resource_pool_->CreateResource(gfx::Size(99, 99), format, color_space)); | |
325 resource_pool_->ReleaseResource( | |
326 resource_pool_->CreateResource(gfx::Size(100, 99), format, color_space)); | |
327 resource_pool_->ReleaseResource( | |
328 resource_pool_->CreateResource(gfx::Size(101, 101), format, color_space)); | |
329 resource_pool_->CheckBusyResources(); | |
330 | 325 |
331 gfx::Size size(100, 100); | 326 // Try some cases that are too large, none should succeed. |
332 Resource* resource = resource_pool_->ReuseResource(size, format, color_space); | 327 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(101, 100), format, |
333 EXPECT_EQ(nullptr, resource); | 328 color_space)); |
334 size = gfx::Size(100, 99); | 329 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 101), format, |
335 resource = resource_pool_->ReuseResource(size, format, color_space); | 330 color_space)); |
336 EXPECT_NE(nullptr, resource); | 331 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(90, 120), format, |
337 ASSERT_EQ(nullptr, resource_pool_->ReuseResource(size, format, color_space)); | 332 color_space)); |
338 resource_pool_->ReleaseResource(resource); | 333 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(120, 120), format, |
334 color_space)); | |
335 | |
336 // Try some cases that are more than 2x smaller than 100x100 in area and | |
337 // won't be re-used. | |
338 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(49, 100), format, | |
339 color_space)); | |
340 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 49), format, | |
341 color_space)); | |
342 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(50, 50), format, | |
343 color_space)); | |
344 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(70, 70), format, | |
345 color_space)); | |
346 | |
347 // Try some cases that are smaller than 100x100, but within 2x area. Reuse | |
348 // should succeed. | |
349 CheckAndReturnResource( | |
350 resource_pool_->ReuseResource(gfx::Size(50, 100), format, color_space)); | |
351 CheckAndReturnResource( | |
352 resource_pool_->ReuseResource(gfx::Size(100, 50), format, color_space)); | |
353 CheckAndReturnResource( | |
354 resource_pool_->ReuseResource(gfx::Size(71, 71), format, color_space)); | |
355 | |
356 // 100x100 is an exact match and should succeed. A subsequent request for | |
357 // the same size should fail (the resource is already in use). | |
358 Resource* resource = | |
359 resource_pool_->ReuseResource(gfx::Size(100, 100), format, color_space); | |
360 EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 100), format, | |
361 color_space)); | |
362 CheckAndReturnResource(resource); | |
339 } | 363 } |
340 | 364 |
341 TEST_F(ResourcePoolTest, MemoryStateSuspended) { | 365 TEST_F(ResourcePoolTest, MemoryStateSuspended) { |
342 // Limits high enough to not be hit by this test. | 366 // Limits high enough to not be hit by this test. |
343 size_t bytes_limit = 10 * 1024 * 1024; | 367 size_t bytes_limit = 10 * 1024 * 1024; |
344 size_t count_limit = 100; | 368 size_t count_limit = 100; |
345 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); | 369 resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit); |
346 | 370 |
347 gfx::Size size(100, 100); | 371 gfx::Size size(100, 100); |
348 ResourceFormat format = RGBA_8888; | 372 ResourceFormat format = RGBA_8888; |
(...skipping 24 matching lines...) Expand all Loading... | |
373 } | 397 } |
374 | 398 |
375 TEST_F(ResourcePoolTest, TextureHintRespected) { | 399 TEST_F(ResourcePoolTest, TextureHintRespected) { |
376 gfx::Size size(100, 100); | 400 gfx::Size size(100, 100); |
377 ResourceFormat format = RGBA_8888; | 401 ResourceFormat format = RGBA_8888; |
378 gfx::ColorSpace color_space; | 402 gfx::ColorSpace color_space; |
379 | 403 |
380 resource_pool_ = | 404 resource_pool_ = |
381 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), | 405 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), |
382 ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 406 ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
383 base::TimeDelta::FromMilliseconds(100)); | 407 base::TimeDelta::FromMilliseconds(100), false); |
danakj
2017/05/04 21:48:37
Add a test with true?
ericrk
2017/05/05 23:18:38
added.
| |
384 Resource* resource = | 408 Resource* resource = |
385 resource_pool_->AcquireResource(size, format, color_space); | 409 resource_pool_->AcquireResource(size, format, color_space); |
386 EXPECT_TRUE(resource_provider_->IsImmutable(resource->id())); | 410 EXPECT_TRUE(resource_provider_->IsImmutable(resource->id())); |
387 resource_pool_->ReleaseResource(resource); | 411 resource_pool_->ReleaseResource(resource); |
388 | 412 |
389 resource_pool_ = | 413 resource_pool_ = |
390 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), | 414 ResourcePool::Create(resource_provider_.get(), task_runner_.get(), |
391 ResourceProvider::TEXTURE_HINT_DEFAULT, | 415 ResourceProvider::TEXTURE_HINT_DEFAULT, |
392 base::TimeDelta::FromMilliseconds(100)); | 416 base::TimeDelta::FromMilliseconds(100), false); |
393 resource = resource_pool_->AcquireResource(size, format, color_space); | 417 resource = resource_pool_->AcquireResource(size, format, color_space); |
394 EXPECT_FALSE(resource_provider_->IsImmutable(resource->id())); | 418 EXPECT_FALSE(resource_provider_->IsImmutable(resource->id())); |
395 resource_pool_->ReleaseResource(resource); | 419 resource_pool_->ReleaseResource(resource); |
396 } | 420 } |
397 | 421 |
398 } // namespace cc | 422 } // namespace cc |
OLD | NEW |