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

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: fix accidentally reverted behavior 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
« no previous file with comments | « 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 5cf868372d0506de8b0d55015d581f897df073d9..52668720f6bada99c78d6704bec41c6cd7b277cb 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -7,6 +7,7 @@
#include "base/memory/scoped_ptr.h"
#include "gpu/command_buffer/service/error_state_mock.h"
#include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/framebuffer_manager.h"
#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
#include "gpu/command_buffer/service/memory_tracking.h"
#include "gpu/command_buffer/service/mocks.h"
@@ -75,10 +76,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 +109,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 +134,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 +172,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 +192,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 +212,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 +367,7 @@ class TextureTestBase : public testing::Test {
: feature_info_(new FeatureInfo()) {
}
virtual ~TextureTestBase() {
- texture_ = NULL;
+ texture_ref_ = NULL;
}
protected:
@@ -385,23 +387,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 +412,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 +424,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,78 +451,81 @@ 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_TRUE(TextureTestHelper::IsNPOT(texture_));
- EXPECT_FALSE(manager_->CanRender(texture_));
- EXPECT_TRUE(texture_->SafeToRenderFrom());
- EXPECT_TRUE(texture_->IsImmutable());
- manager_->SetStreamTexture(texture_, true);
- EXPECT_TRUE(manager_->CanRender(texture_));
+ 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_TRUE(TextureTestHelper::IsNPOT(texture));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
+ EXPECT_TRUE(texture->SafeToRenderFrom());
+ EXPECT_TRUE(texture->IsImmutable());
+ manager_->SetStreamTexture(texture_ref_, true);
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
}
TEST_F(TextureTest, ZeroSizeCanNotRender) {
- manager_->SetTarget(texture_, GL_TEXTURE_2D);
- EXPECT_FALSE(manager_->CanRender(texture_));
- manager_->SetLevelInfo(texture_,
+ manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_TRUE(manager_->CanRender(texture_));
- manager_->SetLevelInfo(texture_,
+ EXPECT_TRUE(manager_->CanRender(texture_ref_));
+ manager_->SetLevelInfo(texture_ref_,
GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
- EXPECT_FALSE(manager_->CanRender(texture_));
+ EXPECT_FALSE(manager_->CanRender(texture_ref_));
}
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);
@@ -528,14 +533,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);
@@ -544,116 +549,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());
}
@@ -665,190 +673,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));
}
@@ -860,20 +873,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);
}
@@ -886,11 +900,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);
@@ -904,20 +919,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);
}
@@ -930,11 +946,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);
@@ -948,11 +965,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);
}
@@ -964,13 +982,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);
}
@@ -980,101 +998,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());
@@ -1089,13 +1110,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());
}
@@ -1103,88 +1124,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 {
@@ -1198,105 +1221,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.
@@ -1377,8 +1400,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,
@@ -1391,9 +1416,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,
@@ -1404,27 +1430,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;
@@ -1437,16 +1463,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());
@@ -1459,27 +1486,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());
@@ -1496,22 +1525,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());
- manager_->SetStreamTexture(texture_, 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());
+ manager_->SetStreamTexture(texture_ref_, 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,
@@ -1528,10 +1559,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());
@@ -1543,7 +1574,243 @@ TEST_F(SaveRestoreTextureTest, SaveRestoreCube) {
GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0));
}
-} // namespace gles2
-} // namespace gpu
+class CountingMemoryTracker : public MemoryTracker {
+ public:
+ CountingMemoryTracker() {
+ current_size_[0] = 0;
+ current_size_[1] = 0;
+ }
+ virtual void TrackMemoryAllocatedChange(size_t old_size,
+ size_t new_size,
+ Pool pool) OVERRIDE {
+ DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
+ current_size_[pool] += new_size - old_size;
+ }
+ virtual bool EnsureGPUMemoryAvailable(size_t size_needed) OVERRIDE {
+ return true;
+ }
+
+ size_t GetSize(Pool pool) {
+ DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
+ return current_size_[pool];
+ }
+
+ private:
+ virtual ~CountingMemoryTracker() {}
+
+ size_t current_size_[2];
+ DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
+};
+
+class SharedTextureTest : public testing::Test {
+ public:
+ SharedTextureTest()
+ : feature_info_(new FeatureInfo()) {
+ }
+
+ virtual ~SharedTextureTest() {
+ }
+
+ virtual void SetUp() {
+ gl_.reset(new ::gfx::MockGLInterface());
+ ::gfx::GLInterface::SetGLInterface(gl_.get());
+
+ memory_tracker1_ = new CountingMemoryTracker;
+ texture_manager1_.reset(new TextureManager(
+ memory_tracker1_, feature_info_.get(),
+ TextureManagerTest::kMaxTextureSize,
+ TextureManagerTest::kMaxCubeMapTextureSize));
+ memory_tracker2_ = new CountingMemoryTracker;
+ texture_manager2_.reset(new TextureManager(
+ memory_tracker2_, feature_info_.get(),
+ TextureManagerTest::kMaxTextureSize,
+ TextureManagerTest::kMaxCubeMapTextureSize));
+ TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+ texture_manager1_->Initialize();
+ TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+ texture_manager2_->Initialize();
+ }
+
+ virtual void TearDown() {
+ texture_manager2_->Destroy(false);
+ texture_manager2_.reset();
+ texture_manager1_->Destroy(false);
+ texture_manager1_.reset();
+ ::gfx::GLInterface::SetGLInterface(NULL);
+ gl_.reset();
+ }
+
+ protected:
+ scoped_ptr< ::gfx::MockGLInterface > gl_;
+ scoped_refptr<FeatureInfo> feature_info_;
+ scoped_refptr<CountingMemoryTracker> memory_tracker1_;
+ scoped_ptr<TextureManager> texture_manager1_;
+ scoped_refptr<CountingMemoryTracker> memory_tracker2_;
+ scoped_ptr<TextureManager> texture_manager2_;
+};
+
+TEST_F(SharedTextureTest, DeleteTextures) {
+ scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+ scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+ ref1->texture());
+ EXPECT_CALL(*gl_, DeleteTextures(1, _))
+ .Times(0);
+ ref1 = NULL;
+ texture_manager1_->RemoveTexture(10);
+ testing::Mock::VerifyAndClearExpectations(gl_.get());
+
+ EXPECT_CALL(*gl_, DeleteTextures(1, _))
+ .Times(1)
+ .RetiresOnSaturation();
+ ref2 = NULL;
+ testing::Mock::VerifyAndClearExpectations(gl_.get());
+}
+
+TEST_F(SharedTextureTest, TextureSafetyAccounting) {
+ EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
+ EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
+ EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
+ EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
+ EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
+ EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
+
+ // Newly created texture is unrenderable.
+ scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+ EXPECT_TRUE(texture_manager1_->HaveUnrenderableTextures());
+ EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
+ EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
+
+ // Associate new texture ref to other texture manager, should account for it
+ // too.
+ scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+ ref1->texture());
+ EXPECT_TRUE(texture_manager2_->HaveUnrenderableTextures());
+ EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
+ EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
+
+ // Make texture renderable but uncleared on one texture manager, should affect
+ // other one.
+ texture_manager1_->SetTarget(ref1, GL_TEXTURE_2D);
+ texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, false);
+ EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
+ EXPECT_TRUE(texture_manager1_->HaveUnsafeTextures());
+ EXPECT_TRUE(texture_manager1_->HaveUnclearedMips());
+ EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
+ EXPECT_TRUE(texture_manager2_->HaveUnsafeTextures());
+ EXPECT_TRUE(texture_manager2_->HaveUnclearedMips());
+
+ // Make texture cleared on one texture manager, should affect other one.
+ texture_manager1_->SetLevelCleared(ref1, GL_TEXTURE_2D, 0, true);
+ EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
+ EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
+ EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
+ EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
+
+ EXPECT_CALL(*gl_, DeleteTextures(1, _))
+ .Times(1)
+ .RetiresOnSaturation();
+ texture_manager1_->RemoveTexture(10);
+}
+
+TEST_F(SharedTextureTest, FBOCompletenessCheck) {
+ const GLenum kCompleteValue = GL_FRAMEBUFFER_COMPLETE;
+ FramebufferManager framebuffer_manager1(1, 1);
+ texture_manager1_->set_framebuffer_manager(&framebuffer_manager1);
+ FramebufferManager framebuffer_manager2(1, 1);
+ texture_manager2_->set_framebuffer_manager(&framebuffer_manager2);
+
+ scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+ framebuffer_manager1.CreateFramebuffer(10, 10);
+ scoped_refptr<Framebuffer> framebuffer1 =
+ framebuffer_manager1.GetFramebuffer(10);
+ framebuffer1->AttachTexture(GL_COLOR_ATTACHMENT0, ref1, GL_TEXTURE_2D, 0);
+ EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1));
+ EXPECT_NE(kCompleteValue, framebuffer1->IsPossiblyComplete());
+
+ // Make FBO complete in manager 1.
+ texture_manager1_->SetTarget(ref1, GL_TEXTURE_2D);
+ texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, true);
+ EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
+ framebuffer_manager1.MarkAsComplete(framebuffer1);
+ EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1));
+
+ // Share texture with manager 2.
+ scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+ ref1->texture());
+ framebuffer_manager2.CreateFramebuffer(20, 20);
+ scoped_refptr<Framebuffer> framebuffer2 =
+ framebuffer_manager2.GetFramebuffer(20);
+ framebuffer2->AttachTexture(GL_COLOR_ATTACHMENT0, ref2, GL_TEXTURE_2D, 0);
+ EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2));
+ EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
+ framebuffer_manager2.MarkAsComplete(framebuffer2);
+ EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2));
+
+ // Change level for texture, both FBOs should be marked incomplete
+ texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, true);
+ EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1));
+ EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
+ framebuffer_manager1.MarkAsComplete(framebuffer1);
+ EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1));
+ EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2));
+ EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
+ framebuffer_manager2.MarkAsComplete(framebuffer2);
+ EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2));
+
+ EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _))
+ .Times(2)
+ .RetiresOnSaturation();
+ framebuffer_manager1.RemoveFramebuffer(10);
+ framebuffer_manager2.RemoveFramebuffer(20);
+ EXPECT_CALL(*gl_, DeleteTextures(1, _))
+ .Times(1)
+ .RetiresOnSaturation();
+ texture_manager1_->RemoveTexture(10);
+}
+
+TEST_F(SharedTextureTest, Memory) {
+ size_t initial_memory1 = memory_tracker1_->GetSize(MemoryTracker::kUnmanaged);
+ size_t initial_memory2 = memory_tracker2_->GetSize(MemoryTracker::kUnmanaged);
+
+ // Newly created texture is unrenderable.
+ scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+ texture_manager1_->SetTarget(ref1, GL_TEXTURE_2D);
+ texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 10, 10, 1, 0,
+ GL_RGBA, GL_UNSIGNED_BYTE, false);
+
+ EXPECT_LT(0u, ref1->texture()->estimated_size());
+ EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
+ memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+
+ // Associate new texture ref to other texture manager, it doesn't account for
+ // the texture memory, the first memory tracker still has it.
+ scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+ ref1->texture());
+ EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
+ memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+ EXPECT_EQ(initial_memory2,
+ memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+
+ // Delete the texture, memory should go to the remaining tracker.
+ texture_manager1_->RemoveTexture(10);
+ ref1 = NULL;
+ EXPECT_EQ(initial_memory1,
+ memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+ EXPECT_EQ(initial_memory2 + ref2->texture()->estimated_size(),
+ memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+
+ EXPECT_CALL(*gl_, DeleteTextures(1, _))
+ .Times(1)
+ .RetiresOnSaturation();
+ ref2 = NULL;
+ EXPECT_EQ(initial_memory2,
+ memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+}
+
+} // namespace gles2
+} // namespace gpu
« no previous file with comments | « 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