OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gpu/command_buffer/service/texture_manager.h" | 5 #include "gpu/command_buffer/service/texture_manager.h" |
6 | 6 |
7 #include "base/memory/scoped_ptr.h" | 7 #include "base/memory/scoped_ptr.h" |
8 #include "gpu/command_buffer/service/feature_info.h" | 8 #include "gpu/command_buffer/service/feature_info.h" |
9 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" | 9 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" |
10 #include "gpu/command_buffer/service/memory_tracking.h" | 10 #include "gpu/command_buffer/service/memory_tracking.h" |
(...skipping 29 matching lines...) Expand all Loading... |
40 protected: | 40 protected: |
41 virtual void SetUp() { | 41 virtual void SetUp() { |
42 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); | 42 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); |
43 ::gfx::GLInterface::SetGLInterface(gl_.get()); | 43 ::gfx::GLInterface::SetGLInterface(gl_.get()); |
44 | 44 |
45 manager_.reset(new TextureManager( | 45 manager_.reset(new TextureManager( |
46 NULL, feature_info_.get(), | 46 NULL, feature_info_.get(), |
47 kMaxTextureSize, kMaxCubeMapTextureSize)); | 47 kMaxTextureSize, kMaxCubeMapTextureSize)); |
48 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), ""); | 48 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), ""); |
49 manager_->Initialize(); | 49 manager_->Initialize(); |
| 50 decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>()); |
50 } | 51 } |
51 | 52 |
52 virtual void TearDown() { | 53 virtual void TearDown() { |
53 manager_->Destroy(false); | 54 manager_->Destroy(false); |
54 manager_.reset(); | 55 manager_.reset(); |
55 ::gfx::GLInterface::SetGLInterface(NULL); | 56 ::gfx::GLInterface::SetGLInterface(NULL); |
56 gl_.reset(); | 57 gl_.reset(); |
57 } | 58 } |
58 | 59 |
| 60 void SetParameter( |
| 61 Texture* texture, GLenum pname, GLint value, GLenum error) { |
| 62 TestHelper::SetTexParameterWithExpectations( |
| 63 gl_.get(), decoder_.get(), manager_.get(), |
| 64 texture, pname, value, error); |
| 65 } |
| 66 |
59 // Use StrictMock to make 100% sure we know how GL will be called. | 67 // Use StrictMock to make 100% sure we know how GL will be called. |
60 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; | 68 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; |
61 scoped_refptr<FeatureInfo> feature_info_; | 69 scoped_refptr<FeatureInfo> feature_info_; |
62 scoped_ptr<TextureManager> manager_; | 70 scoped_ptr<TextureManager> manager_; |
| 71 scoped_ptr<MockGLES2Decoder> decoder_; |
63 }; | 72 }; |
64 | 73 |
65 // GCC requires these declarations, but MSVC requires they not be present | 74 // GCC requires these declarations, but MSVC requires they not be present |
66 #ifndef COMPILER_MSVC | 75 #ifndef COMPILER_MSVC |
67 const GLint TextureManagerTest::kMaxTextureSize; | 76 const GLint TextureManagerTest::kMaxTextureSize; |
68 const GLint TextureManagerTest::kMaxCubeMapTextureSize; | 77 const GLint TextureManagerTest::kMaxCubeMapTextureSize; |
69 const GLint TextureManagerTest::kMaxExternalTextureSize; | 78 const GLint TextureManagerTest::kMaxExternalTextureSize; |
70 const GLint TextureManagerTest::kMax2dLevels; | 79 const GLint TextureManagerTest::kMax2dLevels; |
71 const GLint TextureManagerTest::kMaxCubeMapLevels; | 80 const GLint TextureManagerTest::kMaxCubeMapLevels; |
72 const GLint TextureManagerTest::kMaxExternalLevels; | 81 const GLint TextureManagerTest::kMaxExternalLevels; |
73 #endif | 82 #endif |
74 | 83 |
75 TEST_F(TextureManagerTest, Basic) { | 84 TEST_F(TextureManagerTest, Basic) { |
76 const GLuint kClient1Id = 1; | 85 const GLuint kClient1Id = 1; |
77 const GLuint kService1Id = 11; | 86 const GLuint kService1Id = 11; |
78 const GLuint kClient2Id = 2; | 87 const GLuint kClient2Id = 2; |
79 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 88 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
80 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 89 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
81 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 90 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
82 // Check we can create texture. | 91 // Check we can create texture. |
83 manager_->CreateTexture(kClient1Id, kService1Id); | 92 manager_->CreateTexture(kClient1Id, kService1Id); |
84 // Check texture got created. | 93 // Check texture got created. |
85 Texture* info1 = manager_->GetTexture(kClient1Id); | 94 Texture* texture = manager_->GetTexture(kClient1Id); |
86 ASSERT_TRUE(info1 != NULL); | 95 ASSERT_TRUE(texture != NULL); |
87 EXPECT_EQ(kService1Id, info1->service_id()); | 96 EXPECT_EQ(kService1Id, texture->service_id()); |
88 GLuint client_id = 0; | 97 GLuint client_id = 0; |
89 EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id)); | 98 EXPECT_TRUE(manager_->GetClientId(texture->service_id(), &client_id)); |
90 EXPECT_EQ(kClient1Id, client_id); | 99 EXPECT_EQ(kClient1Id, client_id); |
91 // Check we get nothing for a non-existent texture. | 100 // Check we get nothing for a non-existent texture. |
92 EXPECT_TRUE(manager_->GetTexture(kClient2Id) == NULL); | 101 EXPECT_TRUE(manager_->GetTexture(kClient2Id) == NULL); |
93 // Check trying to a remove non-existent textures does not crash. | 102 // Check trying to a remove non-existent textures does not crash. |
94 manager_->RemoveTexture(kClient2Id); | 103 manager_->RemoveTexture(kClient2Id); |
95 // Check that it gets deleted when the last reference is released. | 104 // Check that it gets deleted when the last reference is released. |
96 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id))) | 105 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id))) |
97 .Times(1) | 106 .Times(1) |
98 .RetiresOnSaturation(); | 107 .RetiresOnSaturation(); |
99 // Check we can't get the texture after we remove it. | 108 // Check we can't get the texture after we remove it. |
100 manager_->RemoveTexture(kClient1Id); | 109 manager_->RemoveTexture(kClient1Id); |
101 EXPECT_TRUE(manager_->GetTexture(kClient1Id) == NULL); | 110 EXPECT_TRUE(manager_->GetTexture(kClient1Id) == NULL); |
102 } | 111 } |
103 | 112 |
104 TEST_F(TextureManagerTest, SetParameter) { | 113 TEST_F(TextureManagerTest, SetParameter) { |
105 const GLuint kClient1Id = 1; | 114 const GLuint kClient1Id = 1; |
106 const GLuint kService1Id = 11; | 115 const GLuint kService1Id = 11; |
107 // Check we can create texture. | 116 // Check we can create texture. |
108 manager_->CreateTexture(kClient1Id, kService1Id); | 117 manager_->CreateTexture(kClient1Id, kService1Id); |
109 // Check texture got created. | 118 // Check texture got created. |
110 Texture* info = manager_->GetTexture(kClient1Id); | 119 Texture* texture = manager_->GetTexture(kClient1Id); |
111 ASSERT_TRUE(info != NULL); | 120 manager_->SetTarget(texture, GL_TEXTURE_2D); |
112 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 121 ASSERT_TRUE(texture != NULL); |
113 info, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); | 122 SetParameter(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR); |
114 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->min_filter()); | 123 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter()); |
115 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 124 SetParameter(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); |
116 info, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); | 125 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->mag_filter()); |
117 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->mag_filter()); | 126 SetParameter(texture, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR); |
118 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 127 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s()); |
119 info, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); | 128 SetParameter(texture, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR); |
120 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_s()); | 129 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t()); |
121 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 130 SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR); |
122 info, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); | 131 SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR); |
123 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_t()); | 132 SetParameter( |
124 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 133 texture, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM); |
125 info, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1)); | 134 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter()); |
126 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 135 SetParameter( |
127 info, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2)); | 136 texture, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM); |
128 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter( | 137 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter()); |
129 info, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE)); | 138 SetParameter(texture, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM); |
130 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->min_filter()); | 139 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s()); |
131 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter( | 140 SetParameter(texture, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM); |
132 info, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE)); | 141 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t()); |
133 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->min_filter()); | 142 SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE); |
134 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter( | |
135 info, GL_TEXTURE_WRAP_S, GL_NEAREST)); | |
136 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_s()); | |
137 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter( | |
138 info, GL_TEXTURE_WRAP_T, GL_NEAREST)); | |
139 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_t()); | |
140 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), manager_->SetParameter( | |
141 info, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0)); | |
142 } | 143 } |
143 | 144 |
144 TEST_F(TextureManagerTest, TextureUsageExt) { | 145 TEST_F(TextureManagerTest, TextureUsageExt) { |
145 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), | 146 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), |
146 "GL_ANGLE_texture_usage"); | 147 "GL_ANGLE_texture_usage"); |
147 TextureManager manager( | 148 TextureManager manager( |
148 NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 149 NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
149 manager.Initialize(); | 150 manager.Initialize(); |
150 const GLuint kClient1Id = 1; | 151 const GLuint kClient1Id = 1; |
151 const GLuint kService1Id = 11; | 152 const GLuint kService1Id = 11; |
152 // Check we can create texture. | 153 // Check we can create texture. |
153 manager.CreateTexture(kClient1Id, kService1Id); | 154 manager.CreateTexture(kClient1Id, kService1Id); |
154 // Check texture got created. | 155 // Check texture got created. |
155 Texture* info = manager.GetTexture(kClient1Id); | 156 Texture* texture = manager.GetTexture(kClient1Id); |
156 ASSERT_TRUE(info != NULL); | 157 ASSERT_TRUE(texture != NULL); |
157 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager.SetParameter( | 158 TestHelper::SetTexParameterWithExpectations( |
158 info, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE)); | 159 gl_.get(), decoder_.get(), &manager, texture, |
| 160 GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE,GL_NO_ERROR); |
159 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE), | 161 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE), |
160 info->usage()); | 162 texture->usage()); |
161 manager.Destroy(false); | 163 manager.Destroy(false); |
162 } | 164 } |
163 | 165 |
164 TEST_F(TextureManagerTest, Destroy) { | 166 TEST_F(TextureManagerTest, Destroy) { |
165 const GLuint kClient1Id = 1; | 167 const GLuint kClient1Id = 1; |
166 const GLuint kService1Id = 11; | 168 const GLuint kService1Id = 11; |
167 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), ""); | 169 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), ""); |
168 TextureManager manager( | 170 TextureManager manager( |
169 NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 171 NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
170 manager.Initialize(); | 172 manager.Initialize(); |
171 // Check we can create texture. | 173 // Check we can create texture. |
172 manager.CreateTexture(kClient1Id, kService1Id); | 174 manager.CreateTexture(kClient1Id, kService1Id); |
173 // Check texture got created. | 175 // Check texture got created. |
174 Texture* info1 = manager.GetTexture(kClient1Id); | 176 Texture* texture = manager.GetTexture(kClient1Id); |
175 ASSERT_TRUE(info1 != NULL); | 177 ASSERT_TRUE(texture != NULL); |
176 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id))) | 178 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id))) |
177 .Times(1) | 179 .Times(1) |
178 .RetiresOnSaturation(); | 180 .RetiresOnSaturation(); |
179 TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), ""); | 181 TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), ""); |
180 manager.Destroy(true); | 182 manager.Destroy(true); |
181 // Check that resources got freed. | 183 // Check that resources got freed. |
182 info1 = manager.GetTexture(kClient1Id); | 184 texture = manager.GetTexture(kClient1Id); |
183 ASSERT_TRUE(info1 == NULL); | 185 ASSERT_TRUE(texture == NULL); |
184 } | 186 } |
185 | 187 |
186 TEST_F(TextureManagerTest, DestroyUnowned) { | 188 TEST_F(TextureManagerTest, DestroyUnowned) { |
187 const GLuint kClient1Id = 1; | 189 const GLuint kClient1Id = 1; |
188 const GLuint kService1Id = 11; | 190 const GLuint kService1Id = 11; |
189 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), ""); | 191 TestHelper::SetupTextureManagerInitExpectations(gl_.get(), ""); |
190 TextureManager manager( | 192 TextureManager manager( |
191 NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 193 NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
192 manager.Initialize(); | 194 manager.Initialize(); |
193 // Check we can create texture. | 195 // Check we can create texture. |
194 Texture* created_info = | 196 Texture* created_texture = |
195 manager.CreateTexture(kClient1Id, kService1Id); | 197 manager.CreateTexture(kClient1Id, kService1Id); |
196 created_info->SetNotOwned(); | 198 created_texture->SetNotOwned(); |
197 | 199 |
198 // Check texture got created. | 200 // Check texture got created. |
199 Texture* info1 = manager.GetTexture(kClient1Id); | 201 Texture* texture = manager.GetTexture(kClient1Id); |
200 ASSERT_TRUE(info1 != NULL); | 202 ASSERT_TRUE(texture != NULL); |
201 | 203 |
202 // Check that it is not freed if it is not owned. | 204 // Check that it is not freed if it is not owned. |
203 TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), ""); | 205 TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), ""); |
204 manager.Destroy(true); | 206 manager.Destroy(true); |
205 info1 = manager.GetTexture(kClient1Id); | 207 texture = manager.GetTexture(kClient1Id); |
206 ASSERT_TRUE(info1 == NULL); | 208 ASSERT_TRUE(texture == NULL); |
207 } | 209 } |
208 | 210 |
209 TEST_F(TextureManagerTest, MaxValues) { | 211 TEST_F(TextureManagerTest, MaxValues) { |
210 // Check we get the right values for the max sizes. | 212 // Check we get the right values for the max sizes. |
211 EXPECT_EQ(kMax2dLevels, manager_->MaxLevelsForTarget(GL_TEXTURE_2D)); | 213 EXPECT_EQ(kMax2dLevels, manager_->MaxLevelsForTarget(GL_TEXTURE_2D)); |
212 EXPECT_EQ(kMaxCubeMapLevels, | 214 EXPECT_EQ(kMaxCubeMapLevels, |
213 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP)); | 215 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP)); |
214 EXPECT_EQ(kMaxCubeMapLevels, | 216 EXPECT_EQ(kMaxCubeMapLevels, |
215 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X)); | 217 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X)); |
216 EXPECT_EQ(kMaxCubeMapLevels, | 218 EXPECT_EQ(kMaxCubeMapLevels, |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
326 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1)); | 328 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1)); |
327 // Check NPOT height on level 0 | 329 // Check NPOT height on level 0 |
328 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1)); | 330 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1)); |
329 // Check NPOT width on level 1 | 331 // Check NPOT width on level 1 |
330 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1)); | 332 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1)); |
331 // Check NPOT height on level 1 | 333 // Check NPOT height on level 1 |
332 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1)); | 334 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1)); |
333 manager.Destroy(false); | 335 manager.Destroy(false); |
334 } | 336 } |
335 | 337 |
336 class TextureInfoTestBase : public testing::Test { | 338 class TextureTestBase : public testing::Test { |
337 public: | 339 public: |
338 static const GLint kMaxTextureSize = 16; | 340 static const GLint kMaxTextureSize = 16; |
339 static const GLint kMaxCubeMapTextureSize = 8; | 341 static const GLint kMaxCubeMapTextureSize = 8; |
340 static const GLint kMax2dLevels = 5; | 342 static const GLint kMax2dLevels = 5; |
341 static const GLint kMaxCubeMapLevels = 4; | 343 static const GLint kMaxCubeMapLevels = 4; |
342 static const GLuint kClient1Id = 1; | 344 static const GLuint kClient1Id = 1; |
343 static const GLuint kService1Id = 11; | 345 static const GLuint kService1Id = 11; |
344 | 346 |
345 TextureInfoTestBase() | 347 TextureTestBase() |
346 : feature_info_(new FeatureInfo()) { | 348 : feature_info_(new FeatureInfo()) { |
347 } | 349 } |
348 virtual ~TextureInfoTestBase() { | 350 virtual ~TextureTestBase() { |
349 info_ = NULL; | 351 texture_ = NULL; |
350 } | 352 } |
351 | 353 |
352 protected: | 354 protected: |
353 void SetUpBase(MemoryTracker* memory_tracker) { | 355 void SetUpBase(MemoryTracker* memory_tracker) { |
354 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); | 356 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); |
355 ::gfx::GLInterface::SetGLInterface(gl_.get()); | 357 ::gfx::GLInterface::SetGLInterface(gl_.get()); |
356 manager_.reset(new TextureManager( | 358 manager_.reset(new TextureManager( |
357 memory_tracker, feature_info_.get(), | 359 memory_tracker, feature_info_.get(), |
358 kMaxTextureSize, kMaxCubeMapTextureSize)); | 360 kMaxTextureSize, kMaxCubeMapTextureSize)); |
| 361 decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>()); |
359 manager_->CreateTexture(kClient1Id, kService1Id); | 362 manager_->CreateTexture(kClient1Id, kService1Id); |
360 info_ = manager_->GetTexture(kClient1Id); | 363 texture_ = manager_->GetTexture(kClient1Id); |
361 ASSERT_TRUE(info_.get() != NULL); | 364 ASSERT_TRUE(texture_.get() != NULL); |
362 } | 365 } |
363 | 366 |
364 virtual void TearDown() { | 367 virtual void TearDown() { |
365 if (info_.get()) { | 368 if (texture_.get()) { |
366 GLuint client_id = 0; | 369 GLuint client_id = 0; |
367 // If it's not in the manager then setting info_ to NULL will | 370 // If it's not in the manager then setting texture_ to NULL will |
368 // delete the texture. | 371 // delete the texture. |
369 if (!manager_->GetClientId(info_->service_id(), &client_id)) { | 372 if (!manager_->GetClientId(texture_->service_id(), &client_id)) { |
370 // Check that it gets deleted when the last reference is released. | 373 // Check that it gets deleted when the last reference is released. |
371 EXPECT_CALL(*gl_, | 374 EXPECT_CALL(*gl_, |
372 DeleteTextures(1, ::testing::Pointee(info_->service_id()))) | 375 DeleteTextures(1, ::testing::Pointee(texture_->service_id()))) |
373 .Times(1) | 376 .Times(1) |
374 .RetiresOnSaturation(); | 377 .RetiresOnSaturation(); |
375 } | 378 } |
376 info_ = NULL; | 379 texture_ = NULL; |
377 } | 380 } |
378 manager_->Destroy(false); | 381 manager_->Destroy(false); |
379 manager_.reset(); | 382 manager_.reset(); |
380 ::gfx::GLInterface::SetGLInterface(NULL); | 383 ::gfx::GLInterface::SetGLInterface(NULL); |
381 gl_.reset(); | 384 gl_.reset(); |
382 } | 385 } |
383 | 386 |
| 387 void SetParameter( |
| 388 Texture* texture, GLenum pname, GLint value, GLenum error) { |
| 389 TestHelper::SetTexParameterWithExpectations( |
| 390 gl_.get(), decoder_.get(), manager_.get(), |
| 391 texture, pname, value, error); |
| 392 } |
| 393 |
384 // Use StrictMock to make 100% sure we know how GL will be called. | 394 // Use StrictMock to make 100% sure we know how GL will be called. |
385 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; | 395 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; |
386 scoped_refptr<FeatureInfo> feature_info_; | 396 scoped_refptr<FeatureInfo> feature_info_; |
387 scoped_ptr<TextureManager> manager_; | 397 scoped_ptr<TextureManager> manager_; |
388 scoped_refptr<Texture> info_; | 398 scoped_ptr<MockGLES2Decoder> decoder_; |
| 399 scoped_refptr<Texture> texture_; |
389 }; | 400 }; |
390 | 401 |
391 class TextureInfoTest : public TextureInfoTestBase { | 402 class TextureTest : public TextureTestBase { |
392 protected: | 403 protected: |
393 virtual void SetUp() { | 404 virtual void SetUp() { |
394 SetUpBase(NULL); | 405 SetUpBase(NULL); |
395 } | 406 } |
396 }; | 407 }; |
397 | 408 |
398 class TextureInfoMemoryTrackerTest : public TextureInfoTestBase { | 409 class TextureMemoryTrackerTest : public TextureTestBase { |
399 protected: | 410 protected: |
400 virtual void SetUp() { | 411 virtual void SetUp() { |
401 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); | 412 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); |
402 SetUpBase(mock_memory_tracker_.get()); | 413 SetUpBase(mock_memory_tracker_.get()); |
403 } | 414 } |
404 | 415 |
405 scoped_refptr<MockMemoryTracker> mock_memory_tracker_; | 416 scoped_refptr<MockMemoryTracker> mock_memory_tracker_; |
406 }; | 417 }; |
407 | 418 |
408 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ | 419 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ |
409 EXPECT_CALL(*mock_memory_tracker_, \ | 420 EXPECT_CALL(*mock_memory_tracker_, \ |
410 TrackMemoryAllocatedChange(old_size, new_size, pool)) \ | 421 TrackMemoryAllocatedChange(old_size, new_size, pool)) \ |
411 .Times(1) \ | 422 .Times(1) \ |
412 .RetiresOnSaturation() \ | 423 .RetiresOnSaturation() \ |
413 | 424 |
414 TEST_F(TextureInfoTest, Basic) { | 425 TEST_F(TextureTest, Basic) { |
415 EXPECT_EQ(0u, info_->target()); | 426 EXPECT_EQ(0u, texture_->target()); |
416 EXPECT_FALSE(info_->texture_complete()); | 427 EXPECT_FALSE(texture_->texture_complete()); |
417 EXPECT_FALSE(info_->cube_complete()); | 428 EXPECT_FALSE(texture_->cube_complete()); |
418 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 429 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
419 EXPECT_FALSE(info_->npot()); | 430 EXPECT_FALSE(texture_->npot()); |
420 EXPECT_EQ(0, info_->num_uncleared_mips()); | 431 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
421 EXPECT_FALSE(manager_->CanRender(info_)); | 432 EXPECT_FALSE(manager_->CanRender(texture_)); |
422 EXPECT_TRUE(info_->SafeToRenderFrom()); | 433 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
423 EXPECT_FALSE(info_->IsImmutable()); | 434 EXPECT_FALSE(texture_->IsImmutable()); |
424 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR), info_->min_filter()); | 435 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR), |
425 EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), info_->mag_filter()); | 436 texture_->min_filter()); |
426 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), info_->wrap_s()); | 437 EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture_->mag_filter()); |
427 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), info_->wrap_t()); | 438 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture_->wrap_s()); |
| 439 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture_->wrap_t()); |
428 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 440 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
429 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 441 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
430 EXPECT_EQ(0u, info_->estimated_size()); | 442 EXPECT_EQ(0u, texture_->estimated_size()); |
431 } | 443 } |
432 | 444 |
433 TEST_F(TextureInfoTest, EstimatedSize) { | 445 TEST_F(TextureTest, EstimatedSize) { |
434 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 446 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
435 manager_->SetLevelInfo(info_, | 447 manager_->SetLevelInfo(texture_, |
436 GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 448 GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
437 EXPECT_EQ(8u * 4u * 4u, info_->estimated_size()); | 449 EXPECT_EQ(8u * 4u * 4u, texture_->estimated_size()); |
438 manager_->SetLevelInfo(info_, | 450 manager_->SetLevelInfo(texture_, |
439 GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 451 GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
440 EXPECT_EQ(8u * 4u * 4u * 2u, info_->estimated_size()); | 452 EXPECT_EQ(8u * 4u * 4u * 2u, texture_->estimated_size()); |
441 } | 453 } |
442 | 454 |
443 TEST_F(TextureInfoMemoryTrackerTest, EstimatedSize) { | 455 TEST_F(TextureMemoryTrackerTest, EstimatedSize) { |
444 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 456 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
445 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged); | 457 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged); |
446 manager_->SetLevelInfo(info_, | 458 manager_->SetLevelInfo(texture_, |
447 GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 459 GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
448 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged); | 460 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged); |
449 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged); | 461 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged); |
450 manager_->SetLevelInfo(info_, | 462 manager_->SetLevelInfo(texture_, |
451 GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 463 GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
452 // Add expectation for texture deletion. | 464 // Add expectation for texture deletion. |
453 EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged); | 465 EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged); |
454 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); | 466 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); |
455 } | 467 } |
456 | 468 |
457 TEST_F(TextureInfoMemoryTrackerTest, SetParameterPool) { | 469 TEST_F(TextureMemoryTrackerTest, SetParameterPool) { |
458 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 470 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
459 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged); | 471 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged); |
460 manager_->SetLevelInfo(info_, | 472 manager_->SetLevelInfo(texture_, |
461 GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 473 GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
462 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged); | 474 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged); |
463 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged); | 475 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged); |
464 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter( | 476 SetParameter( |
465 info_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM)); | 477 texture_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM, |
| 478 GL_NO_ERROR); |
466 // Add expectation for texture deletion. | 479 // Add expectation for texture deletion. |
467 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged); | 480 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged); |
468 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); | 481 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); |
469 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); | 482 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); |
470 } | 483 } |
471 | 484 |
472 TEST_F(TextureInfoTest, POT2D) { | 485 TEST_F(TextureTest, POT2D) { |
473 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 486 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
474 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info_->target()); | 487 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target()); |
475 // Check Setting level 0 to POT | 488 // Check Setting level 0 to POT |
476 manager_->SetLevelInfo(info_, | 489 manager_->SetLevelInfo(texture_, |
477 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 490 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
478 EXPECT_FALSE(info_->npot()); | 491 EXPECT_FALSE(texture_->npot()); |
479 EXPECT_FALSE(info_->texture_complete()); | 492 EXPECT_FALSE(texture_->texture_complete()); |
480 EXPECT_FALSE(manager_->CanRender(info_)); | 493 EXPECT_FALSE(manager_->CanRender(texture_)); |
481 EXPECT_EQ(0, info_->num_uncleared_mips()); | 494 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
482 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 495 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
483 // Set filters to something that will work with a single mip. | 496 // Set filters to something that will work with a single mip. |
484 manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_LINEAR); | 497 SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR); |
485 EXPECT_TRUE(manager_->CanRender(info_)); | 498 EXPECT_TRUE(manager_->CanRender(texture_)); |
486 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 499 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
487 // Set them back. | 500 // Set them back. |
488 manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); | 501 SetParameter( |
| 502 texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR, GL_NO_ERROR); |
489 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 503 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
490 | 504 |
491 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 505 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
492 // Make mips. | 506 // Make mips. |
493 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 507 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
494 EXPECT_TRUE(info_->texture_complete()); | 508 EXPECT_TRUE(texture_->texture_complete()); |
495 EXPECT_TRUE(manager_->CanRender(info_)); | 509 EXPECT_TRUE(manager_->CanRender(texture_)); |
496 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 510 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
497 // Change a mip. | 511 // Change a mip. |
498 manager_->SetLevelInfo(info_, | 512 manager_->SetLevelInfo(texture_, |
499 GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 513 GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
500 EXPECT_FALSE(info_->npot()); | 514 EXPECT_FALSE(texture_->npot()); |
501 EXPECT_FALSE(info_->texture_complete()); | 515 EXPECT_FALSE(texture_->texture_complete()); |
502 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 516 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
503 EXPECT_FALSE(manager_->CanRender(info_)); | 517 EXPECT_FALSE(manager_->CanRender(texture_)); |
504 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 518 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
505 // Set a level past the number of mips that would get generated. | 519 // Set a level past the number of mips that would get generated. |
506 manager_->SetLevelInfo(info_, | 520 manager_->SetLevelInfo(texture_, |
507 GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 521 GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
508 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 522 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
509 // Make mips. | 523 // Make mips. |
510 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 524 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
511 EXPECT_TRUE(manager_->CanRender(info_)); | 525 EXPECT_TRUE(manager_->CanRender(texture_)); |
512 EXPECT_TRUE(info_->texture_complete()); | 526 EXPECT_TRUE(texture_->texture_complete()); |
513 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 527 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
514 } | 528 } |
515 | 529 |
516 TEST_F(TextureInfoMemoryTrackerTest, MarkMipmapsGenerated) { | 530 TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) { |
517 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 531 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
518 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged); | 532 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged); |
519 manager_->SetLevelInfo(info_, | 533 manager_->SetLevelInfo(texture_, |
520 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 534 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
521 EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged); | 535 EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged); |
522 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged); | 536 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged); |
523 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 537 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
524 EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged); | 538 EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged); |
525 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); | 539 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); |
526 } | 540 } |
527 | 541 |
528 TEST_F(TextureInfoTest, UnusedMips) { | 542 TEST_F(TextureTest, UnusedMips) { |
529 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 543 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
530 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info_->target()); | 544 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target()); |
531 // Set level zero to large size. | 545 // Set level zero to large size. |
532 manager_->SetLevelInfo(info_, | 546 manager_->SetLevelInfo(texture_, |
533 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 547 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
534 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 548 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
535 EXPECT_FALSE(info_->npot()); | 549 EXPECT_FALSE(texture_->npot()); |
536 EXPECT_TRUE(info_->texture_complete()); | 550 EXPECT_TRUE(texture_->texture_complete()); |
537 EXPECT_TRUE(manager_->CanRender(info_)); | 551 EXPECT_TRUE(manager_->CanRender(texture_)); |
538 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 552 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
539 // Set level zero to large smaller (levels unused mips) | 553 // Set level zero to large smaller (levels unused mips) |
540 manager_->SetLevelInfo(info_, | 554 manager_->SetLevelInfo(texture_, |
541 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 555 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
542 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 556 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
543 EXPECT_FALSE(info_->npot()); | 557 EXPECT_FALSE(texture_->npot()); |
544 EXPECT_TRUE(info_->texture_complete()); | 558 EXPECT_TRUE(texture_->texture_complete()); |
545 EXPECT_TRUE(manager_->CanRender(info_)); | 559 EXPECT_TRUE(manager_->CanRender(texture_)); |
546 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 560 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
547 // Set an unused level to some size | 561 // Set an unused level to some size |
548 manager_->SetLevelInfo(info_, | 562 manager_->SetLevelInfo(texture_, |
549 GL_TEXTURE_2D, 4, GL_RGBA, 16, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 563 GL_TEXTURE_2D, 4, GL_RGBA, 16, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
550 EXPECT_FALSE(info_->npot()); | 564 EXPECT_FALSE(texture_->npot()); |
551 EXPECT_TRUE(info_->texture_complete()); | 565 EXPECT_TRUE(texture_->texture_complete()); |
552 EXPECT_TRUE(manager_->CanRender(info_)); | 566 EXPECT_TRUE(manager_->CanRender(texture_)); |
553 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 567 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
554 } | 568 } |
555 | 569 |
556 TEST_F(TextureInfoTest, NPOT2D) { | 570 TEST_F(TextureTest, NPOT2D) { |
557 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 571 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
558 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info_->target()); | 572 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target()); |
559 // Check Setting level 0 to NPOT | 573 // Check Setting level 0 to NPOT |
560 manager_->SetLevelInfo(info_, | 574 manager_->SetLevelInfo(texture_, |
561 GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 575 GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
562 EXPECT_TRUE(info_->npot()); | 576 EXPECT_TRUE(texture_->npot()); |
563 EXPECT_FALSE(info_->texture_complete()); | 577 EXPECT_FALSE(texture_->texture_complete()); |
564 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 578 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
565 EXPECT_FALSE(manager_->CanRender(info_)); | 579 EXPECT_FALSE(manager_->CanRender(texture_)); |
566 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 580 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
567 manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_LINEAR); | 581 SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR); |
568 EXPECT_FALSE(manager_->CanRender(info_)); | 582 EXPECT_FALSE(manager_->CanRender(texture_)); |
569 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 583 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
570 manager_->SetParameter(info_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | 584 SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR); |
571 EXPECT_FALSE(manager_->CanRender(info_)); | 585 EXPECT_FALSE(manager_->CanRender(texture_)); |
572 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 586 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
573 manager_->SetParameter(info_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); | 587 SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR); |
574 EXPECT_TRUE(manager_->CanRender(info_)); | 588 EXPECT_TRUE(manager_->CanRender(texture_)); |
575 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 589 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
576 // Change it to POT. | 590 // Change it to POT. |
577 manager_->SetLevelInfo(info_, | 591 manager_->SetLevelInfo(texture_, |
578 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 592 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
579 EXPECT_FALSE(info_->npot()); | 593 EXPECT_FALSE(texture_->npot()); |
580 EXPECT_FALSE(info_->texture_complete()); | 594 EXPECT_FALSE(texture_->texture_complete()); |
581 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 595 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
582 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 596 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
583 } | 597 } |
584 | 598 |
585 TEST_F(TextureInfoTest, NPOT2DNPOTOK) { | 599 TEST_F(TextureTest, NPOT2DNPOTOK) { |
586 TestHelper::SetupFeatureInfoInitExpectations( | 600 TestHelper::SetupFeatureInfoInitExpectations( |
587 gl_.get(), "GL_OES_texture_npot"); | 601 gl_.get(), "GL_OES_texture_npot"); |
588 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 602 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
589 feature_info->Initialize(NULL); | 603 feature_info->Initialize(NULL); |
590 TextureManager manager( | 604 TextureManager manager( |
591 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 605 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
592 manager.CreateTexture(kClient1Id, kService1Id); | 606 manager.CreateTexture(kClient1Id, kService1Id); |
593 Texture* info = manager.GetTexture(kClient1Id); | 607 Texture* texture = manager.GetTexture(kClient1Id); |
594 ASSERT_TRUE(info_ != NULL); | 608 ASSERT_TRUE(texture != NULL); |
595 | 609 |
596 manager.SetInfoTarget(info, GL_TEXTURE_2D); | 610 manager.SetTarget(texture, GL_TEXTURE_2D); |
597 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target()); | 611 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); |
598 // Check Setting level 0 to NPOT | 612 // Check Setting level 0 to NPOT |
599 manager.SetLevelInfo(info, | 613 manager.SetLevelInfo(texture, |
600 GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 614 GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
601 EXPECT_TRUE(info->npot()); | 615 EXPECT_TRUE(texture->npot()); |
602 EXPECT_FALSE(info->texture_complete()); | 616 EXPECT_FALSE(texture->texture_complete()); |
603 EXPECT_TRUE(manager.CanGenerateMipmaps(info)); | 617 EXPECT_TRUE(manager.CanGenerateMipmaps(texture)); |
604 EXPECT_FALSE(manager.CanRender(info)); | 618 EXPECT_FALSE(manager.CanRender(texture)); |
605 EXPECT_TRUE(manager.HaveUnrenderableTextures()); | 619 EXPECT_TRUE(manager.HaveUnrenderableTextures()); |
606 EXPECT_TRUE(manager.MarkMipmapsGenerated(info)); | 620 EXPECT_TRUE(manager.MarkMipmapsGenerated(texture)); |
607 EXPECT_TRUE(info->texture_complete()); | 621 EXPECT_TRUE(texture->texture_complete()); |
608 EXPECT_TRUE(manager.CanRender(info)); | 622 EXPECT_TRUE(manager.CanRender(texture)); |
609 EXPECT_FALSE(manager.HaveUnrenderableTextures()); | 623 EXPECT_FALSE(manager.HaveUnrenderableTextures()); |
610 manager.Destroy(false); | 624 manager.Destroy(false); |
611 } | 625 } |
612 | 626 |
613 TEST_F(TextureInfoTest, POTCubeMap) { | 627 TEST_F(TextureTest, POTCubeMap) { |
614 manager_->SetInfoTarget(info_, GL_TEXTURE_CUBE_MAP); | 628 manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP); |
615 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), info_->target()); | 629 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target()); |
616 // Check Setting level 0 each face to POT | 630 // Check Setting level 0 each face to POT |
617 manager_->SetLevelInfo(info_, | 631 manager_->SetLevelInfo(texture_, |
618 GL_TEXTURE_CUBE_MAP_POSITIVE_X, | 632 GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
619 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 633 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
620 EXPECT_FALSE(info_->npot()); | 634 EXPECT_FALSE(texture_->npot()); |
621 EXPECT_FALSE(info_->texture_complete()); | 635 EXPECT_FALSE(texture_->texture_complete()); |
622 EXPECT_FALSE(info_->cube_complete()); | 636 EXPECT_FALSE(texture_->cube_complete()); |
623 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 637 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
624 EXPECT_FALSE(manager_->CanRender(info_)); | 638 EXPECT_FALSE(manager_->CanRender(texture_)); |
625 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 639 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
626 manager_->SetLevelInfo(info_, | 640 manager_->SetLevelInfo(texture_, |
627 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, | 641 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
628 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 642 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
629 EXPECT_FALSE(info_->npot()); | 643 EXPECT_FALSE(texture_->npot()); |
630 EXPECT_FALSE(info_->texture_complete()); | 644 EXPECT_FALSE(texture_->texture_complete()); |
631 EXPECT_FALSE(info_->cube_complete()); | 645 EXPECT_FALSE(texture_->cube_complete()); |
632 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 646 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
633 EXPECT_FALSE(manager_->CanRender(info_)); | 647 EXPECT_FALSE(manager_->CanRender(texture_)); |
634 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 648 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
635 manager_->SetLevelInfo(info_, | 649 manager_->SetLevelInfo(texture_, |
636 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, | 650 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
637 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 651 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
638 EXPECT_FALSE(info_->npot()); | 652 EXPECT_FALSE(texture_->npot()); |
639 EXPECT_FALSE(info_->texture_complete()); | 653 EXPECT_FALSE(texture_->texture_complete()); |
640 EXPECT_FALSE(info_->cube_complete()); | 654 EXPECT_FALSE(texture_->cube_complete()); |
641 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 655 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
642 EXPECT_FALSE(manager_->CanRender(info_)); | 656 EXPECT_FALSE(manager_->CanRender(texture_)); |
643 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 657 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
644 manager_->SetLevelInfo(info_, | 658 manager_->SetLevelInfo(texture_, |
645 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, | 659 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
646 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 660 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
647 EXPECT_FALSE(info_->npot()); | 661 EXPECT_FALSE(texture_->npot()); |
648 EXPECT_FALSE(info_->texture_complete()); | 662 EXPECT_FALSE(texture_->texture_complete()); |
649 EXPECT_FALSE(info_->cube_complete()); | 663 EXPECT_FALSE(texture_->cube_complete()); |
650 EXPECT_FALSE(manager_->CanRender(info_)); | 664 EXPECT_FALSE(manager_->CanRender(texture_)); |
651 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 665 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
652 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 666 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
653 manager_->SetLevelInfo(info_, | 667 manager_->SetLevelInfo(texture_, |
654 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, | 668 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, |
655 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 669 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
656 EXPECT_FALSE(info_->npot()); | 670 EXPECT_FALSE(texture_->npot()); |
657 EXPECT_FALSE(info_->texture_complete()); | 671 EXPECT_FALSE(texture_->texture_complete()); |
658 EXPECT_FALSE(info_->cube_complete()); | 672 EXPECT_FALSE(texture_->cube_complete()); |
659 EXPECT_FALSE(manager_->CanGenerateMipmaps(info_)); | 673 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_)); |
660 EXPECT_FALSE(manager_->CanRender(info_)); | 674 EXPECT_FALSE(manager_->CanRender(texture_)); |
661 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 675 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
662 manager_->SetLevelInfo(info_, | 676 manager_->SetLevelInfo(texture_, |
663 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, | 677 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
664 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 678 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
665 EXPECT_FALSE(info_->npot()); | 679 EXPECT_FALSE(texture_->npot()); |
666 EXPECT_FALSE(info_->texture_complete()); | 680 EXPECT_FALSE(texture_->texture_complete()); |
667 EXPECT_TRUE(info_->cube_complete()); | 681 EXPECT_TRUE(texture_->cube_complete()); |
668 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 682 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
669 EXPECT_FALSE(manager_->CanRender(info_)); | 683 EXPECT_FALSE(manager_->CanRender(texture_)); |
670 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 684 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
671 | 685 |
672 // Make mips. | 686 // Make mips. |
673 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 687 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
674 EXPECT_TRUE(info_->texture_complete()); | 688 EXPECT_TRUE(texture_->texture_complete()); |
675 EXPECT_TRUE(info_->cube_complete()); | 689 EXPECT_TRUE(texture_->cube_complete()); |
676 EXPECT_TRUE(manager_->CanRender(info_)); | 690 EXPECT_TRUE(manager_->CanRender(texture_)); |
677 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 691 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
678 | 692 |
679 // Change a mip. | 693 // Change a mip. |
680 manager_->SetLevelInfo(info_, | 694 manager_->SetLevelInfo(texture_, |
681 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, | 695 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
682 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 696 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
683 EXPECT_FALSE(info_->npot()); | 697 EXPECT_FALSE(texture_->npot()); |
684 EXPECT_FALSE(info_->texture_complete()); | 698 EXPECT_FALSE(texture_->texture_complete()); |
685 EXPECT_TRUE(info_->cube_complete()); | 699 EXPECT_TRUE(texture_->cube_complete()); |
686 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 700 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
687 // Set a level past the number of mips that would get generated. | 701 // Set a level past the number of mips that would get generated. |
688 manager_->SetLevelInfo(info_, | 702 manager_->SetLevelInfo(texture_, |
689 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, | 703 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
690 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 704 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
691 EXPECT_TRUE(manager_->CanGenerateMipmaps(info_)); | 705 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_)); |
692 // Make mips. | 706 // Make mips. |
693 EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_)); | 707 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_)); |
694 EXPECT_TRUE(info_->texture_complete()); | 708 EXPECT_TRUE(texture_->texture_complete()); |
695 EXPECT_TRUE(info_->cube_complete()); | 709 EXPECT_TRUE(texture_->cube_complete()); |
696 } | 710 } |
697 | 711 |
698 TEST_F(TextureInfoTest, GetLevelSize) { | 712 TEST_F(TextureTest, GetLevelSize) { |
699 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 713 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
700 manager_->SetLevelInfo(info_, | 714 manager_->SetLevelInfo(texture_, |
701 GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 715 GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
702 GLsizei width = -1; | 716 GLsizei width = -1; |
703 GLsizei height = -1; | 717 GLsizei height = -1; |
704 EXPECT_FALSE(info_->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height)); | 718 EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height)); |
705 EXPECT_FALSE(info_->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height)); | 719 EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height)); |
706 EXPECT_FALSE(info_->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height)); | 720 EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height)); |
707 EXPECT_TRUE(info_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height)); | 721 EXPECT_TRUE(texture_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height)); |
708 EXPECT_EQ(4, width); | 722 EXPECT_EQ(4, width); |
709 EXPECT_EQ(5, height); | 723 EXPECT_EQ(5, height); |
710 manager_->RemoveTexture(kClient1Id); | 724 manager_->RemoveTexture(kClient1Id); |
711 EXPECT_TRUE(info_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height)); | 725 EXPECT_TRUE(texture_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height)); |
712 EXPECT_EQ(4, width); | 726 EXPECT_EQ(4, width); |
713 EXPECT_EQ(5, height); | 727 EXPECT_EQ(5, height); |
714 } | 728 } |
715 | 729 |
716 TEST_F(TextureInfoTest, GetLevelType) { | 730 TEST_F(TextureTest, GetLevelType) { |
717 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 731 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
718 manager_->SetLevelInfo(info_, | 732 manager_->SetLevelInfo(texture_, |
719 GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 733 GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
720 GLenum type = -1; | 734 GLenum type = -1; |
721 GLenum format = -1; | 735 GLenum format = -1; |
722 EXPECT_FALSE(info_->GetLevelType(GL_TEXTURE_2D, -1, &type, &format)); | 736 EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, -1, &type, &format)); |
723 EXPECT_FALSE(info_->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format)); | 737 EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format)); |
724 EXPECT_FALSE(info_->GetLevelType(GL_TEXTURE_2D, 0, &type, &format)); | 738 EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, 0, &type, &format)); |
725 EXPECT_TRUE(info_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format)); | 739 EXPECT_TRUE(texture_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format)); |
726 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type); | 740 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type); |
727 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format); | 741 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format); |
728 manager_->RemoveTexture(kClient1Id); | 742 manager_->RemoveTexture(kClient1Id); |
729 EXPECT_TRUE(info_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format)); | 743 EXPECT_TRUE(texture_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format)); |
730 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type); | 744 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type); |
731 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format); | 745 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format); |
732 } | 746 } |
733 | 747 |
734 TEST_F(TextureInfoTest, ValidForTexture) { | 748 TEST_F(TextureTest, ValidForTexture) { |
735 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 749 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
736 manager_->SetLevelInfo(info_, | 750 manager_->SetLevelInfo(texture_, |
737 GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 751 GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
738 // Check bad face. | 752 // Check bad face. |
739 EXPECT_FALSE(info_->ValidForTexture( | 753 EXPECT_FALSE(texture_->ValidForTexture( |
740 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, | 754 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
741 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 755 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
742 // Check bad level. | 756 // Check bad level. |
743 EXPECT_FALSE(info_->ValidForTexture( | 757 EXPECT_FALSE(texture_->ValidForTexture( |
744 GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 758 GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
745 // Check bad xoffset. | 759 // Check bad xoffset. |
746 EXPECT_FALSE(info_->ValidForTexture( | 760 EXPECT_FALSE(texture_->ValidForTexture( |
747 GL_TEXTURE_2D, 1, -1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 761 GL_TEXTURE_2D, 1, -1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
748 // Check bad xoffset + width > width. | 762 // Check bad xoffset + width > width. |
749 EXPECT_FALSE(info_->ValidForTexture( | 763 EXPECT_FALSE(texture_->ValidForTexture( |
750 GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 764 GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
751 // Check bad yoffset. | 765 // Check bad yoffset. |
752 EXPECT_FALSE(info_->ValidForTexture( | 766 EXPECT_FALSE(texture_->ValidForTexture( |
753 GL_TEXTURE_2D, 1, 0, -1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 767 GL_TEXTURE_2D, 1, 0, -1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
754 // Check bad yoffset + height > height. | 768 // Check bad yoffset + height > height. |
755 EXPECT_FALSE(info_->ValidForTexture( | 769 EXPECT_FALSE(texture_->ValidForTexture( |
756 GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 770 GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
757 // Check bad width. | 771 // Check bad width. |
758 EXPECT_FALSE(info_->ValidForTexture( | 772 EXPECT_FALSE(texture_->ValidForTexture( |
759 GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 773 GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
760 // Check bad height. | 774 // Check bad height. |
761 EXPECT_FALSE(info_->ValidForTexture( | 775 EXPECT_FALSE(texture_->ValidForTexture( |
762 GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_RGBA, GL_UNSIGNED_BYTE)); | 776 GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_RGBA, GL_UNSIGNED_BYTE)); |
763 // Check bad format. | 777 // Check bad format. |
764 EXPECT_FALSE(info_->ValidForTexture( | 778 EXPECT_FALSE(texture_->ValidForTexture( |
765 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGB, GL_UNSIGNED_BYTE)); | 779 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGB, GL_UNSIGNED_BYTE)); |
766 // Check bad type. | 780 // Check bad type. |
767 EXPECT_FALSE(info_->ValidForTexture( | 781 EXPECT_FALSE(texture_->ValidForTexture( |
768 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4)); | 782 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4)); |
769 // Check valid full size | 783 // Check valid full size |
770 EXPECT_TRUE(info_->ValidForTexture( | 784 EXPECT_TRUE(texture_->ValidForTexture( |
771 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 785 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
772 // Check valid particial size. | 786 // Check valid particial size. |
773 EXPECT_TRUE(info_->ValidForTexture( | 787 EXPECT_TRUE(texture_->ValidForTexture( |
774 GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_RGBA, GL_UNSIGNED_BYTE)); | 788 GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_RGBA, GL_UNSIGNED_BYTE)); |
775 manager_->RemoveTexture(kClient1Id); | 789 manager_->RemoveTexture(kClient1Id); |
776 EXPECT_TRUE(info_->ValidForTexture( | 790 EXPECT_TRUE(texture_->ValidForTexture( |
777 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); | 791 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE)); |
778 } | 792 } |
779 | 793 |
780 TEST_F(TextureInfoTest, FloatNotLinear) { | 794 TEST_F(TextureTest, FloatNotLinear) { |
781 TestHelper::SetupFeatureInfoInitExpectations( | 795 TestHelper::SetupFeatureInfoInitExpectations( |
782 gl_.get(), "GL_OES_texture_float"); | 796 gl_.get(), "GL_OES_texture_float"); |
783 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 797 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
784 feature_info->Initialize(NULL); | 798 feature_info->Initialize(NULL); |
785 TextureManager manager( | 799 TextureManager manager( |
786 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 800 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
787 manager.CreateTexture(kClient1Id, kService1Id); | 801 manager.CreateTexture(kClient1Id, kService1Id); |
788 Texture* info = manager.GetTexture(kClient1Id); | 802 Texture* texture = manager.GetTexture(kClient1Id); |
789 ASSERT_TRUE(info != NULL); | 803 ASSERT_TRUE(texture != NULL); |
790 manager.SetInfoTarget(info, GL_TEXTURE_2D); | 804 manager.SetTarget(texture, GL_TEXTURE_2D); |
791 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target()); | 805 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); |
792 manager.SetLevelInfo(info, | 806 manager.SetLevelInfo(texture, |
793 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true); | 807 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true); |
794 EXPECT_FALSE(info->texture_complete()); | 808 EXPECT_FALSE(texture->texture_complete()); |
795 manager.SetParameter(info, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | 809 TestHelper::SetTexParameterWithExpectations( |
796 EXPECT_FALSE(info->texture_complete()); | 810 gl_.get(), decoder_.get(), &manager, |
797 manager.SetParameter(info, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); | 811 texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); |
798 EXPECT_TRUE(info->texture_complete()); | 812 EXPECT_FALSE(texture->texture_complete()); |
| 813 TestHelper::SetTexParameterWithExpectations( |
| 814 gl_.get(), decoder_.get(), &manager, |
| 815 texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR); |
| 816 EXPECT_TRUE(texture->texture_complete()); |
799 manager.Destroy(false); | 817 manager.Destroy(false); |
800 } | 818 } |
801 | 819 |
802 TEST_F(TextureInfoTest, FloatLinear) { | 820 TEST_F(TextureTest, FloatLinear) { |
803 TestHelper::SetupFeatureInfoInitExpectations( | 821 TestHelper::SetupFeatureInfoInitExpectations( |
804 gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear"); | 822 gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear"); |
805 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 823 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
806 feature_info->Initialize(NULL); | 824 feature_info->Initialize(NULL); |
807 TextureManager manager( | 825 TextureManager manager( |
808 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 826 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
809 manager.CreateTexture(kClient1Id, kService1Id); | 827 manager.CreateTexture(kClient1Id, kService1Id); |
810 Texture* info = manager.GetTexture(kClient1Id); | 828 Texture* texture = manager.GetTexture(kClient1Id); |
811 ASSERT_TRUE(info != NULL); | 829 ASSERT_TRUE(texture != NULL); |
812 manager.SetInfoTarget(info, GL_TEXTURE_2D); | 830 manager.SetTarget(texture, GL_TEXTURE_2D); |
813 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target()); | 831 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); |
814 manager.SetLevelInfo(info, | 832 manager.SetLevelInfo(texture, |
815 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true); | 833 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true); |
816 EXPECT_TRUE(info->texture_complete()); | 834 EXPECT_TRUE(texture->texture_complete()); |
817 manager.Destroy(false); | 835 manager.Destroy(false); |
818 } | 836 } |
819 | 837 |
820 TEST_F(TextureInfoTest, HalfFloatNotLinear) { | 838 TEST_F(TextureTest, HalfFloatNotLinear) { |
821 TestHelper::SetupFeatureInfoInitExpectations( | 839 TestHelper::SetupFeatureInfoInitExpectations( |
822 gl_.get(), "GL_OES_texture_half_float"); | 840 gl_.get(), "GL_OES_texture_half_float"); |
823 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 841 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
824 feature_info->Initialize(NULL); | 842 feature_info->Initialize(NULL); |
825 TextureManager manager( | 843 TextureManager manager( |
826 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 844 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
827 manager.CreateTexture(kClient1Id, kService1Id); | 845 manager.CreateTexture(kClient1Id, kService1Id); |
828 Texture* info = manager.GetTexture(kClient1Id); | 846 Texture* texture = manager.GetTexture(kClient1Id); |
829 ASSERT_TRUE(info != NULL); | 847 ASSERT_TRUE(texture != NULL); |
830 manager.SetInfoTarget(info, GL_TEXTURE_2D); | 848 manager.SetTarget(texture, GL_TEXTURE_2D); |
831 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target()); | 849 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); |
832 manager.SetLevelInfo(info, | 850 manager.SetLevelInfo(texture, |
833 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true); | 851 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true); |
834 EXPECT_FALSE(info->texture_complete()); | 852 EXPECT_FALSE(texture->texture_complete()); |
835 manager.SetParameter(info, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | 853 TestHelper::SetTexParameterWithExpectations( |
836 EXPECT_FALSE(info->texture_complete()); | 854 gl_.get(), decoder_.get(), &manager, |
837 manager.SetParameter(info, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); | 855 texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); |
838 EXPECT_TRUE(info->texture_complete()); | 856 EXPECT_FALSE(texture->texture_complete()); |
| 857 TestHelper::SetTexParameterWithExpectations( |
| 858 gl_.get(), decoder_.get(), &manager, |
| 859 texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR); |
| 860 EXPECT_TRUE(texture->texture_complete()); |
839 manager.Destroy(false); | 861 manager.Destroy(false); |
840 } | 862 } |
841 | 863 |
842 TEST_F(TextureInfoTest, HalfFloatLinear) { | 864 TEST_F(TextureTest, HalfFloatLinear) { |
843 TestHelper::SetupFeatureInfoInitExpectations( | 865 TestHelper::SetupFeatureInfoInitExpectations( |
844 gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear"); | 866 gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear"); |
845 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 867 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
846 feature_info->Initialize(NULL); | 868 feature_info->Initialize(NULL); |
847 TextureManager manager( | 869 TextureManager manager( |
848 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 870 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
849 manager.CreateTexture(kClient1Id, kService1Id); | 871 manager.CreateTexture(kClient1Id, kService1Id); |
850 Texture* info = manager.GetTexture(kClient1Id); | 872 Texture* texture = manager.GetTexture(kClient1Id); |
851 ASSERT_TRUE(info != NULL); | 873 ASSERT_TRUE(texture != NULL); |
852 manager.SetInfoTarget(info, GL_TEXTURE_2D); | 874 manager.SetTarget(texture, GL_TEXTURE_2D); |
853 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target()); | 875 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); |
854 manager.SetLevelInfo(info, | 876 manager.SetLevelInfo(texture, |
855 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true); | 877 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true); |
856 EXPECT_TRUE(info->texture_complete()); | 878 EXPECT_TRUE(texture->texture_complete()); |
857 manager.Destroy(false); | 879 manager.Destroy(false); |
858 } | 880 } |
859 | 881 |
860 TEST_F(TextureInfoTest, EGLImageExternal) { | 882 TEST_F(TextureTest, EGLImageExternal) { |
861 TestHelper::SetupFeatureInfoInitExpectations( | 883 TestHelper::SetupFeatureInfoInitExpectations( |
862 gl_.get(), "GL_OES_EGL_image_external"); | 884 gl_.get(), "GL_OES_EGL_image_external"); |
863 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 885 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
864 feature_info->Initialize(NULL); | 886 feature_info->Initialize(NULL); |
865 TextureManager manager( | 887 TextureManager manager( |
866 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 888 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
867 manager.CreateTexture(kClient1Id, kService1Id); | 889 manager.CreateTexture(kClient1Id, kService1Id); |
868 Texture* info = manager.GetTexture(kClient1Id); | 890 Texture* texture = manager.GetTexture(kClient1Id); |
869 ASSERT_TRUE(info != NULL); | 891 ASSERT_TRUE(texture != NULL); |
870 manager.SetInfoTarget(info, GL_TEXTURE_EXTERNAL_OES); | 892 manager.SetTarget(texture, GL_TEXTURE_EXTERNAL_OES); |
871 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), info->target()); | 893 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target()); |
872 EXPECT_FALSE(manager.CanGenerateMipmaps(info)); | 894 EXPECT_FALSE(manager.CanGenerateMipmaps(texture)); |
873 manager.Destroy(false); | 895 manager.Destroy(false); |
874 } | 896 } |
875 | 897 |
876 TEST_F(TextureInfoTest, DepthTexture) { | 898 TEST_F(TextureTest, DepthTexture) { |
877 TestHelper::SetupFeatureInfoInitExpectations( | 899 TestHelper::SetupFeatureInfoInitExpectations( |
878 gl_.get(), "GL_ANGLE_depth_texture"); | 900 gl_.get(), "GL_ANGLE_depth_texture"); |
879 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); | 901 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); |
880 feature_info->Initialize(NULL); | 902 feature_info->Initialize(NULL); |
881 TextureManager manager( | 903 TextureManager manager( |
882 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); | 904 NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize); |
883 manager.CreateTexture(kClient1Id, kService1Id); | 905 manager.CreateTexture(kClient1Id, kService1Id); |
884 Texture* info = manager.GetTexture(kClient1Id); | 906 Texture* texture = manager.GetTexture(kClient1Id); |
885 ASSERT_TRUE(info != NULL); | 907 ASSERT_TRUE(texture != NULL); |
886 manager.SetInfoTarget(info, GL_TEXTURE_2D); | 908 manager.SetTarget(texture, GL_TEXTURE_2D); |
887 manager.SetLevelInfo( | 909 manager.SetLevelInfo( |
888 info, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0, | 910 texture, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0, |
889 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false); | 911 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false); |
890 EXPECT_FALSE(manager.CanGenerateMipmaps(info)); | 912 EXPECT_FALSE(manager.CanGenerateMipmaps(texture)); |
891 manager.Destroy(false); | 913 manager.Destroy(false); |
892 } | 914 } |
893 | 915 |
894 TEST_F(TextureInfoTest, SafeUnsafe) { | 916 TEST_F(TextureTest, SafeUnsafe) { |
895 static const GLuint kClient2Id = 2; | 917 static const GLuint kClient2Id = 2; |
896 static const GLuint kService2Id = 12; | 918 static const GLuint kService2Id = 12; |
897 static const GLuint kClient3Id = 3; | 919 static const GLuint kClient3Id = 3; |
898 static const GLuint kService3Id = 13; | 920 static const GLuint kService3Id = 13; |
899 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 921 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
900 EXPECT_EQ(0, info_->num_uncleared_mips()); | 922 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
901 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 923 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
902 manager_->SetLevelInfo(info_, | 924 manager_->SetLevelInfo(texture_, |
903 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 925 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
904 EXPECT_FALSE(info_->SafeToRenderFrom()); | 926 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
905 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 927 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
906 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 928 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
907 EXPECT_EQ(1, info_->num_uncleared_mips()); | 929 EXPECT_EQ(1, texture_->num_uncleared_mips()); |
908 manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 0, true); | 930 manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true); |
909 EXPECT_TRUE(info_->SafeToRenderFrom()); | 931 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
910 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 932 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
911 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 933 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
912 EXPECT_EQ(0, info_->num_uncleared_mips()); | 934 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
913 manager_->SetLevelInfo(info_, | 935 manager_->SetLevelInfo(texture_, |
914 GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 936 GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
915 EXPECT_FALSE(info_->SafeToRenderFrom()); | 937 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
916 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 938 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
917 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 939 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
918 EXPECT_EQ(1, info_->num_uncleared_mips()); | 940 EXPECT_EQ(1, texture_->num_uncleared_mips()); |
919 manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 1, true); | 941 manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true); |
920 EXPECT_TRUE(info_->SafeToRenderFrom()); | 942 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
921 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 943 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
922 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 944 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
923 EXPECT_EQ(0, info_->num_uncleared_mips()); | 945 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
924 manager_->SetLevelInfo(info_, | 946 manager_->SetLevelInfo(texture_, |
925 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 947 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
926 manager_->SetLevelInfo(info_, | 948 manager_->SetLevelInfo(texture_, |
927 GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 949 GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
928 EXPECT_FALSE(info_->SafeToRenderFrom()); | 950 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
929 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 951 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
930 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 952 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
931 EXPECT_EQ(2, info_->num_uncleared_mips()); | 953 EXPECT_EQ(2, texture_->num_uncleared_mips()); |
932 manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 0, true); | 954 manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true); |
933 EXPECT_FALSE(info_->SafeToRenderFrom()); | 955 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
934 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 956 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
935 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 957 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
936 EXPECT_EQ(1, info_->num_uncleared_mips()); | 958 EXPECT_EQ(1, texture_->num_uncleared_mips()); |
937 manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 1, true); | 959 manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true); |
938 EXPECT_TRUE(info_->SafeToRenderFrom()); | 960 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
939 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 961 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
940 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 962 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
941 EXPECT_EQ(0, info_->num_uncleared_mips()); | 963 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
942 manager_->SetLevelInfo(info_, | 964 manager_->SetLevelInfo(texture_, |
943 GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 965 GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
944 EXPECT_FALSE(info_->SafeToRenderFrom()); | 966 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
945 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 967 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
946 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 968 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
947 EXPECT_EQ(1, info_->num_uncleared_mips()); | 969 EXPECT_EQ(1, texture_->num_uncleared_mips()); |
948 manager_->MarkMipmapsGenerated(info_); | 970 manager_->MarkMipmapsGenerated(texture_); |
949 EXPECT_TRUE(info_->SafeToRenderFrom()); | 971 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
950 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 972 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
951 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 973 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
952 EXPECT_EQ(0, info_->num_uncleared_mips()); | 974 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
953 | 975 |
954 manager_->CreateTexture(kClient2Id, kService2Id); | 976 manager_->CreateTexture(kClient2Id, kService2Id); |
955 scoped_refptr<Texture> info2( | 977 scoped_refptr<Texture> texture2( |
956 manager_->GetTexture(kClient2Id)); | 978 manager_->GetTexture(kClient2Id)); |
957 ASSERT_TRUE(info2.get() != NULL); | 979 ASSERT_TRUE(texture2.get() != NULL); |
958 manager_->SetInfoTarget(info2, GL_TEXTURE_2D); | 980 manager_->SetTarget(texture2, GL_TEXTURE_2D); |
959 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 981 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
960 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 982 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
961 EXPECT_EQ(0, info2->num_uncleared_mips()); | 983 EXPECT_EQ(0, texture2->num_uncleared_mips()); |
962 manager_->SetLevelInfo(info2, | 984 manager_->SetLevelInfo(texture2, |
963 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 985 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
964 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 986 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
965 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 987 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
966 EXPECT_EQ(0, info2->num_uncleared_mips()); | 988 EXPECT_EQ(0, texture2->num_uncleared_mips()); |
967 manager_->SetLevelInfo(info2, | 989 manager_->SetLevelInfo(texture2, |
968 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 990 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
969 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 991 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
970 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 992 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
971 EXPECT_EQ(1, info2->num_uncleared_mips()); | 993 EXPECT_EQ(1, texture2->num_uncleared_mips()); |
972 | 994 |
973 manager_->CreateTexture(kClient3Id, kService3Id); | 995 manager_->CreateTexture(kClient3Id, kService3Id); |
974 scoped_refptr<Texture> info3( | 996 scoped_refptr<Texture> texture3( |
975 manager_->GetTexture(kClient3Id)); | 997 manager_->GetTexture(kClient3Id)); |
976 ASSERT_TRUE(info3.get() != NULL); | 998 ASSERT_TRUE(texture3.get() != NULL); |
977 manager_->SetInfoTarget(info3, GL_TEXTURE_2D); | 999 manager_->SetTarget(texture3, GL_TEXTURE_2D); |
978 manager_->SetLevelInfo(info3, | 1000 manager_->SetLevelInfo(texture3, |
979 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1001 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
980 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1002 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
981 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1003 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
982 EXPECT_EQ(1, info3->num_uncleared_mips()); | 1004 EXPECT_EQ(1, texture3->num_uncleared_mips()); |
983 manager_->SetLevelCleared(info2, GL_TEXTURE_2D, 0, true); | 1005 manager_->SetLevelCleared(texture2, GL_TEXTURE_2D, 0, true); |
984 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1006 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
985 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1007 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
986 EXPECT_EQ(0, info2->num_uncleared_mips()); | 1008 EXPECT_EQ(0, texture2->num_uncleared_mips()); |
987 manager_->SetLevelCleared(info3, GL_TEXTURE_2D, 0, true); | 1009 manager_->SetLevelCleared(texture3, GL_TEXTURE_2D, 0, true); |
988 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 1010 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
989 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 1011 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
990 EXPECT_EQ(0, info3->num_uncleared_mips()); | 1012 EXPECT_EQ(0, texture3->num_uncleared_mips()); |
991 | 1013 |
992 manager_->SetLevelInfo(info2, | 1014 manager_->SetLevelInfo(texture2, |
993 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1015 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
994 manager_->SetLevelInfo(info3, | 1016 manager_->SetLevelInfo(texture3, |
995 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1017 GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
996 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1018 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
997 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1019 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
998 EXPECT_EQ(1, info2->num_uncleared_mips()); | 1020 EXPECT_EQ(1, texture2->num_uncleared_mips()); |
999 EXPECT_EQ(1, info3->num_uncleared_mips()); | 1021 EXPECT_EQ(1, texture3->num_uncleared_mips()); |
1000 manager_->RemoveTexture(kClient3Id); | 1022 manager_->RemoveTexture(kClient3Id); |
1001 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1023 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
1002 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1024 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
1003 manager_->RemoveTexture(kClient2Id); | 1025 manager_->RemoveTexture(kClient2Id); |
1004 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1026 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
1005 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1027 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
1006 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id))) | 1028 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id))) |
1007 .Times(1) | 1029 .Times(1) |
1008 .RetiresOnSaturation(); | 1030 .RetiresOnSaturation(); |
1009 info2 = NULL; | 1031 texture2 = NULL; |
1010 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1032 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
1011 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1033 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
1012 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id))) | 1034 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id))) |
1013 .Times(1) | 1035 .Times(1) |
1014 .RetiresOnSaturation(); | 1036 .RetiresOnSaturation(); |
1015 info3 = NULL; | 1037 texture3 = NULL; |
1016 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 1038 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
1017 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 1039 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
1018 } | 1040 } |
1019 | 1041 |
1020 TEST_F(TextureInfoTest, ClearTexture) { | 1042 TEST_F(TextureTest, ClearTexture) { |
1021 scoped_ptr<MockGLES2Decoder> decoder(new gles2::MockGLES2Decoder()); | 1043 EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _)) |
1022 EXPECT_CALL(*decoder, ClearLevel(_, _, _, _, _, _, _, _, _)) | |
1023 .WillRepeatedly(Return(true)); | 1044 .WillRepeatedly(Return(true)); |
1024 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 1045 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
1025 manager_->SetLevelInfo(info_, | 1046 manager_->SetLevelInfo(texture_, |
1026 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1047 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1027 manager_->SetLevelInfo(info_, | 1048 manager_->SetLevelInfo(texture_, |
1028 GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1049 GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1029 EXPECT_FALSE(info_->SafeToRenderFrom()); | 1050 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
1030 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1051 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
1031 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1052 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
1032 EXPECT_EQ(2, info_->num_uncleared_mips()); | 1053 EXPECT_EQ(2, texture_->num_uncleared_mips()); |
1033 manager_->ClearRenderableLevels(decoder.get(), info_); | 1054 manager_->ClearRenderableLevels(decoder_.get(), texture_); |
1034 EXPECT_TRUE(info_->SafeToRenderFrom()); | 1055 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
1035 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 1056 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
1036 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 1057 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
1037 EXPECT_EQ(0, info_->num_uncleared_mips()); | 1058 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
1038 manager_->SetLevelInfo(info_, | 1059 manager_->SetLevelInfo(texture_, |
1039 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1060 GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1040 manager_->SetLevelInfo(info_, | 1061 manager_->SetLevelInfo(texture_, |
1041 GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1062 GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1042 EXPECT_FALSE(info_->SafeToRenderFrom()); | 1063 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
1043 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1064 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
1044 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1065 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
1045 EXPECT_EQ(2, info_->num_uncleared_mips()); | 1066 EXPECT_EQ(2, texture_->num_uncleared_mips()); |
1046 manager_->ClearTextureLevel(decoder.get(), info_, GL_TEXTURE_2D, 0); | 1067 manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 0); |
1047 EXPECT_FALSE(info_->SafeToRenderFrom()); | 1068 EXPECT_FALSE(texture_->SafeToRenderFrom()); |
1048 EXPECT_TRUE(manager_->HaveUnsafeTextures()); | 1069 EXPECT_TRUE(manager_->HaveUnsafeTextures()); |
1049 EXPECT_TRUE(manager_->HaveUnclearedMips()); | 1070 EXPECT_TRUE(manager_->HaveUnclearedMips()); |
1050 EXPECT_EQ(1, info_->num_uncleared_mips()); | 1071 EXPECT_EQ(1, texture_->num_uncleared_mips()); |
1051 manager_->ClearTextureLevel(decoder.get(), info_, GL_TEXTURE_2D, 1); | 1072 manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 1); |
1052 EXPECT_TRUE(info_->SafeToRenderFrom()); | 1073 EXPECT_TRUE(texture_->SafeToRenderFrom()); |
1053 EXPECT_FALSE(manager_->HaveUnsafeTextures()); | 1074 EXPECT_FALSE(manager_->HaveUnsafeTextures()); |
1054 EXPECT_FALSE(manager_->HaveUnclearedMips()); | 1075 EXPECT_FALSE(manager_->HaveUnclearedMips()); |
1055 EXPECT_EQ(0, info_->num_uncleared_mips()); | 1076 EXPECT_EQ(0, texture_->num_uncleared_mips()); |
1056 } | 1077 } |
1057 | 1078 |
1058 TEST_F(TextureInfoTest, UseDeletedTexture) { | 1079 TEST_F(TextureTest, UseDeletedTexture) { |
1059 static const GLuint kClient2Id = 2; | 1080 static const GLuint kClient2Id = 2; |
1060 static const GLuint kService2Id = 12; | 1081 static const GLuint kService2Id = 12; |
1061 // Make the default texture renderable | 1082 // Make the default texture renderable |
1062 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 1083 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
1063 manager_->SetLevelInfo(info_, | 1084 manager_->SetLevelInfo(texture_, |
1064 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1085 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1065 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 1086 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
1066 // Make a new texture | 1087 // Make a new texture |
1067 manager_->CreateTexture(kClient2Id, kService2Id); | 1088 manager_->CreateTexture(kClient2Id, kService2Id); |
1068 scoped_refptr<Texture> info( | 1089 scoped_refptr<Texture> texture( |
1069 manager_->GetTexture(kClient2Id)); | 1090 manager_->GetTexture(kClient2Id)); |
1070 manager_->SetInfoTarget(info, GL_TEXTURE_2D); | 1091 manager_->SetTarget(texture, GL_TEXTURE_2D); |
1071 EXPECT_FALSE(manager_->CanRender(info)); | 1092 EXPECT_FALSE(manager_->CanRender(texture)); |
1072 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 1093 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
1073 // Remove it. | 1094 // Remove it. |
1074 manager_->RemoveTexture(kClient2Id); | 1095 manager_->RemoveTexture(kClient2Id); |
1075 EXPECT_FALSE(manager_->CanRender(info)); | 1096 EXPECT_FALSE(manager_->CanRender(texture)); |
1076 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); | 1097 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); |
1077 // Check that we can still manipulate it and it effects the manager. | 1098 // Check that we can still manipulate it and it effects the manager. |
1078 manager_->SetLevelInfo(info, | 1099 manager_->SetLevelInfo(texture, |
1079 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1100 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1080 EXPECT_TRUE(manager_->CanRender(info)); | 1101 EXPECT_TRUE(manager_->CanRender(texture)); |
1081 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); | 1102 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); |
1082 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id))) | 1103 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id))) |
1083 .Times(1) | 1104 .Times(1) |
1084 .RetiresOnSaturation(); | 1105 .RetiresOnSaturation(); |
1085 info = NULL; | 1106 texture = NULL; |
1086 } | 1107 } |
1087 | 1108 |
1088 TEST_F(TextureInfoTest, GetLevelImage) { | 1109 TEST_F(TextureTest, GetLevelImage) { |
1089 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 1110 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
1090 manager_->SetLevelInfo(info_, | 1111 manager_->SetLevelInfo(texture_, |
1091 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 1112 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
1092 EXPECT_TRUE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); | 1113 EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); |
1093 // Set image. | 1114 // Set image. |
1094 manager_->SetLevelImage(info_, | 1115 manager_->SetLevelImage(texture_, |
1095 GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0)); | 1116 GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0)); |
1096 EXPECT_FALSE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); | 1117 EXPECT_FALSE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); |
1097 // Remove it. | 1118 // Remove it. |
1098 manager_->SetLevelImage(info_, GL_TEXTURE_2D, 1, NULL); | 1119 manager_->SetLevelImage(texture_, GL_TEXTURE_2D, 1, NULL); |
1099 EXPECT_TRUE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); | 1120 EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); |
1100 manager_->SetLevelImage(info_, | 1121 manager_->SetLevelImage(texture_, |
1101 GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0)); | 1122 GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0)); |
1102 // Image should be reset when SetLevelInfo is called. | 1123 // Image should be reset when SetLevelInfo is called. |
1103 manager_->SetLevelInfo(info_, | 1124 manager_->SetLevelInfo(texture_, |
1104 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 1125 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
1105 EXPECT_TRUE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); | 1126 EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); |
1106 } | 1127 } |
1107 | 1128 |
1108 namespace { | 1129 namespace { |
1109 | 1130 |
1110 bool InSet(std::set<std::string>* string_set, const std::string& str) { | 1131 bool InSet(std::set<std::string>* string_set, const std::string& str) { |
1111 std::pair<std::set<std::string>::iterator, bool> result = | 1132 std::pair<std::set<std::string>::iterator, bool> result = |
1112 string_set->insert(str); | 1133 string_set->insert(str); |
1113 return !result.second; | 1134 return !result.second; |
1114 } | 1135 } |
1115 | 1136 |
1116 } // anonymous namespace | 1137 } // anonymous namespace |
1117 | 1138 |
1118 TEST_F(TextureInfoTest, AddToSignature) { | 1139 TEST_F(TextureTest, AddToSignature) { |
1119 manager_->SetInfoTarget(info_, GL_TEXTURE_2D); | 1140 manager_->SetTarget(texture_, GL_TEXTURE_2D); |
1120 manager_->SetLevelInfo(info_, | 1141 manager_->SetLevelInfo(texture_, |
1121 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 1142 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
1122 std::string signature1; | 1143 std::string signature1; |
1123 std::string signature2; | 1144 std::string signature2; |
1124 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature1); | 1145 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature1); |
1125 | 1146 |
1126 std::set<std::string> string_set; | 1147 std::set<std::string> string_set; |
1127 EXPECT_FALSE(InSet(&string_set, signature1)); | 1148 EXPECT_FALSE(InSet(&string_set, signature1)); |
1128 | 1149 |
1129 // check changing 1 thing makes a different signature. | 1150 // check changing 1 thing makes a different signature. |
1130 manager_->SetLevelInfo(info_, | 1151 manager_->SetLevelInfo(texture_, |
1131 GL_TEXTURE_2D, 1, GL_RGBA, 4, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 1152 GL_TEXTURE_2D, 1, GL_RGBA, 4, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
1132 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1153 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1133 EXPECT_FALSE(InSet(&string_set, signature2)); | 1154 EXPECT_FALSE(InSet(&string_set, signature2)); |
1134 | 1155 |
1135 // check putting it back makes the same signature. | 1156 // check putting it back makes the same signature. |
1136 manager_->SetLevelInfo(info_, | 1157 manager_->SetLevelInfo(texture_, |
1137 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); | 1158 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); |
1138 signature2.clear(); | 1159 signature2.clear(); |
1139 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1160 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1140 EXPECT_EQ(signature1, signature2); | 1161 EXPECT_EQ(signature1, signature2); |
1141 | 1162 |
1142 // Check setting cleared status does not change signature. | 1163 // Check setting cleared status does not change signature. |
1143 manager_->SetLevelInfo(info_, | 1164 manager_->SetLevelInfo(texture_, |
1144 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1165 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1145 signature2.clear(); | 1166 signature2.clear(); |
1146 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1167 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1147 EXPECT_EQ(signature1, signature2); | 1168 EXPECT_EQ(signature1, signature2); |
1148 | 1169 |
1149 // Check changing other settings changes signature. | 1170 // Check changing other settings changes signature. |
1150 manager_->SetLevelInfo(info_, | 1171 manager_->SetLevelInfo(texture_, |
1151 GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1172 GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1152 signature2.clear(); | 1173 signature2.clear(); |
1153 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1174 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1154 EXPECT_FALSE(InSet(&string_set, signature2)); | 1175 EXPECT_FALSE(InSet(&string_set, signature2)); |
1155 | 1176 |
1156 manager_->SetLevelInfo(info_, | 1177 manager_->SetLevelInfo(texture_, |
1157 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1178 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1158 signature2.clear(); | 1179 signature2.clear(); |
1159 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1180 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1160 EXPECT_FALSE(InSet(&string_set, signature2)); | 1181 EXPECT_FALSE(InSet(&string_set, signature2)); |
1161 | 1182 |
1162 manager_->SetLevelInfo(info_, | 1183 manager_->SetLevelInfo(texture_, |
1163 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, false); | 1184 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, false); |
1164 signature2.clear(); | 1185 signature2.clear(); |
1165 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1186 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1166 EXPECT_FALSE(InSet(&string_set, signature2)); | 1187 EXPECT_FALSE(InSet(&string_set, signature2)); |
1167 | 1188 |
1168 manager_->SetLevelInfo(info_, | 1189 manager_->SetLevelInfo(texture_, |
1169 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, false); | 1190 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, false); |
1170 signature2.clear(); | 1191 signature2.clear(); |
1171 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1192 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1172 EXPECT_FALSE(InSet(&string_set, signature2)); | 1193 EXPECT_FALSE(InSet(&string_set, signature2)); |
1173 | 1194 |
1174 manager_->SetLevelInfo(info_, | 1195 manager_->SetLevelInfo(texture_, |
1175 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_FLOAT, | 1196 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_FLOAT, |
1176 false); | 1197 false); |
1177 signature2.clear(); | 1198 signature2.clear(); |
1178 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1199 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1179 EXPECT_FALSE(InSet(&string_set, signature2)); | 1200 EXPECT_FALSE(InSet(&string_set, signature2)); |
1180 | 1201 |
1181 // put it back | 1202 // put it back |
1182 manager_->SetLevelInfo(info_, | 1203 manager_->SetLevelInfo(texture_, |
1183 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, | 1204 GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, |
1184 false); | 1205 false); |
1185 signature2.clear(); | 1206 signature2.clear(); |
1186 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1207 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1187 EXPECT_EQ(signature1, signature2); | 1208 EXPECT_EQ(signature1, signature2); |
1188 | 1209 |
1189 // check changing parameters changes signature. | 1210 // check changing parameters changes signature. |
1190 manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_NEAREST); | 1211 SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR); |
1191 signature2.clear(); | 1212 signature2.clear(); |
1192 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1213 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1193 EXPECT_FALSE(InSet(&string_set, signature2)); | 1214 EXPECT_FALSE(InSet(&string_set, signature2)); |
1194 | 1215 |
1195 manager_->SetParameter( | 1216 SetParameter( |
1196 info_, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); | 1217 texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR, GL_NO_ERROR); |
1197 manager_->SetParameter(info_, GL_TEXTURE_MAG_FILTER, GL_NEAREST); | 1218 SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); |
1198 signature2.clear(); | 1219 signature2.clear(); |
1199 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1220 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1200 EXPECT_FALSE(InSet(&string_set, signature2)); | 1221 EXPECT_FALSE(InSet(&string_set, signature2)); |
1201 | 1222 |
1202 manager_->SetParameter(info_, GL_TEXTURE_MAG_FILTER, GL_LINEAR); | 1223 SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR); |
1203 manager_->SetParameter(info_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); | 1224 SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR); |
1204 signature2.clear(); | 1225 signature2.clear(); |
1205 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1226 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1206 EXPECT_FALSE(InSet(&string_set, signature2)); | 1227 EXPECT_FALSE(InSet(&string_set, signature2)); |
1207 | 1228 |
1208 manager_->SetParameter(info_, GL_TEXTURE_WRAP_S, GL_REPEAT); | 1229 SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR); |
1209 manager_->SetParameter(info_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); | 1230 SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR); |
1210 signature2.clear(); | 1231 signature2.clear(); |
1211 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1232 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1212 EXPECT_FALSE(InSet(&string_set, signature2)); | 1233 EXPECT_FALSE(InSet(&string_set, signature2)); |
1213 | 1234 |
1214 // Check putting it back genenerates the same signature | 1235 // Check putting it back genenerates the same signature |
1215 manager_->SetParameter(info_, GL_TEXTURE_WRAP_T, GL_REPEAT); | 1236 SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR); |
1216 signature2.clear(); | 1237 signature2.clear(); |
1217 manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2); | 1238 manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2); |
1218 EXPECT_EQ(signature1, signature2); | 1239 EXPECT_EQ(signature1, signature2); |
1219 | 1240 |
1220 // Check the set was acutally getting different signatures. | 1241 // Check the set was acutally getting different signatures. |
1221 EXPECT_EQ(11u, string_set.size()); | 1242 EXPECT_EQ(11u, string_set.size()); |
1222 } | 1243 } |
1223 | 1244 |
1224 | |
1225 } // namespace gles2 | 1245 } // namespace gles2 |
1226 } // namespace gpu | 1246 } // namespace gpu |
1227 | 1247 |
1228 | 1248 |
OLD | NEW |