Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(139)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/resources/prioritized_resource_unittest.cc

Issue 13051003: cpplint.py pass on cc/(base|debug|quads|resources)/ (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix prioritized_resource_unittest Created 7 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/resources/prioritized_resource_manager.cc ('k') | cc/resources/priority_calculator.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/resources/prioritized_resource_unittest.cc
diff --git a/cc/resources/prioritized_resource_unittest.cc b/cc/resources/prioritized_resource_unittest.cc
index 98e498556739f02035ba15e3e352d1fa16dc6afe..58a938dfbcbcf65e971db1d2b02ce546c10757b3 100644
--- a/cc/resources/prioritized_resource_unittest.cc
+++ b/cc/resources/prioritized_resource_unittest.cc
@@ -16,773 +16,776 @@ namespace cc {
class PrioritizedResourceTest : public testing::Test {
public:
- PrioritizedResourceTest()
- : proxy_(scoped_ptr<Thread>(NULL)),
- texture_size_(256, 256),
- texture_format_(GL_RGBA),
- output_surface_(CreateFakeOutputSurface()) {
- DebugScopedSetImplThread impl_thread(&proxy_);
- resource_provider_ = cc::ResourceProvider::Create(output_surface_.get());
- }
-
- virtual ~PrioritizedResourceTest() {
- DebugScopedSetImplThread impl_thread(&proxy_);
- resource_provider_.reset();
- }
-
- size_t TexturesMemorySize(size_t texture_count) {
- return Resource::MemorySizeBytes(texture_size_, texture_format_) *
- texture_count;
- }
-
- scoped_ptr<PrioritizedResourceManager> CreateManager(size_t max_textures) {
- scoped_ptr<PrioritizedResourceManager> manager =
- PrioritizedResourceManager::Create(&proxy_);
- manager->SetMaxMemoryLimitBytes(TexturesMemorySize(max_textures));
- return manager.Pass();
- }
-
- bool ValidateTexture(scoped_ptr<PrioritizedResource>& texture,
- bool request_late) {
- ResourceManagerAssertInvariants(texture->resource_manager());
- if (request_late)
- texture->RequestLate();
- ResourceManagerAssertInvariants(texture->resource_manager());
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- bool success = texture->can_acquire_backing_texture();
- if (success)
- texture->AcquireBackingTexture(ResourceProvider());
- return success;
- }
-
- void PrioritizeTexturesAndBackings(
- PrioritizedResourceManager* resource_manager) {
- resource_manager->PrioritizeTextures();
- ResourceManagerUpdateBackingsPriorities(resource_manager);
- }
-
- void ResourceManagerUpdateBackingsPriorities(
- PrioritizedResourceManager* resource_manager) {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->PushTexturePrioritiesToBackings();
- }
-
- cc::ResourceProvider* ResourceProvider() { return resource_provider_.get(); }
-
- void ResourceManagerAssertInvariants(
- PrioritizedResourceManager* resource_manager) {
+ PrioritizedResourceTest()
+ : proxy_(scoped_ptr<Thread>(NULL)),
+ texture_size_(256, 256),
+ texture_format_(GL_RGBA),
+ output_surface_(CreateFakeOutputSurface()) {
+ DebugScopedSetImplThread impl_thread(&proxy_);
+ resource_provider_ = cc::ResourceProvider::Create(output_surface_.get());
+ }
+
+ virtual ~PrioritizedResourceTest() {
+ DebugScopedSetImplThread impl_thread(&proxy_);
+ resource_provider_.reset();
+ }
+
+ size_t TexturesMemorySize(size_t texture_count) {
+ return Resource::MemorySizeBytes(texture_size_, texture_format_) *
+ texture_count;
+ }
+
+ scoped_ptr<PrioritizedResourceManager> CreateManager(size_t max_textures) {
+ scoped_ptr<PrioritizedResourceManager> manager =
+ PrioritizedResourceManager::Create(&proxy_);
+ manager->SetMaxMemoryLimitBytes(TexturesMemorySize(max_textures));
+ return manager.Pass();
+ }
+
+ bool ValidateTexture(PrioritizedResource* texture,
+ bool request_late) {
+ ResourceManagerAssertInvariants(texture->resource_manager());
+ if (request_late)
+ texture->RequestLate();
+ ResourceManagerAssertInvariants(texture->resource_manager());
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ bool success = texture->can_acquire_backing_texture();
+ if (success)
+ texture->AcquireBackingTexture(ResourceProvider());
+ return success;
+ }
+
+ void PrioritizeTexturesAndBackings(
+ PrioritizedResourceManager* resource_manager) {
+ resource_manager->PrioritizeTextures();
+ ResourceManagerUpdateBackingsPriorities(resource_manager);
+ }
+
+ void ResourceManagerUpdateBackingsPriorities(
+ PrioritizedResourceManager* resource_manager) {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->PushTexturePrioritiesToBackings();
+ }
+
+ cc::ResourceProvider* ResourceProvider() { return resource_provider_.get(); }
+
+ void ResourceManagerAssertInvariants(
+ PrioritizedResourceManager* resource_manager) {
#ifndef NDEBUG
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->AssertInvariants();
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->AssertInvariants();
#endif
- }
+ }
- bool TextureBackingIsAbovePriorityCutoff(PrioritizedResource* texture) {
- return texture->backing()->
- was_above_priority_cutoff_at_last_priority_update();
- }
+ bool TextureBackingIsAbovePriorityCutoff(PrioritizedResource* texture) {
+ return texture->backing()->
+ was_above_priority_cutoff_at_last_priority_update();
+ }
- size_t EvictedBackingCount(PrioritizedResourceManager* resource_manager) {
- return resource_manager->evicted_backings_.size();
- }
+ size_t EvictedBackingCount(PrioritizedResourceManager* resource_manager) {
+ return resource_manager->evicted_backings_.size();
+ }
protected:
- FakeProxy proxy_;
- const gfx::Size texture_size_;
- const GLenum texture_format_;
- scoped_ptr<OutputSurface> output_surface_;
- scoped_ptr<cc::ResourceProvider> resource_provider_;
+ FakeProxy proxy_;
+ const gfx::Size texture_size_;
+ const GLenum texture_format_;
+ scoped_ptr<OutputSurface> output_surface_;
+ scoped_ptr<cc::ResourceProvider> resource_provider_;
};
namespace {
TEST_F(PrioritizedResourceTest, RequestTextureExceedingMaxLimit) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
-
- // Create textures for double our memory limit.
- scoped_ptr<PrioritizedResource> textures[max_textures * 2];
-
- for (size_t i = 0; i < max_textures * 2; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // Set decreasing priorities
- for (size_t i = 0; i < max_textures * 2; ++i)
- textures[i]->set_request_priority(100 + i);
-
- // Only lower half should be available.
- PrioritizeTexturesAndBackings(resource_manager.get());
- EXPECT_TRUE(ValidateTexture(textures[0], false));
- EXPECT_TRUE(ValidateTexture(textures[7], false));
- EXPECT_FALSE(ValidateTexture(textures[8], false));
- EXPECT_FALSE(ValidateTexture(textures[15], false));
-
- // Set increasing priorities
- for (size_t i = 0; i < max_textures * 2; ++i)
- textures[i]->set_request_priority(100 - i);
-
- // Only upper half should be available.
- PrioritizeTexturesAndBackings(resource_manager.get());
- EXPECT_FALSE(ValidateTexture(textures[0], false));
- EXPECT_FALSE(ValidateTexture(textures[7], false));
- EXPECT_TRUE(ValidateTexture(textures[8], false));
- EXPECT_TRUE(ValidateTexture(textures[15], false));
-
- EXPECT_EQ(TexturesMemorySize(max_textures),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ // Create textures for double our memory limit.
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures * 2];
+
+ for (size_t i = 0; i < kMaxTextures * 2; ++i)
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+
+ // Set decreasing priorities
+ for (size_t i = 0; i < kMaxTextures * 2; ++i)
+ textures[i]->set_request_priority(100 + i);
+
+ // Only lower half should be available.
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ EXPECT_TRUE(ValidateTexture(textures[0].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[7].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[8].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[15].get(), false));
+
+ // Set increasing priorities
+ for (size_t i = 0; i < kMaxTextures * 2; ++i)
+ textures[i]->set_request_priority(100 - i);
+
+ // Only upper half should be available.
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ EXPECT_FALSE(ValidateTexture(textures[0].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[7].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[8].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[15].get(), false));
+
+ EXPECT_EQ(TexturesMemorySize(kMaxTextures),
+ resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, ChangeMemoryLimits) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100 + i);
-
- // Set max limit to 8 textures
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(8));
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (size_t i = 0; i < max_textures; ++i)
- ValidateTexture(textures[i], false); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemory(ResourceProvider());
- }
-
- EXPECT_EQ(TexturesMemorySize(8),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
-
- // Set max limit to 5 textures
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(5));
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_EQ(ValidateTexture(textures[i], false), i < 5); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemory(ResourceProvider());
- }
-
- EXPECT_EQ(TexturesMemorySize(5),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
-
- // Set max limit to 4 textures
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(4));
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_EQ(ValidateTexture(textures[i], false), i < 4); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemory(ResourceProvider());
- }
-
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ }
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100 + i);
+
+ // Set max limit to 8 textures
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(8));
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ ValidateTexture(textures[i].get(), false);
+ {
DebugScopedSetImplThreadAndMainThreadBlocked
impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ resource_manager->ReduceMemory(ResourceProvider());
+ }
+
+ EXPECT_EQ(TexturesMemorySize(8), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ // Set max limit to 5 textures
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(5));
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_EQ(ValidateTexture(textures[i].get(), false), i < 5);
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ReduceMemory(ResourceProvider());
+ }
+
+ EXPECT_EQ(TexturesMemorySize(5), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ // Set max limit to 4 textures
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(4));
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_EQ(ValidateTexture(textures[i].get(), false), i < 4);
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ReduceMemory(ResourceProvider());
+ }
+
+ EXPECT_EQ(TexturesMemorySize(4), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, ChangePriorityCutoff) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100 + i);
-
- // Set the cutoff to drop two textures. Try to request_late on all textures,
- // and make sure that request_late doesn't work on a texture with equal
- // priority to the cutoff.
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(8));
- resource_manager->SetExternalPriorityCutoff(106);
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_EQ(ValidateTexture(textures[i], true), i < 6); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemory(ResourceProvider());
- }
- EXPECT_EQ(TexturesMemorySize(6),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
-
- // Set the cutoff to drop two more textures.
- resource_manager->SetExternalPriorityCutoff(104);
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_EQ(ValidateTexture(textures[i], false), i < 4); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemory(ResourceProvider());
- }
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryAboveCutoffBytes());
-
- // Do a one-time eviction for one more texture based on priority cutoff
- PrioritizedResourceManager::BackingList evicted_backings;
- resource_manager->UnlinkAndClearEvictedBackings(); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemoryOnImplThread(
- TexturesMemorySize(8), 104, ResourceProvider());
- EXPECT_EQ(0, EvictedBackingCount(resource_manager.get()));
- resource_manager->ReduceMemoryOnImplThread(
- TexturesMemorySize(8), 103, ResourceProvider());
- EXPECT_EQ(1, EvictedBackingCount(resource_manager.get()));
- }
- resource_manager->UnlinkAndClearEvictedBackings();
- EXPECT_EQ(TexturesMemorySize(3), resource_manager->MemoryUseBytes());
-
- // Re-allocate the the texture after the one-time drop.
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_EQ(ValidateTexture(textures[i], false), i < 4); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ReduceMemory(ResourceProvider());
- }
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryAboveCutoffBytes());
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ }
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100 + i);
+
+ // Set the cutoff to drop two textures. Try to request_late on all textures,
+ // and make sure that request_late doesn't work on a texture with equal
+ // priority to the cutoff.
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(8));
+ resource_manager->SetExternalPriorityCutoff(106);
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_EQ(ValidateTexture(textures[i].get(), true), i < 6);
+ {
DebugScopedSetImplThreadAndMainThreadBlocked
impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ resource_manager->ReduceMemory(ResourceProvider());
+ }
+ EXPECT_EQ(TexturesMemorySize(6), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ // Set the cutoff to drop two more textures.
+ resource_manager->SetExternalPriorityCutoff(104);
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_EQ(ValidateTexture(textures[i].get(), false), i < 4);
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ReduceMemory(ResourceProvider());
+ }
+ EXPECT_EQ(TexturesMemorySize(4), resource_manager->MemoryAboveCutoffBytes());
+
+ // Do a one-time eviction for one more texture based on priority cutoff
+ PrioritizedResourceManager::BackingList evicted_backings;
+ resource_manager->UnlinkAndClearEvictedBackings();
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ReduceMemoryOnImplThread(
+ TexturesMemorySize(8), 104, ResourceProvider());
+ EXPECT_EQ(0, EvictedBackingCount(resource_manager.get()));
+ resource_manager->ReduceMemoryOnImplThread(
+ TexturesMemorySize(8), 103, ResourceProvider());
+ EXPECT_EQ(1, EvictedBackingCount(resource_manager.get()));
+ }
+ resource_manager->UnlinkAndClearEvictedBackings();
+ EXPECT_EQ(TexturesMemorySize(3), resource_manager->MemoryUseBytes());
+
+ // Re-allocate the the texture after the one-time drop.
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_EQ(ValidateTexture(textures[i].get(), false), i < 4);
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ReduceMemory(ResourceProvider());
+ }
+ EXPECT_EQ(TexturesMemorySize(4), resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, ResourceManagerPartialUpdateTextures) {
- const size_t max_textures = 4;
- const size_t num_textures = 4;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- scoped_ptr<PrioritizedResource> textures[num_textures];
- scoped_ptr<PrioritizedResource> more_textures[num_textures];
-
- for (size_t i = 0; i < num_textures; ++i) {
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
- more_textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
- }
-
- for (size_t i = 0; i < num_textures; ++i)
- textures[i]->set_request_priority(200 + i);
- PrioritizeTexturesAndBackings(resource_manager.get());
-
- // Allocate textures which are currently high priority.
- EXPECT_TRUE(ValidateTexture(textures[0], false));
- EXPECT_TRUE(ValidateTexture(textures[1], false));
- EXPECT_TRUE(ValidateTexture(textures[2], false));
- EXPECT_TRUE(ValidateTexture(textures[3], false));
-
- EXPECT_TRUE(textures[0]->have_backing_texture());
- EXPECT_TRUE(textures[1]->have_backing_texture());
- EXPECT_TRUE(textures[2]->have_backing_texture());
- EXPECT_TRUE(textures[3]->have_backing_texture());
-
- for (size_t i = 0; i < num_textures; ++i)
- more_textures[i]->set_request_priority(100 + i);
- PrioritizeTexturesAndBackings(resource_manager.get());
-
- // Textures are now below cutoff.
- EXPECT_FALSE(ValidateTexture(textures[0], false));
- EXPECT_FALSE(ValidateTexture(textures[1], false));
- EXPECT_FALSE(ValidateTexture(textures[2], false));
- EXPECT_FALSE(ValidateTexture(textures[3], false));
-
- // But they are still valid to use.
- EXPECT_TRUE(textures[0]->have_backing_texture());
- EXPECT_TRUE(textures[1]->have_backing_texture());
- EXPECT_TRUE(textures[2]->have_backing_texture());
- EXPECT_TRUE(textures[3]->have_backing_texture());
-
- // Higher priority textures are finally needed.
- EXPECT_TRUE(ValidateTexture(more_textures[0], false));
- EXPECT_TRUE(ValidateTexture(more_textures[1], false));
- EXPECT_TRUE(ValidateTexture(more_textures[2], false));
- EXPECT_TRUE(ValidateTexture(more_textures[3], false));
-
- // Lower priority have been fully evicted.
- EXPECT_FALSE(textures[0]->have_backing_texture());
- EXPECT_FALSE(textures[1]->have_backing_texture());
- EXPECT_FALSE(textures[2]->have_backing_texture());
- EXPECT_FALSE(textures[3]->have_backing_texture());
-
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ const size_t kMaxTextures = 4;
+ const size_t kNumTextures = 4;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ scoped_ptr<PrioritizedResource> textures[kNumTextures];
+ scoped_ptr<PrioritizedResource> more_textures[kNumTextures];
+
+ for (size_t i = 0; i < kNumTextures; ++i) {
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ more_textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ }
+
+ for (size_t i = 0; i < kNumTextures; ++i)
+ textures[i]->set_request_priority(200 + i);
+ PrioritizeTexturesAndBackings(resource_manager.get());
+
+ // Allocate textures which are currently high priority.
+ EXPECT_TRUE(ValidateTexture(textures[0].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[1].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[2].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[3].get(), false));
+
+ EXPECT_TRUE(textures[0]->have_backing_texture());
+ EXPECT_TRUE(textures[1]->have_backing_texture());
+ EXPECT_TRUE(textures[2]->have_backing_texture());
+ EXPECT_TRUE(textures[3]->have_backing_texture());
+
+ for (size_t i = 0; i < kNumTextures; ++i)
+ more_textures[i]->set_request_priority(100 + i);
+ PrioritizeTexturesAndBackings(resource_manager.get());
+
+ // Textures are now below cutoff.
+ EXPECT_FALSE(ValidateTexture(textures[0].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[1].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[2].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[3].get(), false));
+
+ // But they are still valid to use.
+ EXPECT_TRUE(textures[0]->have_backing_texture());
+ EXPECT_TRUE(textures[1]->have_backing_texture());
+ EXPECT_TRUE(textures[2]->have_backing_texture());
+ EXPECT_TRUE(textures[3]->have_backing_texture());
+
+ // Higher priority textures are finally needed.
+ EXPECT_TRUE(ValidateTexture(more_textures[0].get(), false));
+ EXPECT_TRUE(ValidateTexture(more_textures[1].get(), false));
+ EXPECT_TRUE(ValidateTexture(more_textures[2].get(), false));
+ EXPECT_TRUE(ValidateTexture(more_textures[3].get(), false));
+
+ // Lower priority have been fully evicted.
+ EXPECT_FALSE(textures[0]->have_backing_texture());
+ EXPECT_FALSE(textures[1]->have_backing_texture());
+ EXPECT_FALSE(textures[2]->have_backing_texture());
+ EXPECT_FALSE(textures[3]->have_backing_texture());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, ResourceManagerPrioritiesAreEqual) {
- const size_t max_textures = 16;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // All 16 textures have the same priority except 2 higher priority.
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100);
- textures[0]->set_request_priority(99);
- textures[1]->set_request_priority(99);
-
- // Set max limit to 8 textures
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(8));
- PrioritizeTexturesAndBackings(resource_manager.get());
-
- // The two high priority textures should be available, others should not.
- for (size_t i = 0; i < 2; ++i)
- EXPECT_TRUE(ValidateTexture(textures[i], false));
- for (size_t i = 2; i < max_textures; ++i)
- EXPECT_FALSE(ValidateTexture(textures[i], false));
- EXPECT_EQ(TexturesMemorySize(2),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
-
- // Manually reserving textures should only succeed on the higher priority
- // textures, and on remaining textures up to the memory limit.
- for (size_t i = 0; i < 8; i++)
- EXPECT_TRUE(ValidateTexture(textures[i], true));
- for (size_t i = 9; i < max_textures; i++)
- EXPECT_FALSE(ValidateTexture(textures[i], true));
- EXPECT_EQ(TexturesMemorySize(8),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
+ const size_t kMaxTextures = 16;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ }
+
+ // All 16 textures have the same priority except 2 higher priority.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100);
+ textures[0]->set_request_priority(99);
+ textures[1]->set_request_priority(99);
+
+ // Set max limit to 8 textures
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(8));
+ PrioritizeTexturesAndBackings(resource_manager.get());
+
+ // The two high priority textures should be available, others should not.
+ for (size_t i = 0; i < 2; ++i)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), false));
+ for (size_t i = 2; i < kMaxTextures; ++i)
+ EXPECT_FALSE(ValidateTexture(textures[i].get(), false));
+ EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ // Manually reserving textures should only succeed on the higher priority
+ // textures, and on remaining textures up to the memory limit.
+ for (size_t i = 0; i < 8; i++)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), true));
+ for (size_t i = 9; i < kMaxTextures; i++)
+ EXPECT_FALSE(ValidateTexture(textures[i].get(), true));
+ EXPECT_EQ(TexturesMemorySize(8), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, ResourceManagerDestroyedFirst) {
- scoped_ptr<PrioritizedResourceManager> resource_manager = CreateManager(1);
- scoped_ptr<PrioritizedResource> texture =
- resource_manager->CreateTexture(texture_size_, texture_format_);
+ scoped_ptr<PrioritizedResourceManager> resource_manager = CreateManager(1);
+ scoped_ptr<PrioritizedResource> texture =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
- // Texture is initially invalid, but it will become available.
- EXPECT_FALSE(texture->have_backing_texture());
+ // Texture is initially invalid, but it will become available.
+ EXPECT_FALSE(texture->have_backing_texture());
- texture->set_request_priority(100);
- PrioritizeTexturesAndBackings(resource_manager.get());
+ texture->set_request_priority(100);
+ PrioritizeTexturesAndBackings(resource_manager.get());
- EXPECT_TRUE(ValidateTexture(texture, false));
- EXPECT_TRUE(texture->can_acquire_backing_texture());
- EXPECT_TRUE(texture->have_backing_texture()); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
- }
- resource_manager.reset();
+ EXPECT_TRUE(ValidateTexture(texture.get(), false));
+ EXPECT_TRUE(texture->can_acquire_backing_texture());
+ EXPECT_TRUE(texture->have_backing_texture());
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
+ }
+ resource_manager.reset();
- EXPECT_FALSE(texture->can_acquire_backing_texture());
- EXPECT_FALSE(texture->have_backing_texture());
+ EXPECT_FALSE(texture->can_acquire_backing_texture());
+ EXPECT_FALSE(texture->have_backing_texture());
}
TEST_F(PrioritizedResourceTest, TextureMovedToNewManager) {
- scoped_ptr<PrioritizedResourceManager> resource_manager_one =
- CreateManager(1);
- scoped_ptr<PrioritizedResourceManager> resource_manager_two =
- CreateManager(1);
- scoped_ptr<PrioritizedResource> texture =
- resource_manager_one->CreateTexture(texture_size_, texture_format_);
+ scoped_ptr<PrioritizedResourceManager> resource_manager_one =
+ CreateManager(1);
+ scoped_ptr<PrioritizedResourceManager> resource_manager_two =
+ CreateManager(1);
+ scoped_ptr<PrioritizedResource> texture =
+ resource_manager_one->CreateTexture(texture_size_, texture_format_);
- // Texture is initially invalid, but it will become available.
- EXPECT_FALSE(texture->have_backing_texture());
+ // Texture is initially invalid, but it will become available.
+ EXPECT_FALSE(texture->have_backing_texture());
- texture->set_request_priority(100);
- PrioritizeTexturesAndBackings(resource_manager_one.get());
+ texture->set_request_priority(100);
+ PrioritizeTexturesAndBackings(resource_manager_one.get());
- EXPECT_TRUE(ValidateTexture(texture, false));
- EXPECT_TRUE(texture->can_acquire_backing_texture());
- EXPECT_TRUE(texture->have_backing_texture());
+ EXPECT_TRUE(ValidateTexture(texture.get(), false));
+ EXPECT_TRUE(texture->can_acquire_backing_texture());
+ EXPECT_TRUE(texture->have_backing_texture());
- texture->SetTextureManager(0); {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager_one->ClearAllMemory(ResourceProvider());
- }
- resource_manager_one.reset();
+ texture->SetTextureManager(NULL);
+ {
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager_one->ClearAllMemory(ResourceProvider());
+ }
+ resource_manager_one.reset();
- EXPECT_FALSE(texture->can_acquire_backing_texture());
- EXPECT_FALSE(texture->have_backing_texture());
+ EXPECT_FALSE(texture->can_acquire_backing_texture());
+ EXPECT_FALSE(texture->have_backing_texture());
- texture->SetTextureManager(resource_manager_two.get());
+ texture->SetTextureManager(resource_manager_two.get());
- PrioritizeTexturesAndBackings(resource_manager_two.get());
+ PrioritizeTexturesAndBackings(resource_manager_two.get());
- EXPECT_TRUE(ValidateTexture(texture, false));
- EXPECT_TRUE(texture->can_acquire_backing_texture());
- EXPECT_TRUE(texture->have_backing_texture());
+ EXPECT_TRUE(ValidateTexture(texture.get(), false));
+ EXPECT_TRUE(texture->can_acquire_backing_texture());
+ EXPECT_TRUE(texture->have_backing_texture());
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager_two->ClearAllMemory(ResourceProvider());
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager_two->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest,
RenderSurfacesReduceMemoryAvailableOutsideRootSurface) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
-
- // Half of the memory is taken by surfaces (with high priority place-holder)
- scoped_ptr<PrioritizedResource> render_surface_place_holder =
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+
+ // Half of the memory is taken by surfaces (with high priority place-holder)
+ scoped_ptr<PrioritizedResource> render_surface_place_holder =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ render_surface_place_holder->SetToSelfManagedMemoryPlaceholder(
+ TexturesMemorySize(4));
+ render_surface_place_holder->set_request_priority(
+ PriorityCalculator::RenderSurfacePriority());
+
+ // Create textures to fill our memory limit.
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ textures[i] =
resource_manager->CreateTexture(texture_size_, texture_format_);
- render_surface_place_holder->SetToSelfManagedMemoryPlaceholder(
- TexturesMemorySize(4));
- render_surface_place_holder->set_request_priority(
- PriorityCalculator::RenderSurfacePriority());
-
- // Create textures to fill our memory limit.
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // Set decreasing non-visible priorities outside root surface.
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100 + i);
-
- // Only lower half should be available.
- PrioritizeTexturesAndBackings(resource_manager.get());
- EXPECT_TRUE(ValidateTexture(textures[0], false));
- EXPECT_TRUE(ValidateTexture(textures[3], false));
- EXPECT_FALSE(ValidateTexture(textures[4], false));
- EXPECT_FALSE(ValidateTexture(textures[7], false));
-
- // Set increasing non-visible priorities outside root surface.
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100 - i);
-
- // Only upper half should be available.
- PrioritizeTexturesAndBackings(resource_manager.get());
- EXPECT_FALSE(ValidateTexture(textures[0], false));
- EXPECT_FALSE(ValidateTexture(textures[3], false));
- EXPECT_TRUE(ValidateTexture(textures[4], false));
- EXPECT_TRUE(ValidateTexture(textures[7], false));
-
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryForSelfManagedTextures());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
-
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ }
+
+ // Set decreasing non-visible priorities outside root surface.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100 + i);
+
+ // Only lower half should be available.
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ EXPECT_TRUE(ValidateTexture(textures[0].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[3].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[4].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[7].get(), false));
+
+ // Set increasing non-visible priorities outside root surface.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100 - i);
+
+ // Only upper half should be available.
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ EXPECT_FALSE(ValidateTexture(textures[0].get(), false));
+ EXPECT_FALSE(ValidateTexture(textures[3].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[4].get(), false));
+ EXPECT_TRUE(ValidateTexture(textures[7].get(), false));
+
+ EXPECT_EQ(TexturesMemorySize(4), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_EQ(TexturesMemorySize(4),
+ resource_manager->MemoryForSelfManagedTextures());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest,
RenderSurfacesReduceMemoryAvailableForRequestLate) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
-
- // Half of the memory is taken by surfaces (with high priority place-holder)
- scoped_ptr<PrioritizedResource> render_surface_place_holder =
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+
+ // Half of the memory is taken by surfaces (with high priority place-holder)
+ scoped_ptr<PrioritizedResource> render_surface_place_holder =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ render_surface_place_holder->SetToSelfManagedMemoryPlaceholder(
+ TexturesMemorySize(4));
+ render_surface_place_holder->set_request_priority(
+ PriorityCalculator::RenderSurfacePriority());
+
+ // Create textures to fill our memory limit.
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ textures[i] =
resource_manager->CreateTexture(texture_size_, texture_format_);
- render_surface_place_holder->SetToSelfManagedMemoryPlaceholder(
- TexturesMemorySize(4));
- render_surface_place_holder->set_request_priority(
- PriorityCalculator::RenderSurfacePriority());
-
- // Create textures to fill our memory limit.
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // Set equal priorities.
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100);
-
- // The first four to be requested late will be available.
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (unsigned i = 0; i < max_textures; ++i)
- EXPECT_FALSE(ValidateTexture(textures[i], false));
- for (unsigned i = 0; i < max_textures; i += 2)
- EXPECT_TRUE(ValidateTexture(textures[i], true));
- for (unsigned i = 1; i < max_textures; i += 2)
- EXPECT_FALSE(ValidateTexture(textures[i], true));
-
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryForSelfManagedTextures());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
-
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ }
+
+ // Set equal priorities.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100);
+
+ // The first four to be requested late will be available.
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (unsigned i = 0; i < kMaxTextures; ++i)
+ EXPECT_FALSE(ValidateTexture(textures[i].get(), false));
+ for (unsigned i = 0; i < kMaxTextures; i += 2)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), true));
+ for (unsigned i = 1; i < kMaxTextures; i += 2)
+ EXPECT_FALSE(ValidateTexture(textures[i].get(), true));
+
+ EXPECT_EQ(TexturesMemorySize(4), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_EQ(TexturesMemorySize(4),
+ resource_manager->MemoryForSelfManagedTextures());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest,
WhenRenderSurfaceNotAvailableTexturesAlsoNotAvailable) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
-
- // Half of the memory is taken by surfaces (with high priority place-holder)
- scoped_ptr<PrioritizedResource> render_surface_place_holder =
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+
+ // Half of the memory is taken by surfaces (with high priority place-holder)
+ scoped_ptr<PrioritizedResource> render_surface_place_holder =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ render_surface_place_holder->SetToSelfManagedMemoryPlaceholder(
+ TexturesMemorySize(4));
+ render_surface_place_holder->set_request_priority(
+ PriorityCalculator::RenderSurfacePriority());
+
+ // Create textures to fill our memory limit.
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i] =
resource_manager->CreateTexture(texture_size_, texture_format_);
- render_surface_place_holder->SetToSelfManagedMemoryPlaceholder(
- TexturesMemorySize(4));
- render_surface_place_holder->set_request_priority(
- PriorityCalculator::RenderSurfacePriority());
-
- // Create textures to fill our memory limit.
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // Set 6 visible textures in the root surface, and 2 in a child surface.
- for (size_t i = 0; i < 6; ++i)
- textures[i]->
- set_request_priority(PriorityCalculator::VisiblePriority(true));
- for (size_t i = 6; i < 8; ++i)
- textures[i]->
- set_request_priority(PriorityCalculator::VisiblePriority(false));
-
- PrioritizeTexturesAndBackings(resource_manager.get());
-
- // Unable to request_late textures in the child surface.
- EXPECT_FALSE(ValidateTexture(textures[6], true));
- EXPECT_FALSE(ValidateTexture(textures[7], true));
-
- // Root surface textures are valid.
- for (size_t i = 0; i < 6; ++i)
- EXPECT_TRUE(ValidateTexture(textures[i], false));
-
- EXPECT_EQ(TexturesMemorySize(6),
- resource_manager->MemoryAboveCutoffBytes());
- EXPECT_EQ(TexturesMemorySize(2),
- resource_manager->MemoryForSelfManagedTextures());
- EXPECT_LE(resource_manager->MemoryUseBytes(),
- resource_manager->MemoryAboveCutoffBytes());
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ // Set 6 visible textures in the root surface, and 2 in a child surface.
+ for (size_t i = 0; i < 6; ++i) {
+ textures[i]->
+ set_request_priority(PriorityCalculator::VisiblePriority(true));
+ }
+ for (size_t i = 6; i < 8; ++i) {
+ textures[i]->
+ set_request_priority(PriorityCalculator::VisiblePriority(false));
+ }
+
+ PrioritizeTexturesAndBackings(resource_manager.get());
+
+ // Unable to request_late textures in the child surface.
+ EXPECT_FALSE(ValidateTexture(textures[6].get(), true));
+ EXPECT_FALSE(ValidateTexture(textures[7].get(), true));
+
+ // Root surface textures are valid.
+ for (size_t i = 0; i < 6; ++i)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), false));
+
+ EXPECT_EQ(TexturesMemorySize(6), resource_manager->MemoryAboveCutoffBytes());
+ EXPECT_EQ(TexturesMemorySize(2),
+ resource_manager->MemoryForSelfManagedTextures());
+ EXPECT_LE(resource_manager->MemoryUseBytes(),
+ resource_manager->MemoryAboveCutoffBytes());
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, RequestLateBackingsSorting) {
- const size_t max_textures = 8;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(max_textures));
-
- // Create textures to fill our memory limit.
- scoped_ptr<PrioritizedResource> textures[max_textures];
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // Set equal priorities, and allocate backings for all textures.
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100);
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (unsigned i = 0; i < max_textures; ++i)
- EXPECT_TRUE(ValidateTexture(textures[i], false));
-
- // Drop the memory limit and prioritize (none will be above the threshold,
- // but they still have backings because ReduceMemory hasn't been called).
- resource_manager->SetMaxMemoryLimitBytes(
- TexturesMemorySize(max_textures / 2));
- PrioritizeTexturesAndBackings(resource_manager.get());
-
- // Push half of them back over the limit.
- for (size_t i = 0; i < max_textures; i += 2)
- EXPECT_TRUE(textures[i]->RequestLate());
-
- // Push the priorities to the backings array and sort the backings array
- ResourceManagerUpdateBackingsPriorities(resource_manager.get());
-
- // Assert that the backings list be sorted with the below-limit backings
- // before the above-limit backings.
- ResourceManagerAssertInvariants(resource_manager.get());
-
- // Make sure that we have backings for all of the textures.
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_TRUE(textures[i]->have_backing_texture());
-
- // Make sure that only the request_late textures are above the priority
- // cutoff
- for (size_t i = 0; i < max_textures; i += 2)
- EXPECT_TRUE(TextureBackingIsAbovePriorityCutoff(textures[i].get()));
- for (size_t i = 1; i < max_textures; i += 2)
- EXPECT_FALSE(TextureBackingIsAbovePriorityCutoff(textures[i].get()));
+ const size_t kMaxTextures = 8;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(kMaxTextures));
+
+ // Create textures to fill our memory limit.
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ // Set equal priorities, and allocate backings for all textures.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100);
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (unsigned i = 0; i < kMaxTextures; ++i)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), false));
+
+ // Drop the memory limit and prioritize (none will be above the threshold,
+ // but they still have backings because ReduceMemory hasn't been called).
+ resource_manager->SetMaxMemoryLimitBytes(
+ TexturesMemorySize(kMaxTextures / 2));
+ PrioritizeTexturesAndBackings(resource_manager.get());
+
+ // Push half of them back over the limit.
+ for (size_t i = 0; i < kMaxTextures; i += 2)
+ EXPECT_TRUE(textures[i]->RequestLate());
+
+ // Push the priorities to the backings array and sort the backings array
+ ResourceManagerUpdateBackingsPriorities(resource_manager.get());
+
+ // Assert that the backings list be sorted with the below-limit backings
+ // before the above-limit backings.
+ ResourceManagerAssertInvariants(resource_manager.get());
+
+ // Make sure that we have backings for all of the textures.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_TRUE(textures[i]->have_backing_texture());
+
+ // Make sure that only the request_late textures are above the priority
+ // cutoff
+ for (size_t i = 0; i < kMaxTextures; i += 2)
+ EXPECT_TRUE(TextureBackingIsAbovePriorityCutoff(textures[i].get()));
+ for (size_t i = 1; i < kMaxTextures; i += 2)
+ EXPECT_FALSE(TextureBackingIsAbovePriorityCutoff(textures[i].get()));
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
TEST_F(PrioritizedResourceTest, ClearUploadsToEvictedResources) {
- const size_t max_textures = 4;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(max_textures));
-
- // Create textures to fill our memory limit.
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- // Set equal priorities, and allocate backings for all textures.
- for (size_t i = 0; i < max_textures; ++i)
- textures[i]->set_request_priority(100);
- PrioritizeTexturesAndBackings(resource_manager.get());
- for (unsigned i = 0; i < max_textures; ++i)
- EXPECT_TRUE(ValidateTexture(textures[i], false));
-
- ResourceUpdateQueue queue;
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked(&proxy_);
- for (size_t i = 0; i < max_textures; ++i) {
- const ResourceUpdate upload = ResourceUpdate::Create(
- textures[i].get(), NULL, gfx::Rect(), gfx::Rect(), gfx::Vector2d());
- queue.AppendFullUpload(upload);
- }
+ const size_t kMaxTextures = 4;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(kMaxTextures));
- // Make sure that we have backings for all of the textures.
- for (size_t i = 0; i < max_textures; ++i)
- EXPECT_TRUE(textures[i]->have_backing_texture());
+ // Create textures to fill our memory limit.
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
- queue.ClearUploadsToEvictedResources();
- EXPECT_EQ(4, queue.FullUploadSize());
-
- resource_manager->ReduceMemoryOnImplThread(
- TexturesMemorySize(1),
- PriorityCalculator::AllowEverythingCutoff(),
- ResourceProvider());
- queue.ClearUploadsToEvictedResources();
- EXPECT_EQ(1, queue.FullUploadSize());
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
- resource_manager->ReduceMemoryOnImplThread(
- 0, PriorityCalculator::AllowEverythingCutoff(), ResourceProvider());
- queue.ClearUploadsToEvictedResources();
- EXPECT_EQ(0, queue.FullUploadSize());
+ // Set equal priorities, and allocate backings for all textures.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ textures[i]->set_request_priority(100);
+ PrioritizeTexturesAndBackings(resource_manager.get());
+ for (unsigned i = 0; i < kMaxTextures; ++i)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), false));
+
+ ResourceUpdateQueue queue;
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ const ResourceUpdate upload = ResourceUpdate::Create(
+ textures[i].get(), NULL, gfx::Rect(), gfx::Rect(), gfx::Vector2d());
+ queue.AppendFullUpload(upload);
+ }
+
+ // Make sure that we have backings for all of the textures.
+ for (size_t i = 0; i < kMaxTextures; ++i)
+ EXPECT_TRUE(textures[i]->have_backing_texture());
+
+ queue.ClearUploadsToEvictedResources();
+ EXPECT_EQ(4, queue.FullUploadSize());
+
+ resource_manager->ReduceMemoryOnImplThread(
+ TexturesMemorySize(1),
+ PriorityCalculator::AllowEverythingCutoff(),
+ ResourceProvider());
+ queue.ClearUploadsToEvictedResources();
+ EXPECT_EQ(1, queue.FullUploadSize());
+
+ resource_manager->ReduceMemoryOnImplThread(
+ 0, PriorityCalculator::AllowEverythingCutoff(), ResourceProvider());
+ queue.ClearUploadsToEvictedResources();
+ EXPECT_EQ(0, queue.FullUploadSize());
}
TEST_F(PrioritizedResourceTest, UsageStatistics) {
- const size_t max_textures = 5;
- scoped_ptr<PrioritizedResourceManager> resource_manager =
- CreateManager(max_textures);
- scoped_ptr<PrioritizedResource> textures[max_textures];
-
- for (size_t i = 0; i < max_textures; ++i)
- textures[i] =
- resource_manager->CreateTexture(texture_size_, texture_format_);
-
- textures[0]->set_request_priority(
- PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
- textures[1]->
- set_request_priority(PriorityCalculator::AllowVisibleOnlyCutoff());
- textures[2]->set_request_priority(
- PriorityCalculator::AllowVisibleAndNearbyCutoff() - 1);
- textures[3]->set_request_priority(
- PriorityCalculator::AllowVisibleAndNearbyCutoff());
- textures[4]->set_request_priority(
- PriorityCalculator::AllowVisibleAndNearbyCutoff() + 1);
-
- // Set max limit to 2 textures.
- resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(2));
- PrioritizeTexturesAndBackings(resource_manager.get());
-
- // The first two textures should be available, others should not.
- for (size_t i = 0; i < 2; ++i)
- EXPECT_TRUE(ValidateTexture(textures[i], false));
- for (size_t i = 2; i < max_textures; ++i)
- EXPECT_FALSE(ValidateTexture(textures[i], false));
-
- // Validate the statistics.
- {
- DebugScopedSetImplThread impl_thread(&proxy_);
- EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryUseBytes());
- EXPECT_EQ(TexturesMemorySize(1),
- resource_manager->MemoryVisibleBytes());
- EXPECT_EQ(TexturesMemorySize(3),
- resource_manager->MemoryVisibleAndNearbyBytes());
- }
-
- // Re-prioritize the textures, but do not push the values to backings.
- textures[0]->set_request_priority(
- PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
- textures[1]->set_request_priority(
- PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
- textures[2]->set_request_priority(
- PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
- textures[3]->set_request_priority(
- PriorityCalculator::AllowVisibleAndNearbyCutoff() - 1);
- textures[4]->set_request_priority(
- PriorityCalculator::AllowVisibleAndNearbyCutoff());
- resource_manager->PrioritizeTextures();
-
- // Verify that we still see the old values.
- {
- DebugScopedSetImplThread impl_thread (& proxy_);
- EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryUseBytes());
- EXPECT_EQ(TexturesMemorySize(1),
- resource_manager->MemoryVisibleBytes());
- EXPECT_EQ(TexturesMemorySize(3),
- resource_manager->MemoryVisibleAndNearbyBytes());
- }
-
- // Push priorities to backings, and verify we see the new values.
- {
- DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked (& proxy_);
- resource_manager->PushTexturePrioritiesToBackings();
- EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryUseBytes());
- EXPECT_EQ(TexturesMemorySize(3),
- resource_manager->MemoryVisibleBytes());
- EXPECT_EQ(TexturesMemorySize(4),
- resource_manager->MemoryVisibleAndNearbyBytes());
- }
+ const size_t kMaxTextures = 5;
+ scoped_ptr<PrioritizedResourceManager> resource_manager =
+ CreateManager(kMaxTextures);
+ scoped_ptr<PrioritizedResource> textures[kMaxTextures];
+ for (size_t i = 0; i < kMaxTextures; ++i) {
+ textures[i] =
+ resource_manager->CreateTexture(texture_size_, texture_format_);
+ }
+
+ textures[0]->
+ set_request_priority(PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
+ textures[1]->
+ set_request_priority(PriorityCalculator::AllowVisibleOnlyCutoff());
+ textures[2]->set_request_priority(
+ PriorityCalculator::AllowVisibleAndNearbyCutoff() - 1);
+ textures[3]->
+ set_request_priority(PriorityCalculator::AllowVisibleAndNearbyCutoff());
+ textures[4]->set_request_priority(
+ PriorityCalculator::AllowVisibleAndNearbyCutoff() + 1);
+
+ // Set max limit to 2 textures.
+ resource_manager->SetMaxMemoryLimitBytes(TexturesMemorySize(2));
+ PrioritizeTexturesAndBackings(resource_manager.get());
+
+ // The first two textures should be available, others should not.
+ for (size_t i = 0; i < 2; ++i)
+ EXPECT_TRUE(ValidateTexture(textures[i].get(), false));
+ for (size_t i = 2; i < kMaxTextures; ++i)
+ EXPECT_FALSE(ValidateTexture(textures[i].get(), false));
+
+ // Validate the statistics.
+ {
+ DebugScopedSetImplThread impl_thread(&proxy_);
+ EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryUseBytes());
+ EXPECT_EQ(TexturesMemorySize(1), resource_manager->MemoryVisibleBytes());
+ EXPECT_EQ(TexturesMemorySize(3),
+ resource_manager->MemoryVisibleAndNearbyBytes());
+ }
+
+ // Re-prioritize the textures, but do not push the values to backings.
+ textures[0]->
+ set_request_priority(PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
+ textures[1]->
+ set_request_priority(PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
+ textures[2]->
+ set_request_priority(PriorityCalculator::AllowVisibleOnlyCutoff() - 1);
+ textures[3]->set_request_priority(
+ PriorityCalculator::AllowVisibleAndNearbyCutoff() - 1);
+ textures[4]->
+ set_request_priority(PriorityCalculator::AllowVisibleAndNearbyCutoff());
+ resource_manager->PrioritizeTextures();
+
+ // Verify that we still see the old values.
+ {
+ DebugScopedSetImplThread impl_thread(&proxy_);
+ EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryUseBytes());
+ EXPECT_EQ(TexturesMemorySize(1), resource_manager->MemoryVisibleBytes());
+ EXPECT_EQ(TexturesMemorySize(3),
+ resource_manager->MemoryVisibleAndNearbyBytes());
+ }
+
+ // Push priorities to backings, and verify we see the new values.
+ {
DebugScopedSetImplThreadAndMainThreadBlocked
- impl_thread_and_main_thread_blocked (& proxy_);
- resource_manager->ClearAllMemory(ResourceProvider());
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->PushTexturePrioritiesToBackings();
+ EXPECT_EQ(TexturesMemorySize(2), resource_manager->MemoryUseBytes());
+ EXPECT_EQ(TexturesMemorySize(3), resource_manager->MemoryVisibleBytes());
+ EXPECT_EQ(TexturesMemorySize(4),
+ resource_manager->MemoryVisibleAndNearbyBytes());
+ }
+
+ DebugScopedSetImplThreadAndMainThreadBlocked
+ impl_thread_and_main_thread_blocked(&proxy_);
+ resource_manager->ClearAllMemory(ResourceProvider());
}
} // namespace
« no previous file with comments | « cc/resources/prioritized_resource_manager.cc ('k') | cc/resources/priority_calculator.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698