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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: gpu/command_buffer/service/texture_manager_unittest.cc

Issue 14844004: gpu: Refactor to support cross-channel shared textures (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 7 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
« gpu/command_buffer/service/texture_manager.cc ('K') | « gpu/command_buffer/service/texture_manager.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: gpu/command_buffer/service/texture_manager_unittest.cc
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index bef870bf137f9a2ac192c1f7efaf39aae50c5706..28614ba5c08cee6549eefd731b1477e1ec42a95e 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -75,10 +75,10 @@ class TextureManagerTest : public testing::Test {
}
void SetParameter(
- Texture* texture, GLenum pname, GLint value, GLenum error) {
+ TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
TestHelper::SetTexParameterWithExpectations(
gl_.get(), error_state_.get(), manager_.get(),
- texture, pname, value, error);
+ texture_ref, pname, value, error);
}
// Use StrictMock to make 100% sure we know how GL will be called.
@@ -108,7 +108,7 @@ TEST_F(TextureManagerTest, Basic) {
// Check we can create texture.
manager_->CreateTexture(kClient1Id, kService1Id);
// Check texture got created.
- Texture* texture = manager_->GetTexture(kClient1Id);
+ TextureRef* texture = manager_->GetTexture(kClient1Id);
ASSERT_TRUE(texture != NULL);
EXPECT_EQ(kService1Id, texture->service_id());
GLuint client_id = 0;
@@ -133,30 +133,31 @@ TEST_F(TextureManagerTest, SetParameter) {
// Check we can create texture.
manager_->CreateTexture(kClient1Id, kService1Id);
// Check texture got created.
- Texture* texture = manager_->GetTexture(kClient1Id);
- manager_->SetTarget(texture, GL_TEXTURE_2D);
- ASSERT_TRUE(texture != NULL);
- SetParameter(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
+ TextureRef* texture_ref = manager_->GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ Texture* texture = texture_ref->texture();
+ manager_->SetTarget(texture_ref, GL_TEXTURE_2D);
+ SetParameter(texture_ref, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
- SetParameter(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+ SetParameter(texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->mag_filter());
- SetParameter(texture, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+ SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
- SetParameter(texture, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+ SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
- SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR);
- SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR);
+ SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR);
+ SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR);
SetParameter(
- texture, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
+ texture_ref, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
SetParameter(
- texture, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
+ texture_ref, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
- SetParameter(texture, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM);
+ SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM);
EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
- SetParameter(texture, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM);
+ SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM);
EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
- SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
+ SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
}
TEST_F(TextureManagerTest, TextureUsageExt) {
@@ -170,13 +171,13 @@ TEST_F(TextureManagerTest, TextureUsageExt) {
// Check we can create texture.
manager.CreateTexture(kClient1Id, kService1Id);
// Check texture got created.
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
TestHelper::SetTexParameterWithExpectations(
- gl_.get(), error_state_.get(), &manager, texture,
+ gl_.get(), error_state_.get(), &manager, texture_ref,
GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE,GL_NO_ERROR);
EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
- texture->usage());
+ texture_ref->texture()->usage());
manager.Destroy(false);
}
@@ -190,7 +191,7 @@ TEST_F(TextureManagerTest, Destroy) {
// Check we can create texture.
manager.CreateTexture(kClient1Id, kService1Id);
// Check texture got created.
- Texture* texture = manager.GetTexture(kClient1Id);
+ TextureRef* texture = manager.GetTexture(kClient1Id);
ASSERT_TRUE(texture != NULL);
EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
.Times(1)
@@ -210,12 +211,12 @@ TEST_F(TextureManagerTest, DestroyUnowned) {
NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.Initialize();
// Check we can create texture.
- Texture* created_texture =
+ TextureRef* created_texture =
manager.CreateTexture(kClient1Id, kService1Id);
- created_texture->SetNotOwned();
+ created_texture->texture()->SetNotOwned();
// Check texture got created.
- Texture* texture = manager.GetTexture(kClient1Id);
+ TextureRef* texture = manager.GetTexture(kClient1Id);
ASSERT_TRUE(texture != NULL);
// Check that it is not freed if it is not owned.
@@ -365,7 +366,7 @@ class TextureTestBase : public testing::Test {
: feature_info_(new FeatureInfo()) {
}
virtual ~TextureTestBase() {
- texture_ = NULL;
+ texture_ref_ = NULL;
}
protected:
@@ -385,23 +386,23 @@ class TextureTestBase : public testing::Test {
decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
manager_->CreateTexture(kClient1Id, kService1Id);
- texture_ = manager_->GetTexture(kClient1Id);
- ASSERT_TRUE(texture_.get() != NULL);
+ texture_ref_ = manager_->GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref_.get() != NULL);
}
virtual void TearDown() {
- if (texture_.get()) {
+ if (texture_ref_.get()) {
GLuint client_id = 0;
- // If it's not in the manager then setting texture_ to NULL will
+ // If it's not in the manager then setting texture_ref_ to NULL will
// delete the texture.
- if (!manager_->GetClientId(texture_->service_id(), &client_id)) {
+ if (!manager_->GetClientId(texture_ref_->service_id(), &client_id)) {
// Check that it gets deleted when the last reference is released.
EXPECT_CALL(*gl_,
- DeleteTextures(1, ::testing::Pointee(texture_->service_id())))
+ DeleteTextures(1, ::testing::Pointee(texture_ref_->service_id())))
.Times(1)
.RetiresOnSaturation();
}
- texture_ = NULL;
+ texture_ref_ = NULL;
}
manager_->Destroy(false);
manager_.reset();
@@ -410,10 +411,10 @@ class TextureTestBase : public testing::Test {
}
void SetParameter(
- Texture* texture, GLenum pname, GLint value, GLenum error) {
+ TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
TestHelper::SetTexParameterWithExpectations(
gl_.get(), error_state_.get(), manager_.get(),
- texture, pname, value, error);
+ texture_ref, pname, value, error);
}
scoped_ptr<MockGLES2Decoder> decoder_;
@@ -422,7 +423,7 @@ class TextureTestBase : public testing::Test {
scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
scoped_refptr<FeatureInfo> feature_info_;
scoped_ptr<TextureManager> manager_;
- scoped_refptr<Texture> texture_;
+ scoped_refptr<TextureRef> texture_ref_;
};
class TextureTest : public TextureTestBase {
@@ -449,65 +450,68 @@ class TextureMemoryTrackerTest : public TextureTestBase {
.RetiresOnSaturation() \
TEST_F(TextureTest, Basic) {
- EXPECT_EQ(0u, texture_->target());
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_EQ(0, texture_->num_uncleared_mips());
- EXPECT_FALSE(manager_->CanRender(texture_));
- EXPECT_TRUE(texture_->SafeToRenderFrom());
- EXPECT_FALSE(texture_->IsImmutable());
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(0u, texture->target());
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_EQ(0, texture->num_uncleared_mips());
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
+ EXPECT_TRUE(texture->SafeToRenderFrom());
+ EXPECT_FALSE(texture->IsImmutable());
EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR),
- texture_->min_filter());
- EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture_->mag_filter());
- EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture_->wrap_s());
- EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture_->wrap_t());
+ texture->min_filter());
+ EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture->mag_filter());
+ EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_s());
+ EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_t());
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
- EXPECT_EQ(0u, texture_->estimated_size());
+ EXPECT_EQ(0u, texture->estimated_size());
}
TEST_F(TextureTest, SetTargetTexture2D) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
- EXPECT_TRUE(texture_->SafeToRenderFrom());
- EXPECT_FALSE(texture_->IsImmutable());
+ Texture* texture = texture_ref_->texture();
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
+ EXPECT_TRUE(texture->SafeToRenderFrom());
+ EXPECT_FALSE(texture->IsImmutable());
}
TEST_F(TextureTest, SetTargetTextureExternalOES) {
- manager_->SetTarget(texture_, GL_TEXTURE_EXTERNAL_OES);
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
- EXPECT_TRUE(texture_->SafeToRenderFrom());
- EXPECT_TRUE(texture_->IsImmutable());
+ Texture* texture = texture_ref_->texture();
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_EXTERNAL_OES);
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
+ EXPECT_TRUE(texture->SafeToRenderFrom());
+ EXPECT_TRUE(texture->IsImmutable());
}
TEST_F(TextureTest, EstimatedSize) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_EQ(8u * 4u * 4u, texture_->estimated_size());
- manager_->SetLevelInfo(texture_,
+ EXPECT_EQ(8u * 4u * 4u, texture_ref_->texture()->estimated_size());
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_EQ(8u * 4u * 4u * 2u, texture_->estimated_size());
+ EXPECT_EQ(8u * 4u * 4u * 2u, texture_ref_->texture()->estimated_size());
}
TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
// Add expectation for texture deletion.
EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged);
@@ -515,14 +519,14 @@ TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
}
TEST_F(TextureMemoryTrackerTest, SetParameterPool) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged);
SetParameter(
- texture_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM,
+ texture_ref_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM,
GL_NO_ERROR);
// Add expectation for texture deletion.
EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged);
@@ -531,116 +535,119 @@ TEST_F(TextureMemoryTrackerTest, SetParameterPool) {
}
TEST_F(TextureTest, POT2D) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
// Check Setting level 0 to POT
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
- EXPECT_EQ(0, texture_->num_uncleared_mips());
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
+ EXPECT_EQ(0, texture->num_uncleared_mips());
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
// Set filters to something that will work with a single mip.
- SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
- EXPECT_TRUE(manager_->CanRender(texture_));
+ SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Set them back.
- SetParameter(
- texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR_MIPMAP_LINEAR, GL_NO_ERROR);
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
// Make mips.
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Change a mip.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
// Set a level past the number of mips that would get generated.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
// Make mips.
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
}
TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged);
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged);
EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
}
TEST_F(TextureTest, UnusedMips) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
// Set level zero to large size.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Set level zero to large smaller (levels unused mips)
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Set an unused level to some size
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 4, GL_RGBA, 16, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
}
TEST_F(TextureTest, NPOT2D) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
// Check Setting level 0 to NPOT
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
- EXPECT_FALSE(manager_->CanRender(texture_));
+ SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
- EXPECT_FALSE(manager_->CanRender(texture_));
+ SetParameter(texture_ref_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
- EXPECT_TRUE(manager_->CanRender(texture_));
+ SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Change it to POT.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
}
@@ -652,190 +659,195 @@ TEST_F(TextureTest, NPOT2DNPOTOK) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ Texture* texture = texture_ref->texture();
- manager.SetTarget(texture, GL_TEXTURE_2D);
+ manager.SetTarget(texture_ref, GL_TEXTURE_2D);
EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
// Check Setting level 0 to NPOT
- manager.SetLevelInfo(texture,
+ manager.SetLevelInfo(texture_ref,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
- EXPECT_TRUE(manager.CanGenerateMipmaps(texture));
- EXPECT_FALSE(manager.CanRender(texture));
+ EXPECT_TRUE(manager.CanGenerateMipmaps(texture_ref));
+ EXPECT_FALSE(manager.CanRender(texture_ref));
EXPECT_TRUE(manager.HaveUnrenderableTextures());
- EXPECT_TRUE(manager.MarkMipmapsGenerated(texture));
+ EXPECT_TRUE(manager.MarkMipmapsGenerated(texture_ref));
EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
- EXPECT_TRUE(manager.CanRender(texture));
+ EXPECT_TRUE(manager.CanRender(texture_ref));
EXPECT_FALSE(manager.HaveUnrenderableTextures());
manager.Destroy(false);
}
TEST_F(TextureTest, POTCubeMap) {
- manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_CUBE_MAP);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
// Check Setting level 0 each face to POT
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
// Make mips.
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_TRUE(manager_->CanRender(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Change a mip.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+ EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
// Set a level past the number of mips that would get generated.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+ EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
// Make mips.
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
}
TEST_F(TextureTest, GetLevelSize) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
GLsizei width = -1;
GLsizei height = -1;
- EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height));
- EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height));
- EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
- EXPECT_TRUE(texture_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
+ Texture* texture = texture_ref_->texture();
+ EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height));
+ EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height));
+ EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+ EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
EXPECT_EQ(4, width);
EXPECT_EQ(5, height);
manager_->RemoveTexture(kClient1Id);
- EXPECT_TRUE(texture_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
+ EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
EXPECT_EQ(4, width);
EXPECT_EQ(5, height);
}
TEST_F(TextureTest, GetLevelType) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
GLenum type = -1;
GLenum format = -1;
- EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, -1, &type, &format));
- EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format));
- EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, 0, &type, &format));
- EXPECT_TRUE(texture_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
+ Texture* texture = texture_ref_->texture();
+ EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, -1, &type, &format));
+ EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format));
+ EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &format));
+ EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
manager_->RemoveTexture(kClient1Id);
- EXPECT_TRUE(texture_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
+ EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
}
TEST_F(TextureTest, ValidForTexture) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
// Check bad face.
- EXPECT_FALSE(texture_->ValidForTexture(
+ Texture* texture = texture_ref_->texture();
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad level.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad xoffset.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, -1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad xoffset + width > width.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad yoffset.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, -1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad yoffset + height > height.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad width.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad height.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_RGBA, GL_UNSIGNED_BYTE));
// Check bad format.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGB, GL_UNSIGNED_BYTE));
// Check bad type.
- EXPECT_FALSE(texture_->ValidForTexture(
+ EXPECT_FALSE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4));
// Check valid full size
- EXPECT_TRUE(texture_->ValidForTexture(
+ EXPECT_TRUE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
// Check valid particial size.
- EXPECT_TRUE(texture_->ValidForTexture(
+ EXPECT_TRUE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_RGBA, GL_UNSIGNED_BYTE));
manager_->RemoveTexture(kClient1Id);
- EXPECT_TRUE(texture_->ValidForTexture(
+ EXPECT_TRUE(texture->ValidForTexture(
GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
}
@@ -847,20 +859,21 @@ TEST_F(TextureTest, FloatNotLinear) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
- manager.SetTarget(texture, GL_TEXTURE_2D);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+ Texture* texture = texture_ref->texture();
EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
- manager.SetLevelInfo(texture,
+ manager.SetLevelInfo(texture_ref,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
TestHelper::SetTexParameterWithExpectations(
gl_.get(), error_state_.get(), &manager,
- texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+ texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
TestHelper::SetTexParameterWithExpectations(
- gl_.get(), error_state_.get(), &manager,
- texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
+ gl_.get(), error_state_.get(), &manager, texture_ref,
+ GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
manager.Destroy(false);
}
@@ -873,11 +886,12 @@ TEST_F(TextureTest, FloatLinear) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
- manager.SetTarget(texture, GL_TEXTURE_2D);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+ Texture* texture = texture_ref->texture();
EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
- manager.SetLevelInfo(texture,
+ manager.SetLevelInfo(texture_ref,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
manager.Destroy(false);
@@ -891,20 +905,21 @@ TEST_F(TextureTest, HalfFloatNotLinear) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
- manager.SetTarget(texture, GL_TEXTURE_2D);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+ Texture* texture = texture_ref->texture();
EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
- manager.SetLevelInfo(texture,
+ manager.SetLevelInfo(texture_ref,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
TestHelper::SetTexParameterWithExpectations(
gl_.get(), error_state_.get(), &manager,
- texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+ texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
TestHelper::SetTexParameterWithExpectations(
- gl_.get(), error_state_.get(), &manager,
- texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
+ gl_.get(), error_state_.get(), &manager, texture_ref,
+ GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
manager.Destroy(false);
}
@@ -917,11 +932,12 @@ TEST_F(TextureTest, HalfFloatLinear) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
- manager.SetTarget(texture, GL_TEXTURE_2D);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+ Texture* texture = texture_ref->texture();
EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
- manager.SetLevelInfo(texture,
+ manager.SetLevelInfo(texture_ref,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
manager.Destroy(false);
@@ -935,11 +951,12 @@ TEST_F(TextureTest, EGLImageExternal) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
- manager.SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ manager.SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
+ Texture* texture = texture_ref->texture();
EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
- EXPECT_FALSE(manager.CanGenerateMipmaps(texture));
+ EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
manager.Destroy(false);
}
@@ -951,13 +968,13 @@ TEST_F(TextureTest, DepthTexture) {
TextureManager manager(
NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
manager.CreateTexture(kClient1Id, kService1Id);
- Texture* texture = manager.GetTexture(kClient1Id);
- ASSERT_TRUE(texture != NULL);
- manager.SetTarget(texture, GL_TEXTURE_2D);
+ TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+ ASSERT_TRUE(texture_ref != NULL);
+ manager.SetTarget(texture_ref, GL_TEXTURE_2D);
manager.SetLevelInfo(
- texture, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
+ texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
- EXPECT_FALSE(manager.CanGenerateMipmaps(texture));
+ EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
manager.Destroy(false);
}
@@ -967,101 +984,104 @@ TEST_F(TextureTest, SafeUnsafe) {
static const GLuint kClient3Id = 3;
static const GLuint kService3Id = 13;
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(0, texture->num_uncleared_mips());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(1, texture_->num_uncleared_mips());
- manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true);
- EXPECT_TRUE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(1, texture->num_uncleared_mips());
+ manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 0, true);
+ EXPECT_TRUE(texture->SafeToRenderFrom());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
- manager_->SetLevelInfo(texture_,
+ EXPECT_EQ(0, texture->num_uncleared_mips());
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(1, texture_->num_uncleared_mips());
- manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true);
- EXPECT_TRUE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(1, texture->num_uncleared_mips());
+ manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 1, true);
+ EXPECT_TRUE(texture->SafeToRenderFrom());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
- manager_->SetLevelInfo(texture_,
+ EXPECT_EQ(0, texture->num_uncleared_mips());
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(2, texture_->num_uncleared_mips());
- manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(2, texture->num_uncleared_mips());
+ manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 0, true);
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(1, texture_->num_uncleared_mips());
- manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true);
- EXPECT_TRUE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(1, texture->num_uncleared_mips());
+ manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 1, true);
+ EXPECT_TRUE(texture->SafeToRenderFrom());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
- manager_->SetLevelInfo(texture_,
+ EXPECT_EQ(0, texture->num_uncleared_mips());
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(1, texture_->num_uncleared_mips());
- manager_->MarkMipmapsGenerated(texture_);
- EXPECT_TRUE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(1, texture->num_uncleared_mips());
+ manager_->MarkMipmapsGenerated(texture_ref_);
+ EXPECT_TRUE(texture->SafeToRenderFrom());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
+ EXPECT_EQ(0, texture->num_uncleared_mips());
manager_->CreateTexture(kClient2Id, kService2Id);
- scoped_refptr<Texture> texture2(
+ scoped_refptr<TextureRef> texture_ref2(
manager_->GetTexture(kClient2Id));
- ASSERT_TRUE(texture2.get() != NULL);
- manager_->SetTarget(texture2, GL_TEXTURE_2D);
+ ASSERT_TRUE(texture_ref2.get() != NULL);
+ manager_->SetTarget(texture_ref2, GL_TEXTURE_2D);
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
+ Texture* texture2 = texture_ref2->texture();
EXPECT_EQ(0, texture2->num_uncleared_mips());
- manager_->SetLevelInfo(texture2,
+ manager_->SetLevelInfo(texture_ref2,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
EXPECT_EQ(0, texture2->num_uncleared_mips());
- manager_->SetLevelInfo(texture2,
+ manager_->SetLevelInfo(texture_ref2,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
EXPECT_EQ(1, texture2->num_uncleared_mips());
manager_->CreateTexture(kClient3Id, kService3Id);
- scoped_refptr<Texture> texture3(
+ scoped_refptr<TextureRef> texture_ref3(
manager_->GetTexture(kClient3Id));
- ASSERT_TRUE(texture3.get() != NULL);
- manager_->SetTarget(texture3, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture3,
+ ASSERT_TRUE(texture_ref3.get() != NULL);
+ manager_->SetTarget(texture_ref3, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref3,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
+ Texture* texture3 = texture_ref3->texture();
EXPECT_EQ(1, texture3->num_uncleared_mips());
- manager_->SetLevelCleared(texture2, GL_TEXTURE_2D, 0, true);
+ manager_->SetLevelCleared(texture_ref2, GL_TEXTURE_2D, 0, true);
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
EXPECT_EQ(0, texture2->num_uncleared_mips());
- manager_->SetLevelCleared(texture3, GL_TEXTURE_2D, 0, true);
+ manager_->SetLevelCleared(texture_ref3, GL_TEXTURE_2D, 0, true);
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
EXPECT_EQ(0, texture3->num_uncleared_mips());
- manager_->SetLevelInfo(texture2,
+ manager_->SetLevelInfo(texture_ref2,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- manager_->SetLevelInfo(texture3,
+ manager_->SetLevelInfo(texture_ref3,
GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
@@ -1076,13 +1096,13 @@ TEST_F(TextureTest, SafeUnsafe) {
EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
.Times(1)
.RetiresOnSaturation();
- texture2 = NULL;
+ texture_ref2 = NULL;
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id)))
.Times(1)
.RetiresOnSaturation();
- texture3 = NULL;
+ texture_ref3 = NULL;
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
}
@@ -1090,88 +1110,90 @@ TEST_F(TextureTest, SafeUnsafe) {
TEST_F(TextureTest, ClearTexture) {
EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
.WillRepeatedly(Return(true));
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ Texture* texture = texture_ref_->texture();
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(2, texture_->num_uncleared_mips());
- manager_->ClearRenderableLevels(decoder_.get(), texture_);
- EXPECT_TRUE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(2, texture->num_uncleared_mips());
+ manager_->ClearRenderableLevels(decoder_.get(), texture_ref_);
+ EXPECT_TRUE(texture->SafeToRenderFrom());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
- manager_->SetLevelInfo(texture_,
+ EXPECT_EQ(0, texture->num_uncleared_mips());
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(2, texture_->num_uncleared_mips());
- manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 0);
- EXPECT_FALSE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(2, texture->num_uncleared_mips());
+ manager_->ClearTextureLevel(decoder_.get(), texture_ref_, GL_TEXTURE_2D, 0);
+ EXPECT_FALSE(texture->SafeToRenderFrom());
EXPECT_TRUE(manager_->HaveUnsafeTextures());
EXPECT_TRUE(manager_->HaveUnclearedMips());
- EXPECT_EQ(1, texture_->num_uncleared_mips());
- manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 1);
- EXPECT_TRUE(texture_->SafeToRenderFrom());
+ EXPECT_EQ(1, texture->num_uncleared_mips());
+ manager_->ClearTextureLevel(decoder_.get(), texture_ref_, GL_TEXTURE_2D, 1);
+ EXPECT_TRUE(texture->SafeToRenderFrom());
EXPECT_FALSE(manager_->HaveUnsafeTextures());
EXPECT_FALSE(manager_->HaveUnclearedMips());
- EXPECT_EQ(0, texture_->num_uncleared_mips());
+ EXPECT_EQ(0, texture->num_uncleared_mips());
}
TEST_F(TextureTest, UseDeletedTexture) {
static const GLuint kClient2Id = 2;
static const GLuint kService2Id = 12;
// Make the default texture renderable
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
// Make a new texture
manager_->CreateTexture(kClient2Id, kService2Id);
- scoped_refptr<Texture> texture(
+ scoped_refptr<TextureRef> texture_ref(
manager_->GetTexture(kClient2Id));
- manager_->SetTarget(texture, GL_TEXTURE_2D);
- EXPECT_FALSE(manager_->CanRender(texture));
+ manager_->SetTarget(texture_ref, GL_TEXTURE_2D);
+ EXPECT_FALSE(manager_->CanRender(texture_ref));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
// Remove it.
manager_->RemoveTexture(kClient2Id);
- EXPECT_FALSE(manager_->CanRender(texture));
+ EXPECT_FALSE(manager_->CanRender(texture_ref));
EXPECT_TRUE(manager_->HaveUnrenderableTextures());
// Check that we can still manipulate it and it effects the manager.
- manager_->SetLevelInfo(texture,
+ manager_->SetLevelInfo(texture_ref,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
- EXPECT_TRUE(manager_->CanRender(texture));
+ EXPECT_TRUE(manager_->CanRender(texture_ref));
EXPECT_FALSE(manager_->HaveUnrenderableTextures());
EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
.Times(1)
.RetiresOnSaturation();
- texture = NULL;
+ texture_ref = NULL;
}
TEST_F(TextureTest, GetLevelImage) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
// Set image.
- manager_->SetLevelImage(texture_,
+ manager_->SetLevelImage(texture_ref_,
GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0));
- EXPECT_FALSE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+ EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
// Remove it.
- manager_->SetLevelImage(texture_, GL_TEXTURE_2D, 1, NULL);
- EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
- manager_->SetLevelImage(texture_,
+ manager_->SetLevelImage(texture_ref_, GL_TEXTURE_2D, 1, NULL);
+ EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+ manager_->SetLevelImage(texture_ref_,
GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0));
// Image should be reset when SetLevelInfo is called.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+ EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
}
namespace {
@@ -1185,105 +1207,105 @@ bool InSet(std::set<std::string>* string_set, const std::string& str) {
} // anonymous namespace
TEST_F(TextureTest, AddToSignature) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
std::string signature1;
std::string signature2;
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature1);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature1);
std::set<std::string> string_set;
EXPECT_FALSE(InSet(&string_set, signature1));
// check changing 1 thing makes a different signature.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 4, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
// check putting it back makes the same signature.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_EQ(signature1, signature2);
// Check setting cleared status does not change signature.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_EQ(signature1, signature2);
// Check changing other settings changes signature.
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_FLOAT,
false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
// put it back
- manager_->SetLevelInfo(texture_,
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
false);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_EQ(signature1, signature2);
// check changing parameters changes signature.
- SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- SetParameter(
- texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR, GL_NO_ERROR);
- SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER,
+ GL_NEAREST_MIPMAP_LINEAR, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
- SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
- SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
- SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_FALSE(InSet(&string_set, signature2));
// Check putting it back genenerates the same signature
- SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
+ SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
signature2.clear();
- manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+ manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
EXPECT_EQ(signature1, signature2);
// Check the set was acutally getting different signatures.
@@ -1364,8 +1386,10 @@ class SaveRestoreTextureTest : public TextureTest {
bool cleared;
};
- void SetLevelInfo(Texture* texture, GLint level, const LevelInfo& info) {
- manager_->SetLevelInfo(texture,
+ void SetLevelInfo(TextureRef* texture_ref,
+ GLint level,
+ const LevelInfo& info) {
+ manager_->SetLevelInfo(texture_ref,
info.target,
level,
info.format,
@@ -1378,9 +1402,10 @@ class SaveRestoreTextureTest : public TextureTest {
info.cleared);
}
- static LevelInfo GetLevelInfo(const Texture* texture,
+ static LevelInfo GetLevelInfo(const TextureRef* texture_ref,
GLint target,
GLint level) {
+ const Texture* texture = texture_ref->texture();
LevelInfo info;
info.target = target;
EXPECT_TRUE(texture->GetLevelSize(target, level, &info.width,
@@ -1391,27 +1416,27 @@ class SaveRestoreTextureTest : public TextureTest {
return info;
}
- TextureDefinition* Save(Texture* texture) {
+ TextureDefinition* Save(TextureRef* texture_ref) {
EXPECT_CALL(*gl_, GenTextures(_, _))
.WillOnce(SetArgumentPointee<1>(kEmptyTextureServiceId));
- TextureDefinition* definition = manager_->Save(texture);
+ TextureDefinition* definition = manager_->Save(texture_ref);
EXPECT_TRUE(definition != NULL);
return definition;
}
- void Restore(Texture* texture, TextureDefinition* definition) {
- EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(texture->service_id())))
+ void Restore(TextureRef* texture_ref, TextureDefinition* definition) {
+ EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(texture_ref->service_id())))
.Times(1).RetiresOnSaturation();
EXPECT_CALL(*gl_,
BindTexture(definition->target(), definition->service_id()))
.Times(1).RetiresOnSaturation();
EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(AtLeast(1));
- EXPECT_TRUE(
- manager_->Restore("TextureTest", decoder_.get(), texture, definition));
+ EXPECT_TRUE(manager_->Restore("TextureTest", decoder_.get(),
+ texture_ref, definition));
}
- scoped_refptr<Texture> texture2_;
+ scoped_refptr<TextureRef> texture2_;
private:
static const GLuint kEmptyTextureServiceId;
@@ -1424,16 +1449,17 @@ const GLuint SaveRestoreTextureTest::kService2Id = 12;
const GLuint SaveRestoreTextureTest::kEmptyTextureServiceId = 13;
TEST_F(SaveRestoreTextureTest, SaveRestore2D) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
LevelInfo level0(
GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE, true);
- SetLevelInfo(texture_, 0, level0);
- EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- LevelInfo level1 = GetLevelInfo(texture_.get(), GL_TEXTURE_2D, 1);
- LevelInfo level2 = GetLevelInfo(texture_.get(), GL_TEXTURE_2D, 2);
- scoped_ptr<TextureDefinition> definition(Save(texture_));
+ SetLevelInfo(texture_ref_, 0, level0);
+ EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ LevelInfo level1 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1);
+ LevelInfo level2 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2);
+ scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
const TextureDefinition::LevelInfos& infos = definition->level_infos();
EXPECT_EQ(1U, infos.size());
EXPECT_EQ(3U, infos[0].size());
@@ -1446,27 +1472,29 @@ TEST_F(SaveRestoreTextureTest, SaveRestore2D) {
0,
LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1, 0, GL_UNSIGNED_BYTE, false));
EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture2_));
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture2_));
- EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture2_->estimated_size());
+ texture = texture2_->texture();
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture->estimated_size());
Restore(texture2_, definition.release());
EXPECT_EQ(level0, GetLevelInfo(texture2_.get(), GL_TEXTURE_2D, 0));
EXPECT_EQ(level1, GetLevelInfo(texture2_.get(), GL_TEXTURE_2D, 1));
EXPECT_EQ(level2, GetLevelInfo(texture2_.get(), GL_TEXTURE_2D, 2));
- EXPECT_EQ(64U + 16U + 4U, texture2_->estimated_size());
+ EXPECT_EQ(64U + 16U + 4U, texture->estimated_size());
GLint w, h;
- EXPECT_TRUE(texture2_->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
+ EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
EXPECT_EQ(0, w);
EXPECT_EQ(0, h);
}
TEST_F(SaveRestoreTextureTest, SaveRestoreClearRectangle) {
- manager_->SetTarget(texture_, GL_TEXTURE_RECTANGLE_ARB);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_RECTANGLE_ARB);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture->target());
LevelInfo level0(
GL_TEXTURE_RECTANGLE_ARB, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false);
- SetLevelInfo(texture_, 0, level0);
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- scoped_ptr<TextureDefinition> definition(Save(texture_));
+ SetLevelInfo(texture_ref_, 0, level0);
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
const TextureDefinition::LevelInfos& infos = definition->level_infos();
EXPECT_EQ(1U, infos.size());
EXPECT_EQ(1U, infos[0].size());
@@ -1483,22 +1511,24 @@ TEST_F(SaveRestoreTextureTest, SaveRestoreClearRectangle) {
}
TEST_F(SaveRestoreTextureTest, SaveRestoreStreamTexture) {
- manager_->SetTarget(texture_, GL_TEXTURE_EXTERNAL_OES);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture_->target());
- texture_->SetStreamTexture(true);
- GLuint service_id = texture_->service_id();
- scoped_ptr<TextureDefinition> definition(Save(texture_));
- EXPECT_FALSE(texture_->IsStreamTexture());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_EXTERNAL_OES);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
+ texture->SetStreamTexture(true);
+ GLuint service_id = texture->service_id();
+ scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
+ EXPECT_FALSE(texture->IsStreamTexture());
manager_->SetTarget(texture2_, GL_TEXTURE_EXTERNAL_OES);
Restore(texture2_, definition.release());
- EXPECT_TRUE(texture2_->IsStreamTexture());
- EXPECT_TRUE(texture2_->IsImmutable());
+ EXPECT_TRUE(texture2_->texture()->IsStreamTexture());
+ EXPECT_TRUE(texture2_->texture()->IsImmutable());
EXPECT_EQ(service_id, texture2_->service_id());
}
TEST_F(SaveRestoreTextureTest, SaveRestoreCube) {
- manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP);
- EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target());
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_CUBE_MAP);
+ Texture* texture = texture_ref_->texture();
+ EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
GL_RGBA,
1,
@@ -1515,10 +1545,10 @@ TEST_F(SaveRestoreTextureTest, SaveRestoreCube) {
0,
GL_UNSIGNED_BYTE,
true);
- SetLevelInfo(texture_, 0, face0);
- SetLevelInfo(texture_, 0, face5);
- EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
- scoped_ptr<TextureDefinition> definition(Save(texture_));
+ SetLevelInfo(texture_ref_, 0, face0);
+ SetLevelInfo(texture_ref_, 0, face5);
+ EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+ scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
const TextureDefinition::LevelInfos& infos = definition->level_infos();
EXPECT_EQ(6U, infos.size());
EXPECT_EQ(1U, infos[0].size());
« gpu/command_buffer/service/texture_manager.cc ('K') | « gpu/command_buffer/service/texture_manager.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698