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 3 // found in the LICENSE file. 4 5 #include "gpu/command_buffer/service/texture_manager.h" 6 7 #include "base/memory/scoped_ptr.h" 8 #include "gpu/command_buffer/service/error_state_mock.h" 9 #include "gpu/command_buffer/service/feature_info.h" 10 #include "gpu/command_buffer/service/framebuffer_manager.h" 11 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" 12 #include "gpu/command_buffer/service/gpu_service_test.h" 13 #include "gpu/command_buffer/service/mailbox_manager.h" 14 #include "gpu/command_buffer/service/memory_tracking.h" 15 #include "gpu/command_buffer/service/mocks.h" 16 #include "gpu/command_buffer/service/test_helper.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 #include "ui/gl/gl_mock.h" 19 20 using ::testing::AtLeast; 21 using ::testing::Pointee; 22 using ::testing::Return; 23 using ::testing::SetArgumentPointee; 24 using ::testing::StrictMock; 25 using ::testing::_; 26 27 namespace gpu { 28 namespace gles2 { 29 30 class TextureTestHelper { 31 public: 32 static bool IsNPOT(const Texture* texture) { 33 return texture->npot(); 34 } 35 static bool IsTextureComplete(const Texture* texture) { 36 return texture->texture_complete(); 37 } 38 static bool IsCubeComplete(const Texture* texture) { 39 return texture->cube_complete(); 40 } 41 }; 42 43 class TextureManagerTest : public GpuServiceTest { 44 public: 45 static const GLint kMaxTextureSize = 16; 46 static const GLint kMaxCubeMapTextureSize = 8; 47 static const GLint kMaxExternalTextureSize = 16; 48 static const GLint kMax2dLevels = 5; 49 static const GLint kMaxCubeMapLevels = 4; 50 static const GLint kMaxExternalLevels = 1; 51 static const bool kUseDefaultTextures = false; 52 53 TextureManagerTest() : feature_info_(new FeatureInfo()) {} 54 55 virtual ~TextureManagerTest() { 56 } 57 58 protected: 59 virtual void SetUp() { 60 GpuServiceTest::SetUp(); 61 manager_.reset(new TextureManager(NULL, 62 feature_info_.get(), 63 kMaxTextureSize, 64 kMaxCubeMapTextureSize, 65 kUseDefaultTextures)); 66 TestHelper::SetupTextureManagerInitExpectations( 67 gl_.get(), "", kUseDefaultTextures); 68 manager_->Initialize(); 69 error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>()); 70 } 71 72 virtual void TearDown() { 73 manager_->Destroy(false); 74 manager_.reset(); 75 GpuServiceTest::TearDown(); 76 } 77 78 void SetParameter( 79 TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) { 80 TestHelper::SetTexParameteriWithExpectations( 81 gl_.get(), error_state_.get(), manager_.get(), 82 texture_ref, pname, value, error); 83 } 84 85 scoped_refptr<FeatureInfo> feature_info_; 86 scoped_ptr<TextureManager> manager_; 87 scoped_ptr<MockErrorState> error_state_; 88 }; 89 90 // GCC requires these declarations, but MSVC requires they not be present 91 #ifndef COMPILER_MSVC 92 const GLint TextureManagerTest::kMaxTextureSize; 93 const GLint TextureManagerTest::kMaxCubeMapTextureSize; 94 const GLint TextureManagerTest::kMaxExternalTextureSize; 95 const GLint TextureManagerTest::kMax2dLevels; 96 const GLint TextureManagerTest::kMaxCubeMapLevels; 97 const GLint TextureManagerTest::kMaxExternalLevels; 98 #endif 99 100 TEST_F(TextureManagerTest, Basic) { 101 const GLuint kClient1Id = 1; 102 const GLuint kService1Id = 11; 103 const GLuint kClient2Id = 2; 104 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 105 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 106 EXPECT_FALSE(manager_->HaveUnclearedMips()); 107 // Check we can create texture. 108 manager_->CreateTexture(kClient1Id, kService1Id); 109 // Check texture got created. 110 scoped_refptr<TextureRef> texture = manager_->GetTexture(kClient1Id); 111 ASSERT_TRUE(texture.get() != NULL); 112 EXPECT_EQ(kService1Id, texture->service_id()); 113 EXPECT_EQ(kClient1Id, texture->client_id()); 114 EXPECT_EQ(texture->texture(), manager_->GetTextureForServiceId( 115 texture->service_id())); 116 // Check we get nothing for a non-existent texture. 117 EXPECT_TRUE(manager_->GetTexture(kClient2Id) == NULL); 118 // Check trying to a remove non-existent textures does not crash. 119 manager_->RemoveTexture(kClient2Id); 120 // Check that it gets deleted when the last reference is released. 121 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id))) 122 .Times(1) 123 .RetiresOnSaturation(); 124 // Check we can't get the texture after we remove it. 125 manager_->RemoveTexture(kClient1Id); 126 EXPECT_TRUE(manager_->GetTexture(kClient1Id) == NULL); 127 EXPECT_EQ(0u, texture->client_id()); 128 } 129 130 TEST_F(TextureManagerTest, SetParameter) { 131 const GLuint kClient1Id = 1; 132 const GLuint kService1Id = 11; 133 // Check we can create texture. 134 manager_->CreateTexture(kClient1Id, kService1Id); 135 // Check texture got created. 136 TextureRef* texture_ref = manager_->GetTexture(kClient1Id); 137 ASSERT_TRUE(texture_ref != NULL); 138 Texture* texture = texture_ref->texture(); 139 manager_->SetTarget(texture_ref, GL_TEXTURE_2D); 140 SetParameter(texture_ref, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR); 141 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter()); 142 SetParameter(texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); 143 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->mag_filter()); 144 SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR); 145 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s()); 146 SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR); 147 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t()); 148 SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR); 149 SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR); 150 SetParameter( 151 texture_ref, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM); 152 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter()); 153 SetParameter( 154 texture_ref, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM); 155 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter()); 156 SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM); 157 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s()); 158 SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM); 159 EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t()); 160 SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE); 161 } 162 163 TEST_F(TextureManagerTest, UseDefaultTexturesTrue) { 164 bool use_default_textures = true; 165 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 166 167 TestHelper::SetupTextureManagerInitExpectations( 168 gl_.get(), "GL_ANGLE_texture_usage", use_default_textures); 169 TextureManager manager(NULL, 170 feature_info_.get(), 171 kMaxTextureSize, 172 kMaxCubeMapTextureSize, 173 use_default_textures); 174 manager.Initialize(); 175 176 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) != NULL); 177 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) != NULL); 178 179 // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB. 180 181 manager.Destroy(false); 182 } 183 184 TEST_F(TextureManagerTest, UseDefaultTexturesFalse) { 185 bool use_default_textures = false; 186 TestHelper::SetupTextureManagerInitExpectations( 187 gl_.get(), "GL_ANGLE_texture_usage", use_default_textures); 188 TextureManager manager(NULL, 189 feature_info_.get(), 190 kMaxTextureSize, 191 kMaxCubeMapTextureSize, 192 use_default_textures); 193 manager.Initialize(); 194 195 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) == NULL); 196 EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) == NULL); 197 198 // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB. 199 200 manager.Destroy(false); 201 } 202 203 TEST_F(TextureManagerTest, TextureUsageExt) { 204 TestHelper::SetupTextureManagerInitExpectations( 205 gl_.get(), "GL_ANGLE_texture_usage", kUseDefaultTextures); 206 TextureManager manager(NULL, 207 feature_info_.get(), 208 kMaxTextureSize, 209 kMaxCubeMapTextureSize, 210 kUseDefaultTextures); 211 manager.Initialize(); 212 const GLuint kClient1Id = 1; 213 const GLuint kService1Id = 11; 214 // Check we can create texture. 215 manager.CreateTexture(kClient1Id, kService1Id); 216 // Check texture got created. 217 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 218 ASSERT_TRUE(texture_ref != NULL); 219 TestHelper::SetTexParameteriWithExpectations( 220 gl_.get(), error_state_.get(), &manager, texture_ref, 221 GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE,GL_NO_ERROR); 222 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE), 223 texture_ref->texture()->usage()); 224 manager.Destroy(false); 225 } 226 227 TEST_F(TextureManagerTest, Destroy) { 228 const GLuint kClient1Id = 1; 229 const GLuint kService1Id = 11; 230 TestHelper::SetupTextureManagerInitExpectations( 231 gl_.get(), "", kUseDefaultTextures); 232 TextureManager manager(NULL, 233 feature_info_.get(), 234 kMaxTextureSize, 235 kMaxCubeMapTextureSize, 236 kUseDefaultTextures); 237 manager.Initialize(); 238 // Check we can create texture. 239 manager.CreateTexture(kClient1Id, kService1Id); 240 // Check texture got created. 241 TextureRef* texture = manager.GetTexture(kClient1Id); 242 ASSERT_TRUE(texture != NULL); 243 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id))) 244 .Times(1) 245 .RetiresOnSaturation(); 246 TestHelper::SetupTextureManagerDestructionExpectations( 247 gl_.get(), "", kUseDefaultTextures); 248 manager.Destroy(true); 249 // Check that resources got freed. 250 texture = manager.GetTexture(kClient1Id); 251 ASSERT_TRUE(texture == NULL); 252 } 253 254 TEST_F(TextureManagerTest, MaxValues) { 255 // Check we get the right values for the max sizes. 256 EXPECT_EQ(kMax2dLevels, manager_->MaxLevelsForTarget(GL_TEXTURE_2D)); 257 EXPECT_EQ(kMaxCubeMapLevels, 258 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP)); 259 EXPECT_EQ(kMaxCubeMapLevels, 260 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X)); 261 EXPECT_EQ(kMaxCubeMapLevels, 262 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_X)); 263 EXPECT_EQ(kMaxCubeMapLevels, 264 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Y)); 265 EXPECT_EQ(kMaxCubeMapLevels, 266 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y)); 267 EXPECT_EQ(kMaxCubeMapLevels, 268 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Z)); 269 EXPECT_EQ(kMaxCubeMapLevels, 270 manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)); 271 EXPECT_EQ(kMaxExternalLevels, 272 manager_->MaxLevelsForTarget(GL_TEXTURE_EXTERNAL_OES)); 273 EXPECT_EQ(kMaxTextureSize, manager_->MaxSizeForTarget(GL_TEXTURE_2D)); 274 EXPECT_EQ(kMaxCubeMapTextureSize, 275 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP)); 276 EXPECT_EQ(kMaxCubeMapTextureSize, 277 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X)); 278 EXPECT_EQ(kMaxCubeMapTextureSize, 279 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_X)); 280 EXPECT_EQ(kMaxCubeMapTextureSize, 281 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Y)); 282 EXPECT_EQ(kMaxCubeMapTextureSize, 283 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y)); 284 EXPECT_EQ(kMaxCubeMapTextureSize, 285 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_Z)); 286 EXPECT_EQ(kMaxCubeMapTextureSize, 287 manager_->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)); 288 EXPECT_EQ(kMaxExternalTextureSize, 289 manager_->MaxSizeForTarget(GL_TEXTURE_EXTERNAL_OES)); 290 } 291 292 TEST_F(TextureManagerTest, ValidForTarget) { 293 // check 2d 294 EXPECT_TRUE(manager_->ValidForTarget( 295 GL_TEXTURE_2D, 0, kMaxTextureSize, kMaxTextureSize, 1)); 296 EXPECT_TRUE(manager_->ValidForTarget( 297 GL_TEXTURE_2D, kMax2dLevels - 1, 1, 1, 1)); 298 EXPECT_FALSE(manager_->ValidForTarget( 299 GL_TEXTURE_2D, kMax2dLevels - 1, 1, 2, 1)); 300 EXPECT_FALSE(manager_->ValidForTarget( 301 GL_TEXTURE_2D, kMax2dLevels - 1, 2, 1, 1)); 302 // check level out of range. 303 EXPECT_FALSE(manager_->ValidForTarget( 304 GL_TEXTURE_2D, kMax2dLevels, kMaxTextureSize, 1, 1)); 305 // check has depth. 306 EXPECT_FALSE(manager_->ValidForTarget( 307 GL_TEXTURE_2D, kMax2dLevels, kMaxTextureSize, 1, 2)); 308 // Check NPOT width on level 0 309 EXPECT_TRUE(manager_->ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1)); 310 // Check NPOT height on level 0 311 EXPECT_TRUE(manager_->ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1)); 312 // Check NPOT width on level 1 313 EXPECT_FALSE(manager_->ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1)); 314 // Check NPOT height on level 1 315 EXPECT_FALSE(manager_->ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1)); 316 317 // check cube 318 EXPECT_TRUE(manager_->ValidForTarget( 319 GL_TEXTURE_CUBE_MAP, 0, 320 kMaxCubeMapTextureSize, kMaxCubeMapTextureSize, 1)); 321 EXPECT_TRUE(manager_->ValidForTarget( 322 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels - 1, 1, 1, 1)); 323 EXPECT_FALSE(manager_->ValidForTarget( 324 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels - 1, 2, 2, 1)); 325 // check level out of range. 326 EXPECT_FALSE(manager_->ValidForTarget( 327 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels, 328 kMaxCubeMapTextureSize, 1, 1)); 329 // check not square. 330 EXPECT_FALSE(manager_->ValidForTarget( 331 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels, 332 kMaxCubeMapTextureSize, 1, 1)); 333 // check has depth. 334 EXPECT_FALSE(manager_->ValidForTarget( 335 GL_TEXTURE_CUBE_MAP, kMaxCubeMapLevels, 336 kMaxCubeMapTextureSize, 1, 2)); 337 338 for (GLint level = 0; level < kMax2dLevels; ++level) { 339 EXPECT_TRUE(manager_->ValidForTarget( 340 GL_TEXTURE_2D, level, kMaxTextureSize >> level, 1, 1)); 341 EXPECT_TRUE(manager_->ValidForTarget( 342 GL_TEXTURE_2D, level, 1, kMaxTextureSize >> level, 1)); 343 EXPECT_FALSE(manager_->ValidForTarget( 344 GL_TEXTURE_2D, level, (kMaxTextureSize >> level) + 1, 1, 1)); 345 EXPECT_FALSE(manager_->ValidForTarget( 346 GL_TEXTURE_2D, level, 1, (kMaxTextureSize >> level) + 1, 1)); 347 } 348 349 for (GLint level = 0; level < kMaxCubeMapLevels; ++level) { 350 EXPECT_TRUE(manager_->ValidForTarget( 351 GL_TEXTURE_CUBE_MAP, level, 352 kMaxCubeMapTextureSize >> level, 353 kMaxCubeMapTextureSize >> level, 354 1)); 355 EXPECT_FALSE(manager_->ValidForTarget( 356 GL_TEXTURE_CUBE_MAP, level, 357 (kMaxCubeMapTextureSize >> level) * 2, 358 (kMaxCubeMapTextureSize >> level) * 2, 359 1)); 360 } 361 } 362 363 TEST_F(TextureManagerTest, ValidForTargetNPOT) { 364 TestHelper::SetupFeatureInfoInitExpectations( 365 gl_.get(), "GL_OES_texture_npot"); 366 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 367 feature_info->Initialize(); 368 TextureManager manager(NULL, 369 feature_info.get(), 370 kMaxTextureSize, 371 kMaxCubeMapTextureSize, 372 kUseDefaultTextures); 373 // Check NPOT width on level 0 374 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1)); 375 // Check NPOT height on level 0 376 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1)); 377 // Check NPOT width on level 1 378 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1)); 379 // Check NPOT height on level 1 380 EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1)); 381 manager.Destroy(false); 382 } 383 384 class TextureTestBase : public GpuServiceTest { 385 public: 386 static const GLint kMaxTextureSize = 16; 387 static const GLint kMaxCubeMapTextureSize = 8; 388 static const GLint kMax2dLevels = 5; 389 static const GLint kMaxCubeMapLevels = 4; 390 static const GLuint kClient1Id = 1; 391 static const GLuint kService1Id = 11; 392 static const bool kUseDefaultTextures = false; 393 394 TextureTestBase() 395 : feature_info_(new FeatureInfo()) { 396 } 397 virtual ~TextureTestBase() { 398 texture_ref_ = NULL; 399 } 400 401 protected: 402 void SetUpBase(MemoryTracker* memory_tracker, std::string extensions) { 403 GpuServiceTest::SetUp(); 404 if (!extensions.empty()) { 405 TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), 406 extensions.c_str()); 407 feature_info_->Initialize(); 408 } 409 410 manager_.reset(new TextureManager(memory_tracker, 411 feature_info_.get(), 412 kMaxTextureSize, 413 kMaxCubeMapTextureSize, 414 kUseDefaultTextures)); 415 decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>()); 416 error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>()); 417 manager_->CreateTexture(kClient1Id, kService1Id); 418 texture_ref_ = manager_->GetTexture(kClient1Id); 419 ASSERT_TRUE(texture_ref_.get() != NULL); 420 } 421 422 virtual void TearDown() { 423 if (texture_ref_.get()) { 424 // If it's not in the manager then setting texture_ref_ to NULL will 425 // delete the texture. 426 if (!texture_ref_->client_id()) { 427 // Check that it gets deleted when the last reference is released. 428 EXPECT_CALL(*gl_, 429 DeleteTextures(1, ::testing::Pointee(texture_ref_->service_id()))) 430 .Times(1) 431 .RetiresOnSaturation(); 432 } 433 texture_ref_ = NULL; 434 } 435 manager_->Destroy(false); 436 manager_.reset(); 437 GpuServiceTest::TearDown(); 438 } 439 440 void SetParameter( 441 TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) { 442 TestHelper::SetTexParameteriWithExpectations( 443 gl_.get(), error_state_.get(), manager_.get(), 444 texture_ref, pname, value, error); 445 } 446 447 scoped_ptr<MockGLES2Decoder> decoder_; 448 scoped_ptr<MockErrorState> error_state_; 449 scoped_refptr<FeatureInfo> feature_info_; 450 scoped_ptr<TextureManager> manager_; 451 scoped_refptr<TextureRef> texture_ref_; 452 }; 453 454 class TextureTest : public TextureTestBase { 455 protected: 456 virtual void SetUp() { 457 SetUpBase(NULL, std::string()); 458 } 459 }; 460 461 class TextureMemoryTrackerTest : public TextureTestBase { 462 protected: 463 virtual void SetUp() { 464 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); 465 SetUpBase(mock_memory_tracker_.get(), std::string()); 466 } 467 468 scoped_refptr<MockMemoryTracker> mock_memory_tracker_; 469 }; 470 471 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ 472 EXPECT_CALL(*mock_memory_tracker_.get(), \ 473 TrackMemoryAllocatedChange(old_size, new_size, pool)) \ 474 .Times(1).RetiresOnSaturation() 475 476 TEST_F(TextureTest, Basic) { 477 Texture* texture = texture_ref_->texture(); 478 EXPECT_EQ(0u, texture->target()); 479 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 480 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 481 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 482 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 483 EXPECT_EQ(0, texture->num_uncleared_mips()); 484 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 485 EXPECT_TRUE(texture->SafeToRenderFrom()); 486 EXPECT_FALSE(texture->IsImmutable()); 487 EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR), 488 texture->min_filter()); 489 EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture->mag_filter()); 490 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_s()); 491 EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture->wrap_t()); 492 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 493 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 494 EXPECT_EQ(0u, texture->estimated_size()); 495 } 496 497 TEST_F(TextureTest, SetTargetTexture2D) { 498 Texture* texture = texture_ref_->texture(); 499 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 500 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 501 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 502 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 503 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 504 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 505 EXPECT_TRUE(texture->SafeToRenderFrom()); 506 EXPECT_FALSE(texture->IsImmutable()); 507 } 508 509 TEST_F(TextureTest, SetTargetTextureExternalOES) { 510 Texture* texture = texture_ref_->texture(); 511 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES); 512 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 513 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 514 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 515 EXPECT_TRUE(TextureTestHelper::IsNPOT(texture)); 516 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 517 EXPECT_TRUE(texture->SafeToRenderFrom()); 518 EXPECT_TRUE(texture->IsImmutable()); 519 } 520 521 TEST_F(TextureTest, ZeroSizeCanNotRender) { 522 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 523 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 524 manager_->SetLevelInfo(texture_ref_.get(), 525 GL_TEXTURE_2D, 526 0, 527 GL_RGBA, 528 1, 529 1, 530 1, 531 0, 532 GL_RGBA, 533 GL_UNSIGNED_BYTE, 534 true); 535 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 536 manager_->SetLevelInfo(texture_ref_.get(), 537 GL_TEXTURE_2D, 538 0, 539 GL_RGBA, 540 0, 541 0, 542 1, 543 0, 544 GL_RGBA, 545 GL_UNSIGNED_BYTE, 546 true); 547 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 548 } 549 550 TEST_F(TextureTest, EstimatedSize) { 551 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 552 manager_->SetLevelInfo(texture_ref_.get(), 553 GL_TEXTURE_2D, 554 0, 555 GL_RGBA, 556 8, 557 4, 558 1, 559 0, 560 GL_RGBA, 561 GL_UNSIGNED_BYTE, 562 true); 563 EXPECT_EQ(8u * 4u * 4u, texture_ref_->texture()->estimated_size()); 564 manager_->SetLevelInfo(texture_ref_.get(), 565 GL_TEXTURE_2D, 566 2, 567 GL_RGBA, 568 8, 569 4, 570 1, 571 0, 572 GL_RGBA, 573 GL_UNSIGNED_BYTE, 574 true); 575 EXPECT_EQ(8u * 4u * 4u * 2u, texture_ref_->texture()->estimated_size()); 576 } 577 578 TEST_F(TextureMemoryTrackerTest, EstimatedSize) { 579 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 580 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged); 581 manager_->SetLevelInfo(texture_ref_.get(), 582 GL_TEXTURE_2D, 583 0, 584 GL_RGBA, 585 8, 586 4, 587 1, 588 0, 589 GL_RGBA, 590 GL_UNSIGNED_BYTE, 591 true); 592 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged); 593 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged); 594 manager_->SetLevelInfo(texture_ref_.get(), 595 GL_TEXTURE_2D, 596 2, 597 GL_RGBA, 598 8, 599 4, 600 1, 601 0, 602 GL_RGBA, 603 GL_UNSIGNED_BYTE, 604 true); 605 // Add expectation for texture deletion. 606 EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged); 607 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); 608 } 609 610 TEST_F(TextureMemoryTrackerTest, SetParameterPool) { 611 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 612 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged); 613 manager_->SetLevelInfo(texture_ref_.get(), 614 GL_TEXTURE_2D, 615 0, 616 GL_RGBA, 617 8, 618 4, 619 1, 620 0, 621 GL_RGBA, 622 GL_UNSIGNED_BYTE, 623 true); 624 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged); 625 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged); 626 SetParameter(texture_ref_.get(), 627 GL_TEXTURE_POOL_CHROMIUM, 628 GL_TEXTURE_POOL_MANAGED_CHROMIUM, 629 GL_NO_ERROR); 630 // Add expectation for texture deletion. 631 EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged); 632 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); 633 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); 634 } 635 636 TEST_F(TextureTest, POT2D) { 637 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 638 Texture* texture = texture_ref_->texture(); 639 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 640 // Check Setting level 0 to POT 641 manager_->SetLevelInfo(texture_ref_.get(), 642 GL_TEXTURE_2D, 643 0, 644 GL_RGBA, 645 4, 646 4, 647 1, 648 0, 649 GL_RGBA, 650 GL_UNSIGNED_BYTE, 651 true); 652 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 653 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 654 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 655 EXPECT_EQ(0, texture->num_uncleared_mips()); 656 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 657 // Set filters to something that will work with a single mip. 658 SetParameter( 659 texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR); 660 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 661 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 662 // Set them back. 663 SetParameter(texture_ref_.get(), 664 GL_TEXTURE_MIN_FILTER, 665 GL_LINEAR_MIPMAP_LINEAR, 666 GL_NO_ERROR); 667 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 668 669 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 670 // Make mips. 671 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 672 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 673 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 674 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 675 // Change a mip. 676 manager_->SetLevelInfo(texture_ref_.get(), 677 GL_TEXTURE_2D, 678 1, 679 GL_RGBA, 680 4, 681 4, 682 1, 683 0, 684 GL_RGBA, 685 GL_UNSIGNED_BYTE, 686 true); 687 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 688 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 689 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 690 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 691 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 692 // Set a level past the number of mips that would get generated. 693 manager_->SetLevelInfo(texture_ref_.get(), 694 GL_TEXTURE_2D, 695 3, 696 GL_RGBA, 697 4, 698 4, 699 1, 700 0, 701 GL_RGBA, 702 GL_UNSIGNED_BYTE, 703 true); 704 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 705 // Make mips. 706 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 707 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 708 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 709 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 710 } 711 712 TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) { 713 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 714 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged); 715 manager_->SetLevelInfo(texture_ref_.get(), 716 GL_TEXTURE_2D, 717 0, 718 GL_RGBA, 719 4, 720 4, 721 1, 722 0, 723 GL_RGBA, 724 GL_UNSIGNED_BYTE, 725 true); 726 EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged); 727 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged); 728 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 729 EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged); 730 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged); 731 } 732 733 TEST_F(TextureTest, UnusedMips) { 734 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 735 Texture* texture = texture_ref_->texture(); 736 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 737 // Set level zero to large size. 738 manager_->SetLevelInfo(texture_ref_.get(), 739 GL_TEXTURE_2D, 740 0, 741 GL_RGBA, 742 4, 743 4, 744 1, 745 0, 746 GL_RGBA, 747 GL_UNSIGNED_BYTE, 748 true); 749 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 750 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 751 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 752 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 753 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 754 // Set level zero to large smaller (levels unused mips) 755 manager_->SetLevelInfo(texture_ref_.get(), 756 GL_TEXTURE_2D, 757 0, 758 GL_RGBA, 759 2, 760 2, 761 1, 762 0, 763 GL_RGBA, 764 GL_UNSIGNED_BYTE, 765 true); 766 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 767 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 768 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 769 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 770 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 771 // Set an unused level to some size 772 manager_->SetLevelInfo(texture_ref_.get(), 773 GL_TEXTURE_2D, 774 4, 775 GL_RGBA, 776 16, 777 16, 778 1, 779 0, 780 GL_RGBA, 781 GL_UNSIGNED_BYTE, 782 true); 783 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 784 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 785 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 786 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 787 } 788 789 TEST_F(TextureTest, NPOT2D) { 790 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 791 Texture* texture = texture_ref_->texture(); 792 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 793 // Check Setting level 0 to NPOT 794 manager_->SetLevelInfo(texture_ref_.get(), 795 GL_TEXTURE_2D, 796 0, 797 GL_RGBA, 798 4, 799 5, 800 1, 801 0, 802 GL_RGBA, 803 GL_UNSIGNED_BYTE, 804 true); 805 EXPECT_TRUE(TextureTestHelper::IsNPOT(texture)); 806 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 807 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 808 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 809 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 810 SetParameter( 811 texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR); 812 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 813 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 814 SetParameter( 815 texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR); 816 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 817 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 818 SetParameter( 819 texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR); 820 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 821 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 822 // Change it to POT. 823 manager_->SetLevelInfo(texture_ref_.get(), 824 GL_TEXTURE_2D, 825 0, 826 GL_RGBA, 827 4, 828 4, 829 1, 830 0, 831 GL_RGBA, 832 GL_UNSIGNED_BYTE, 833 true); 834 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 835 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 836 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 837 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 838 } 839 840 TEST_F(TextureTest, NPOT2DNPOTOK) { 841 TestHelper::SetupFeatureInfoInitExpectations( 842 gl_.get(), "GL_OES_texture_npot"); 843 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 844 feature_info->Initialize(); 845 TextureManager manager(NULL, 846 feature_info.get(), 847 kMaxTextureSize, 848 kMaxCubeMapTextureSize, 849 kUseDefaultTextures); 850 manager.CreateTexture(kClient1Id, kService1Id); 851 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 852 ASSERT_TRUE(texture_ref != NULL); 853 Texture* texture = texture_ref->texture(); 854 855 manager.SetTarget(texture_ref, GL_TEXTURE_2D); 856 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 857 // Check Setting level 0 to NPOT 858 manager.SetLevelInfo(texture_ref, 859 GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true); 860 EXPECT_TRUE(TextureTestHelper::IsNPOT(texture)); 861 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 862 EXPECT_TRUE(manager.CanGenerateMipmaps(texture_ref)); 863 EXPECT_FALSE(manager.CanRender(texture_ref)); 864 EXPECT_TRUE(manager.HaveUnrenderableTextures()); 865 EXPECT_TRUE(manager.MarkMipmapsGenerated(texture_ref)); 866 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 867 EXPECT_TRUE(manager.CanRender(texture_ref)); 868 EXPECT_FALSE(manager.HaveUnrenderableTextures()); 869 manager.Destroy(false); 870 } 871 872 TEST_F(TextureTest, POTCubeMap) { 873 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_CUBE_MAP); 874 Texture* texture = texture_ref_->texture(); 875 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target()); 876 // Check Setting level 0 each face to POT 877 manager_->SetLevelInfo(texture_ref_.get(), 878 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 879 0, 880 GL_RGBA, 881 4, 882 4, 883 1, 884 0, 885 GL_RGBA, 886 GL_UNSIGNED_BYTE, 887 true); 888 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 889 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 890 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 891 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 892 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 893 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 894 manager_->SetLevelInfo(texture_ref_.get(), 895 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 896 0, 897 GL_RGBA, 898 4, 899 4, 900 1, 901 0, 902 GL_RGBA, 903 GL_UNSIGNED_BYTE, 904 true); 905 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 906 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 907 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 908 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 909 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 910 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 911 manager_->SetLevelInfo(texture_ref_.get(), 912 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 913 0, 914 GL_RGBA, 915 4, 916 4, 917 1, 918 0, 919 GL_RGBA, 920 GL_UNSIGNED_BYTE, 921 true); 922 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 923 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 924 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 925 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 926 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 927 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 928 manager_->SetLevelInfo(texture_ref_.get(), 929 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 930 0, 931 GL_RGBA, 932 4, 933 4, 934 1, 935 0, 936 GL_RGBA, 937 GL_UNSIGNED_BYTE, 938 true); 939 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 940 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 941 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 942 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 943 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 944 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 945 manager_->SetLevelInfo(texture_ref_.get(), 946 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 947 0, 948 GL_RGBA, 949 4, 950 4, 951 1, 952 0, 953 GL_RGBA, 954 GL_UNSIGNED_BYTE, 955 true); 956 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 957 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 958 EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture)); 959 EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_.get())); 960 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 961 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 962 manager_->SetLevelInfo(texture_ref_.get(), 963 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 964 0, 965 GL_RGBA, 966 4, 967 4, 968 1, 969 0, 970 GL_RGBA, 971 GL_UNSIGNED_BYTE, 972 true); 973 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 974 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 975 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture)); 976 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 977 EXPECT_FALSE(manager_->CanRender(texture_ref_.get())); 978 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 979 980 // Make mips. 981 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 982 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 983 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture)); 984 EXPECT_TRUE(manager_->CanRender(texture_ref_.get())); 985 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 986 987 // Change a mip. 988 manager_->SetLevelInfo(texture_ref_.get(), 989 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 990 1, 991 GL_RGBA, 992 4, 993 4, 994 1, 995 0, 996 GL_RGBA, 997 GL_UNSIGNED_BYTE, 998 true); 999 EXPECT_FALSE(TextureTestHelper::IsNPOT(texture)); 1000 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 1001 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture)); 1002 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 1003 // Set a level past the number of mips that would get generated. 1004 manager_->SetLevelInfo(texture_ref_.get(), 1005 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 1006 3, 1007 GL_RGBA, 1008 4, 1009 4, 1010 1, 1011 0, 1012 GL_RGBA, 1013 GL_UNSIGNED_BYTE, 1014 true); 1015 EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get())); 1016 // Make mips. 1017 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 1018 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 1019 EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture)); 1020 } 1021 1022 TEST_F(TextureTest, GetLevelSize) { 1023 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1024 manager_->SetLevelInfo(texture_ref_.get(), 1025 GL_TEXTURE_2D, 1026 1, 1027 GL_RGBA, 1028 4, 1029 5, 1030 1, 1031 0, 1032 GL_RGBA, 1033 GL_UNSIGNED_BYTE, 1034 true); 1035 GLsizei width = -1; 1036 GLsizei height = -1; 1037 Texture* texture = texture_ref_->texture(); 1038 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height)); 1039 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height)); 1040 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height)); 1041 EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height)); 1042 EXPECT_EQ(4, width); 1043 EXPECT_EQ(5, height); 1044 manager_->RemoveTexture(kClient1Id); 1045 EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height)); 1046 EXPECT_EQ(4, width); 1047 EXPECT_EQ(5, height); 1048 } 1049 1050 TEST_F(TextureTest, GetLevelType) { 1051 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1052 manager_->SetLevelInfo(texture_ref_.get(), 1053 GL_TEXTURE_2D, 1054 1, 1055 GL_RGBA, 1056 4, 1057 5, 1058 1, 1059 0, 1060 GL_RGBA, 1061 GL_UNSIGNED_BYTE, 1062 true); 1063 GLenum type = -1; 1064 GLenum format = -1; 1065 Texture* texture = texture_ref_->texture(); 1066 EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, -1, &type, &format)); 1067 EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format)); 1068 EXPECT_FALSE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &format)); 1069 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format)); 1070 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type); 1071 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format); 1072 manager_->RemoveTexture(kClient1Id); 1073 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &format)); 1074 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type); 1075 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format); 1076 } 1077 1078 TEST_F(TextureTest, ValidForTexture) { 1079 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1080 manager_->SetLevelInfo(texture_ref_.get(), 1081 GL_TEXTURE_2D, 1082 1, 1083 GL_RGBA, 1084 4, 1085 5, 1086 1, 1087 0, 1088 GL_RGBA, 1089 GL_UNSIGNED_BYTE, 1090 true); 1091 // Check bad face. 1092 Texture* texture = texture_ref_->texture(); 1093 EXPECT_FALSE(texture->ValidForTexture( 1094 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 1095 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE)); 1096 // Check bad level. 1097 EXPECT_FALSE(texture->ValidForTexture( 1098 GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_UNSIGNED_BYTE)); 1099 // Check bad xoffset. 1100 EXPECT_FALSE(texture->ValidForTexture( 1101 GL_TEXTURE_2D, 1, -1, 0, 4, 5, GL_UNSIGNED_BYTE)); 1102 // Check bad xoffset + width > width. 1103 EXPECT_FALSE(texture->ValidForTexture( 1104 GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_UNSIGNED_BYTE)); 1105 // Check bad yoffset. 1106 EXPECT_FALSE(texture->ValidForTexture( 1107 GL_TEXTURE_2D, 1, 0, -1, 4, 5, GL_UNSIGNED_BYTE)); 1108 // Check bad yoffset + height > height. 1109 EXPECT_FALSE(texture->ValidForTexture( 1110 GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_UNSIGNED_BYTE)); 1111 // Check bad width. 1112 EXPECT_FALSE(texture->ValidForTexture( 1113 GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_UNSIGNED_BYTE)); 1114 // Check bad height. 1115 EXPECT_FALSE(texture->ValidForTexture( 1116 GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_UNSIGNED_BYTE)); 1117 // Check bad type. 1118 EXPECT_FALSE(texture->ValidForTexture( 1119 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_SHORT_4_4_4_4)); 1120 // Check valid full size 1121 EXPECT_TRUE(texture->ValidForTexture( 1122 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE)); 1123 // Check valid particial size. 1124 EXPECT_TRUE(texture->ValidForTexture( 1125 GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_UNSIGNED_BYTE)); 1126 manager_->RemoveTexture(kClient1Id); 1127 EXPECT_TRUE(texture->ValidForTexture( 1128 GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE)); 1129 } 1130 1131 TEST_F(TextureTest, FloatNotLinear) { 1132 TestHelper::SetupFeatureInfoInitExpectations( 1133 gl_.get(), "GL_OES_texture_float"); 1134 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 1135 feature_info->Initialize(); 1136 TextureManager manager(NULL, 1137 feature_info.get(), 1138 kMaxTextureSize, 1139 kMaxCubeMapTextureSize, 1140 kUseDefaultTextures); 1141 manager.CreateTexture(kClient1Id, kService1Id); 1142 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 1143 ASSERT_TRUE(texture_ref != NULL); 1144 manager.SetTarget(texture_ref, GL_TEXTURE_2D); 1145 Texture* texture = texture_ref->texture(); 1146 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 1147 manager.SetLevelInfo(texture_ref, 1148 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true); 1149 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 1150 TestHelper::SetTexParameteriWithExpectations( 1151 gl_.get(), error_state_.get(), &manager, 1152 texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); 1153 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 1154 TestHelper::SetTexParameteriWithExpectations( 1155 gl_.get(), error_state_.get(), &manager, texture_ref, 1156 GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR); 1157 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 1158 manager.Destroy(false); 1159 } 1160 1161 TEST_F(TextureTest, FloatLinear) { 1162 TestHelper::SetupFeatureInfoInitExpectations( 1163 gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear"); 1164 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 1165 feature_info->Initialize(); 1166 TextureManager manager(NULL, 1167 feature_info.get(), 1168 kMaxTextureSize, 1169 kMaxCubeMapTextureSize, 1170 kUseDefaultTextures); 1171 manager.CreateTexture(kClient1Id, kService1Id); 1172 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 1173 ASSERT_TRUE(texture_ref != NULL); 1174 manager.SetTarget(texture_ref, GL_TEXTURE_2D); 1175 Texture* texture = texture_ref->texture(); 1176 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 1177 manager.SetLevelInfo(texture_ref, 1178 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true); 1179 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 1180 manager.Destroy(false); 1181 } 1182 1183 TEST_F(TextureTest, HalfFloatNotLinear) { 1184 TestHelper::SetupFeatureInfoInitExpectations( 1185 gl_.get(), "GL_OES_texture_half_float"); 1186 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 1187 feature_info->Initialize(); 1188 TextureManager manager(NULL, 1189 feature_info.get(), 1190 kMaxTextureSize, 1191 kMaxCubeMapTextureSize, 1192 kUseDefaultTextures); 1193 manager.CreateTexture(kClient1Id, kService1Id); 1194 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 1195 ASSERT_TRUE(texture_ref != NULL); 1196 manager.SetTarget(texture_ref, GL_TEXTURE_2D); 1197 Texture* texture = texture_ref->texture(); 1198 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 1199 manager.SetLevelInfo(texture_ref, 1200 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true); 1201 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 1202 TestHelper::SetTexParameteriWithExpectations( 1203 gl_.get(), error_state_.get(), &manager, 1204 texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); 1205 EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture)); 1206 TestHelper::SetTexParameteriWithExpectations( 1207 gl_.get(), error_state_.get(), &manager, texture_ref, 1208 GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR); 1209 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 1210 manager.Destroy(false); 1211 } 1212 1213 TEST_F(TextureTest, HalfFloatLinear) { 1214 TestHelper::SetupFeatureInfoInitExpectations( 1215 gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear"); 1216 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 1217 feature_info->Initialize(); 1218 TextureManager manager(NULL, 1219 feature_info.get(), 1220 kMaxTextureSize, 1221 kMaxCubeMapTextureSize, 1222 kUseDefaultTextures); 1223 manager.CreateTexture(kClient1Id, kService1Id); 1224 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 1225 ASSERT_TRUE(texture_ref != NULL); 1226 manager.SetTarget(texture_ref, GL_TEXTURE_2D); 1227 Texture* texture = texture_ref->texture(); 1228 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 1229 manager.SetLevelInfo(texture_ref, 1230 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true); 1231 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 1232 manager.Destroy(false); 1233 } 1234 1235 TEST_F(TextureTest, EGLImageExternal) { 1236 TestHelper::SetupFeatureInfoInitExpectations( 1237 gl_.get(), "GL_OES_EGL_image_external"); 1238 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 1239 feature_info->Initialize(); 1240 TextureManager manager(NULL, 1241 feature_info.get(), 1242 kMaxTextureSize, 1243 kMaxCubeMapTextureSize, 1244 kUseDefaultTextures); 1245 manager.CreateTexture(kClient1Id, kService1Id); 1246 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 1247 ASSERT_TRUE(texture_ref != NULL); 1248 manager.SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES); 1249 Texture* texture = texture_ref->texture(); 1250 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target()); 1251 EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref)); 1252 manager.Destroy(false); 1253 } 1254 1255 TEST_F(TextureTest, DepthTexture) { 1256 TestHelper::SetupFeatureInfoInitExpectations( 1257 gl_.get(), "GL_ANGLE_depth_texture"); 1258 scoped_refptr<FeatureInfo> feature_info(new FeatureInfo()); 1259 feature_info->Initialize(); 1260 TextureManager manager(NULL, 1261 feature_info.get(), 1262 kMaxTextureSize, 1263 kMaxCubeMapTextureSize, 1264 kUseDefaultTextures); 1265 manager.CreateTexture(kClient1Id, kService1Id); 1266 TextureRef* texture_ref = manager.GetTexture(kClient1Id); 1267 ASSERT_TRUE(texture_ref != NULL); 1268 manager.SetTarget(texture_ref, GL_TEXTURE_2D); 1269 manager.SetLevelInfo( 1270 texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0, 1271 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false); 1272 EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref)); 1273 manager.Destroy(false); 1274 } 1275 1276 TEST_F(TextureTest, SafeUnsafe) { 1277 static const GLuint kClient2Id = 2; 1278 static const GLuint kService2Id = 12; 1279 static const GLuint kClient3Id = 3; 1280 static const GLuint kService3Id = 13; 1281 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1282 Texture* texture = texture_ref_->texture(); 1283 EXPECT_EQ(0, texture->num_uncleared_mips()); 1284 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1285 manager_->SetLevelInfo(texture_ref_.get(), 1286 GL_TEXTURE_2D, 1287 0, 1288 GL_RGBA, 1289 4, 1290 4, 1291 1, 1292 0, 1293 GL_RGBA, 1294 GL_UNSIGNED_BYTE, 1295 false); 1296 EXPECT_FALSE(texture->SafeToRenderFrom()); 1297 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1298 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1299 EXPECT_EQ(1, texture->num_uncleared_mips()); 1300 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true); 1301 EXPECT_TRUE(texture->SafeToRenderFrom()); 1302 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1303 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1304 EXPECT_EQ(0, texture->num_uncleared_mips()); 1305 manager_->SetLevelInfo(texture_ref_.get(), 1306 GL_TEXTURE_2D, 1307 1, 1308 GL_RGBA, 1309 8, 1310 8, 1311 1, 1312 0, 1313 GL_RGBA, 1314 GL_UNSIGNED_BYTE, 1315 false); 1316 EXPECT_FALSE(texture->SafeToRenderFrom()); 1317 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1318 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1319 EXPECT_EQ(1, texture->num_uncleared_mips()); 1320 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true); 1321 EXPECT_TRUE(texture->SafeToRenderFrom()); 1322 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1323 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1324 EXPECT_EQ(0, texture->num_uncleared_mips()); 1325 manager_->SetLevelInfo(texture_ref_.get(), 1326 GL_TEXTURE_2D, 1327 0, 1328 GL_RGBA, 1329 4, 1330 4, 1331 1, 1332 0, 1333 GL_RGBA, 1334 GL_UNSIGNED_BYTE, 1335 false); 1336 manager_->SetLevelInfo(texture_ref_.get(), 1337 GL_TEXTURE_2D, 1338 1, 1339 GL_RGBA, 1340 8, 1341 8, 1342 1, 1343 0, 1344 GL_RGBA, 1345 GL_UNSIGNED_BYTE, 1346 false); 1347 EXPECT_FALSE(texture->SafeToRenderFrom()); 1348 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1349 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1350 EXPECT_EQ(2, texture->num_uncleared_mips()); 1351 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 0, true); 1352 EXPECT_FALSE(texture->SafeToRenderFrom()); 1353 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1354 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1355 EXPECT_EQ(1, texture->num_uncleared_mips()); 1356 manager_->SetLevelCleared(texture_ref_.get(), GL_TEXTURE_2D, 1, true); 1357 EXPECT_TRUE(texture->SafeToRenderFrom()); 1358 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1359 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1360 EXPECT_EQ(0, texture->num_uncleared_mips()); 1361 manager_->SetLevelInfo(texture_ref_.get(), 1362 GL_TEXTURE_2D, 1363 1, 1364 GL_RGBA, 1365 8, 1366 8, 1367 1, 1368 0, 1369 GL_RGBA, 1370 GL_UNSIGNED_BYTE, 1371 false); 1372 EXPECT_FALSE(texture->SafeToRenderFrom()); 1373 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1374 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1375 EXPECT_EQ(1, texture->num_uncleared_mips()); 1376 manager_->MarkMipmapsGenerated(texture_ref_.get()); 1377 EXPECT_TRUE(texture->SafeToRenderFrom()); 1378 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1379 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1380 EXPECT_EQ(0, texture->num_uncleared_mips()); 1381 1382 manager_->CreateTexture(kClient2Id, kService2Id); 1383 scoped_refptr<TextureRef> texture_ref2( 1384 manager_->GetTexture(kClient2Id)); 1385 ASSERT_TRUE(texture_ref2.get() != NULL); 1386 manager_->SetTarget(texture_ref2.get(), GL_TEXTURE_2D); 1387 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1388 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1389 Texture* texture2 = texture_ref2->texture(); 1390 EXPECT_EQ(0, texture2->num_uncleared_mips()); 1391 manager_->SetLevelInfo(texture_ref2.get(), 1392 GL_TEXTURE_2D, 1393 0, 1394 GL_RGBA, 1395 8, 1396 8, 1397 1, 1398 0, 1399 GL_RGBA, 1400 GL_UNSIGNED_BYTE, 1401 true); 1402 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1403 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1404 EXPECT_EQ(0, texture2->num_uncleared_mips()); 1405 manager_->SetLevelInfo(texture_ref2.get(), 1406 GL_TEXTURE_2D, 1407 0, 1408 GL_RGBA, 1409 8, 1410 8, 1411 1, 1412 0, 1413 GL_RGBA, 1414 GL_UNSIGNED_BYTE, 1415 false); 1416 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1417 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1418 EXPECT_EQ(1, texture2->num_uncleared_mips()); 1419 1420 manager_->CreateTexture(kClient3Id, kService3Id); 1421 scoped_refptr<TextureRef> texture_ref3( 1422 manager_->GetTexture(kClient3Id)); 1423 ASSERT_TRUE(texture_ref3.get() != NULL); 1424 manager_->SetTarget(texture_ref3.get(), GL_TEXTURE_2D); 1425 manager_->SetLevelInfo(texture_ref3.get(), 1426 GL_TEXTURE_2D, 1427 0, 1428 GL_RGBA, 1429 8, 1430 8, 1431 1, 1432 0, 1433 GL_RGBA, 1434 GL_UNSIGNED_BYTE, 1435 false); 1436 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1437 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1438 Texture* texture3 = texture_ref3->texture(); 1439 EXPECT_EQ(1, texture3->num_uncleared_mips()); 1440 manager_->SetLevelCleared(texture_ref2.get(), GL_TEXTURE_2D, 0, true); 1441 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1442 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1443 EXPECT_EQ(0, texture2->num_uncleared_mips()); 1444 manager_->SetLevelCleared(texture_ref3.get(), GL_TEXTURE_2D, 0, true); 1445 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1446 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1447 EXPECT_EQ(0, texture3->num_uncleared_mips()); 1448 1449 manager_->SetLevelInfo(texture_ref2.get(), 1450 GL_TEXTURE_2D, 1451 0, 1452 GL_RGBA, 1453 8, 1454 8, 1455 1, 1456 0, 1457 GL_RGBA, 1458 GL_UNSIGNED_BYTE, 1459 false); 1460 manager_->SetLevelInfo(texture_ref3.get(), 1461 GL_TEXTURE_2D, 1462 0, 1463 GL_RGBA, 1464 8, 1465 8, 1466 1, 1467 0, 1468 GL_RGBA, 1469 GL_UNSIGNED_BYTE, 1470 false); 1471 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1472 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1473 EXPECT_EQ(1, texture2->num_uncleared_mips()); 1474 EXPECT_EQ(1, texture3->num_uncleared_mips()); 1475 manager_->RemoveTexture(kClient3Id); 1476 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1477 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1478 manager_->RemoveTexture(kClient2Id); 1479 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1480 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1481 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id))) 1482 .Times(1) 1483 .RetiresOnSaturation(); 1484 texture_ref2 = NULL; 1485 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1486 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1487 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id))) 1488 .Times(1) 1489 .RetiresOnSaturation(); 1490 texture_ref3 = NULL; 1491 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1492 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1493 } 1494 1495 TEST_F(TextureTest, ClearTexture) { 1496 EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _, _)) 1497 .WillRepeatedly(Return(true)); 1498 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1499 manager_->SetLevelInfo(texture_ref_.get(), 1500 GL_TEXTURE_2D, 1501 0, 1502 GL_RGBA, 1503 4, 1504 4, 1505 1, 1506 0, 1507 GL_RGBA, 1508 GL_UNSIGNED_BYTE, 1509 false); 1510 manager_->SetLevelInfo(texture_ref_.get(), 1511 GL_TEXTURE_2D, 1512 1, 1513 GL_RGBA, 1514 4, 1515 4, 1516 1, 1517 0, 1518 GL_RGBA, 1519 GL_UNSIGNED_BYTE, 1520 false); 1521 Texture* texture = texture_ref_->texture(); 1522 EXPECT_FALSE(texture->SafeToRenderFrom()); 1523 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1524 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1525 EXPECT_EQ(2, texture->num_uncleared_mips()); 1526 manager_->ClearRenderableLevels(decoder_.get(), texture_ref_.get()); 1527 EXPECT_TRUE(texture->SafeToRenderFrom()); 1528 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1529 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1530 EXPECT_EQ(0, texture->num_uncleared_mips()); 1531 manager_->SetLevelInfo(texture_ref_.get(), 1532 GL_TEXTURE_2D, 1533 0, 1534 GL_RGBA, 1535 4, 1536 4, 1537 1, 1538 0, 1539 GL_RGBA, 1540 GL_UNSIGNED_BYTE, 1541 false); 1542 manager_->SetLevelInfo(texture_ref_.get(), 1543 GL_TEXTURE_2D, 1544 1, 1545 GL_RGBA, 1546 4, 1547 4, 1548 1, 1549 0, 1550 GL_RGBA, 1551 GL_UNSIGNED_BYTE, 1552 false); 1553 EXPECT_FALSE(texture->SafeToRenderFrom()); 1554 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1555 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1556 EXPECT_EQ(2, texture->num_uncleared_mips()); 1557 manager_->ClearTextureLevel( 1558 decoder_.get(), texture_ref_.get(), GL_TEXTURE_2D, 0); 1559 EXPECT_FALSE(texture->SafeToRenderFrom()); 1560 EXPECT_TRUE(manager_->HaveUnsafeTextures()); 1561 EXPECT_TRUE(manager_->HaveUnclearedMips()); 1562 EXPECT_EQ(1, texture->num_uncleared_mips()); 1563 manager_->ClearTextureLevel( 1564 decoder_.get(), texture_ref_.get(), GL_TEXTURE_2D, 1); 1565 EXPECT_TRUE(texture->SafeToRenderFrom()); 1566 EXPECT_FALSE(manager_->HaveUnsafeTextures()); 1567 EXPECT_FALSE(manager_->HaveUnclearedMips()); 1568 EXPECT_EQ(0, texture->num_uncleared_mips()); 1569 } 1570 1571 TEST_F(TextureTest, UseDeletedTexture) { 1572 static const GLuint kClient2Id = 2; 1573 static const GLuint kService2Id = 12; 1574 // Make the default texture renderable 1575 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1576 manager_->SetLevelInfo(texture_ref_.get(), 1577 GL_TEXTURE_2D, 1578 0, 1579 GL_RGBA, 1580 1, 1581 1, 1582 1, 1583 0, 1584 GL_RGBA, 1585 GL_UNSIGNED_BYTE, 1586 false); 1587 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 1588 // Make a new texture 1589 manager_->CreateTexture(kClient2Id, kService2Id); 1590 scoped_refptr<TextureRef> texture_ref( 1591 manager_->GetTexture(kClient2Id)); 1592 manager_->SetTarget(texture_ref.get(), GL_TEXTURE_2D); 1593 EXPECT_FALSE(manager_->CanRender(texture_ref.get())); 1594 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 1595 // Remove it. 1596 manager_->RemoveTexture(kClient2Id); 1597 EXPECT_FALSE(manager_->CanRender(texture_ref.get())); 1598 EXPECT_TRUE(manager_->HaveUnrenderableTextures()); 1599 // Check that we can still manipulate it and it effects the manager. 1600 manager_->SetLevelInfo(texture_ref.get(), 1601 GL_TEXTURE_2D, 1602 0, 1603 GL_RGBA, 1604 1, 1605 1, 1606 1, 1607 0, 1608 GL_RGBA, 1609 GL_UNSIGNED_BYTE, 1610 false); 1611 EXPECT_TRUE(manager_->CanRender(texture_ref.get())); 1612 EXPECT_FALSE(manager_->HaveUnrenderableTextures()); 1613 EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id))) 1614 .Times(1) 1615 .RetiresOnSaturation(); 1616 texture_ref = NULL; 1617 } 1618 1619 TEST_F(TextureTest, GetLevelImage) { 1620 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1621 manager_->SetLevelInfo(texture_ref_.get(), 1622 GL_TEXTURE_2D, 1623 1, 1624 GL_RGBA, 1625 2, 1626 2, 1627 1, 1628 0, 1629 GL_RGBA, 1630 GL_UNSIGNED_BYTE, 1631 true); 1632 Texture* texture = texture_ref_->texture(); 1633 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); 1634 // Set image. 1635 manager_->SetLevelImage(texture_ref_.get(), 1636 GL_TEXTURE_2D, 1637 1, 1638 gfx::GLImage::CreateGLImage(0).get()); 1639 EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); 1640 // Remove it. 1641 manager_->SetLevelImage(texture_ref_.get(), GL_TEXTURE_2D, 1, NULL); 1642 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); 1643 manager_->SetLevelImage(texture_ref_.get(), 1644 GL_TEXTURE_2D, 1645 1, 1646 gfx::GLImage::CreateGLImage(0).get()); 1647 // Image should be reset when SetLevelInfo is called. 1648 manager_->SetLevelInfo(texture_ref_.get(), 1649 GL_TEXTURE_2D, 1650 1, 1651 GL_RGBA, 1652 2, 1653 2, 1654 1, 1655 0, 1656 GL_RGBA, 1657 GL_UNSIGNED_BYTE, 1658 true); 1659 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL); 1660 } 1661 1662 namespace { 1663 1664 bool InSet(std::set<std::string>* string_set, const std::string& str) { 1665 std::pair<std::set<std::string>::iterator, bool> result = 1666 string_set->insert(str); 1667 return !result.second; 1668 } 1669 1670 } // anonymous namespace 1671 1672 TEST_F(TextureTest, AddToSignature) { 1673 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1674 manager_->SetLevelInfo(texture_ref_.get(), 1675 GL_TEXTURE_2D, 1676 1, 1677 GL_RGBA, 1678 2, 1679 2, 1680 1, 1681 0, 1682 GL_RGBA, 1683 GL_UNSIGNED_BYTE, 1684 true); 1685 std::string signature1; 1686 std::string signature2; 1687 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature1); 1688 1689 std::set<std::string> string_set; 1690 EXPECT_FALSE(InSet(&string_set, signature1)); 1691 1692 // check changing 1 thing makes a different signature. 1693 manager_->SetLevelInfo(texture_ref_.get(), 1694 GL_TEXTURE_2D, 1695 1, 1696 GL_RGBA, 1697 4, 1698 2, 1699 1, 1700 0, 1701 GL_RGBA, 1702 GL_UNSIGNED_BYTE, 1703 true); 1704 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1705 EXPECT_FALSE(InSet(&string_set, signature2)); 1706 1707 // check putting it back makes the same signature. 1708 manager_->SetLevelInfo(texture_ref_.get(), 1709 GL_TEXTURE_2D, 1710 1, 1711 GL_RGBA, 1712 2, 1713 2, 1714 1, 1715 0, 1716 GL_RGBA, 1717 GL_UNSIGNED_BYTE, 1718 true); 1719 signature2.clear(); 1720 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1721 EXPECT_EQ(signature1, signature2); 1722 1723 // Check setting cleared status does not change signature. 1724 manager_->SetLevelInfo(texture_ref_.get(), 1725 GL_TEXTURE_2D, 1726 1, 1727 GL_RGBA, 1728 2, 1729 2, 1730 1, 1731 0, 1732 GL_RGBA, 1733 GL_UNSIGNED_BYTE, 1734 false); 1735 signature2.clear(); 1736 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1737 EXPECT_EQ(signature1, signature2); 1738 1739 // Check changing other settings changes signature. 1740 manager_->SetLevelInfo(texture_ref_.get(), 1741 GL_TEXTURE_2D, 1742 1, 1743 GL_RGBA, 1744 2, 1745 4, 1746 1, 1747 0, 1748 GL_RGBA, 1749 GL_UNSIGNED_BYTE, 1750 false); 1751 signature2.clear(); 1752 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1753 EXPECT_FALSE(InSet(&string_set, signature2)); 1754 1755 manager_->SetLevelInfo(texture_ref_.get(), 1756 GL_TEXTURE_2D, 1757 1, 1758 GL_RGBA, 1759 2, 1760 2, 1761 2, 1762 0, 1763 GL_RGBA, 1764 GL_UNSIGNED_BYTE, 1765 false); 1766 signature2.clear(); 1767 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1768 EXPECT_FALSE(InSet(&string_set, signature2)); 1769 1770 manager_->SetLevelInfo(texture_ref_.get(), 1771 GL_TEXTURE_2D, 1772 1, 1773 GL_RGBA, 1774 2, 1775 2, 1776 1, 1777 1, 1778 GL_RGBA, 1779 GL_UNSIGNED_BYTE, 1780 false); 1781 signature2.clear(); 1782 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1783 EXPECT_FALSE(InSet(&string_set, signature2)); 1784 1785 manager_->SetLevelInfo(texture_ref_.get(), 1786 GL_TEXTURE_2D, 1787 1, 1788 GL_RGBA, 1789 2, 1790 2, 1791 1, 1792 0, 1793 GL_RGB, 1794 GL_UNSIGNED_BYTE, 1795 false); 1796 signature2.clear(); 1797 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1798 EXPECT_FALSE(InSet(&string_set, signature2)); 1799 1800 manager_->SetLevelInfo(texture_ref_.get(), 1801 GL_TEXTURE_2D, 1802 1, 1803 GL_RGBA, 1804 2, 1805 2, 1806 1, 1807 0, 1808 GL_RGBA, 1809 GL_FLOAT, 1810 false); 1811 signature2.clear(); 1812 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1813 EXPECT_FALSE(InSet(&string_set, signature2)); 1814 1815 // put it back 1816 manager_->SetLevelInfo(texture_ref_.get(), 1817 GL_TEXTURE_2D, 1818 1, 1819 GL_RGBA, 1820 2, 1821 2, 1822 1, 1823 0, 1824 GL_RGBA, 1825 GL_UNSIGNED_BYTE, 1826 false); 1827 signature2.clear(); 1828 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1829 EXPECT_EQ(signature1, signature2); 1830 1831 // check changing parameters changes signature. 1832 SetParameter( 1833 texture_ref_.get(), GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR); 1834 signature2.clear(); 1835 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1836 EXPECT_FALSE(InSet(&string_set, signature2)); 1837 1838 SetParameter(texture_ref_.get(), 1839 GL_TEXTURE_MIN_FILTER, 1840 GL_NEAREST_MIPMAP_LINEAR, 1841 GL_NO_ERROR); 1842 SetParameter( 1843 texture_ref_.get(), GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR); 1844 signature2.clear(); 1845 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1846 EXPECT_FALSE(InSet(&string_set, signature2)); 1847 1848 SetParameter( 1849 texture_ref_.get(), GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR); 1850 SetParameter( 1851 texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR); 1852 signature2.clear(); 1853 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1854 EXPECT_FALSE(InSet(&string_set, signature2)); 1855 1856 SetParameter(texture_ref_.get(), GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR); 1857 SetParameter( 1858 texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR); 1859 signature2.clear(); 1860 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1861 EXPECT_FALSE(InSet(&string_set, signature2)); 1862 1863 // Check putting it back genenerates the same signature 1864 SetParameter(texture_ref_.get(), GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR); 1865 signature2.clear(); 1866 manager_->AddToSignature(texture_ref_.get(), GL_TEXTURE_2D, 1, &signature2); 1867 EXPECT_EQ(signature1, signature2); 1868 1869 // Check the set was acutally getting different signatures. 1870 EXPECT_EQ(11u, string_set.size()); 1871 } 1872 1873 class ProduceConsumeTextureTest : public TextureTest, 1874 public ::testing::WithParamInterface<GLenum> { 1875 public: 1876 virtual void SetUp() { 1877 TextureTest::SetUpBase(NULL, "GL_OES_EGL_image_external"); 1878 manager_->CreateTexture(kClient2Id, kService2Id); 1879 texture2_ = manager_->GetTexture(kClient2Id); 1880 1881 EXPECT_CALL(*decoder_.get(), GetErrorState()) 1882 .WillRepeatedly(Return(error_state_.get())); 1883 } 1884 1885 virtual void TearDown() { 1886 if (texture2_.get()) { 1887 // If it's not in the manager then setting texture2_ to NULL will 1888 // delete the texture. 1889 if (!texture2_->client_id()) { 1890 // Check that it gets deleted when the last reference is released. 1891 EXPECT_CALL( 1892 *gl_, 1893 DeleteTextures(1, ::testing::Pointee(texture2_->service_id()))) 1894 .Times(1).RetiresOnSaturation(); 1895 } 1896 texture2_ = NULL; 1897 } 1898 TextureTest::TearDown(); 1899 } 1900 1901 protected: 1902 struct LevelInfo { 1903 LevelInfo(GLenum target, 1904 GLenum format, 1905 GLsizei width, 1906 GLsizei height, 1907 GLsizei depth, 1908 GLint border, 1909 GLenum type, 1910 bool cleared) 1911 : target(target), 1912 format(format), 1913 width(width), 1914 height(height), 1915 depth(depth), 1916 border(border), 1917 type(type), 1918 cleared(cleared) {} 1919 1920 LevelInfo() 1921 : target(0), 1922 format(0), 1923 width(-1), 1924 height(-1), 1925 depth(1), 1926 border(0), 1927 type(0), 1928 cleared(false) {} 1929 1930 bool operator==(const LevelInfo& other) const { 1931 return target == other.target && format == other.format && 1932 width == other.width && height == other.height && 1933 depth == other.depth && border == other.border && 1934 type == other.type && cleared == other.cleared; 1935 } 1936 1937 GLenum target; 1938 GLenum format; 1939 GLsizei width; 1940 GLsizei height; 1941 GLsizei depth; 1942 GLint border; 1943 GLenum type; 1944 bool cleared; 1945 }; 1946 1947 void SetLevelInfo(TextureRef* texture_ref, 1948 GLint level, 1949 const LevelInfo& info) { 1950 manager_->SetLevelInfo(texture_ref, 1951 info.target, 1952 level, 1953 info.format, 1954 info.width, 1955 info.height, 1956 info.depth, 1957 info.border, 1958 info.format, 1959 info.type, 1960 info.cleared); 1961 } 1962 1963 static LevelInfo GetLevelInfo(const TextureRef* texture_ref, 1964 GLint target, 1965 GLint level) { 1966 const Texture* texture = texture_ref->texture(); 1967 LevelInfo info; 1968 info.target = target; 1969 EXPECT_TRUE(texture->GetLevelSize(target, level, &info.width, 1970 &info.height)); 1971 EXPECT_TRUE(texture->GetLevelType(target, level, &info.type, 1972 &info.format)); 1973 info.cleared = texture->IsLevelCleared(target, level); 1974 return info; 1975 } 1976 1977 Texture* Produce(TextureRef* texture_ref) { 1978 Texture* texture = manager_->Produce(texture_ref); 1979 EXPECT_TRUE(texture != NULL); 1980 return texture; 1981 } 1982 1983 void Consume(GLuint client_id, Texture* texture) { 1984 EXPECT_TRUE(manager_->Consume(client_id, texture)); 1985 } 1986 1987 scoped_refptr<TextureRef> texture2_; 1988 1989 private: 1990 static const GLuint kClient2Id; 1991 static const GLuint kService2Id; 1992 }; 1993 1994 const GLuint ProduceConsumeTextureTest::kClient2Id = 2; 1995 const GLuint ProduceConsumeTextureTest::kService2Id = 12; 1996 1997 TEST_F(ProduceConsumeTextureTest, ProduceConsume2D) { 1998 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_2D); 1999 Texture* texture = texture_ref_->texture(); 2000 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target()); 2001 LevelInfo level0( 2002 GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE, true); 2003 SetLevelInfo(texture_ref_.get(), 0, level0); 2004 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_.get())); 2005 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 2006 LevelInfo level1 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1); 2007 LevelInfo level2 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2); 2008 Texture* produced_texture = Produce(texture_ref_.get()); 2009 EXPECT_EQ(produced_texture, texture); 2010 2011 // Make this texture bigger with more levels, and make sure they get 2012 // clobbered correctly during Consume(). 2013 manager_->SetTarget(texture2_.get(), GL_TEXTURE_2D); 2014 SetLevelInfo( 2015 texture2_.get(), 2016 0, 2017 LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1, 0, GL_UNSIGNED_BYTE, false)); 2018 EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture2_.get())); 2019 texture = texture2_->texture(); 2020 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 2021 EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture->estimated_size()); 2022 2023 GLuint client_id = texture2_->client_id(); 2024 manager_->RemoveTexture(client_id); 2025 Consume(client_id, produced_texture); 2026 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id); 2027 EXPECT_EQ(produced_texture, restored_texture->texture()); 2028 EXPECT_EQ(level0, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 0)); 2029 EXPECT_EQ(level1, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 1)); 2030 EXPECT_EQ(level2, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 2)); 2031 texture = restored_texture->texture(); 2032 EXPECT_EQ(64U + 16U + 4U, texture->estimated_size()); 2033 GLint w, h; 2034 EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h)); 2035 2036 // However the old texture ref still exists if it was referenced somewhere. 2037 EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, 2038 texture2_->texture()->estimated_size()); 2039 } 2040 2041 TEST_F(ProduceConsumeTextureTest, ProduceConsumeClearRectangle) { 2042 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_RECTANGLE_ARB); 2043 Texture* texture = texture_ref_->texture(); 2044 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture->target()); 2045 LevelInfo level0( 2046 GL_TEXTURE_RECTANGLE_ARB, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false); 2047 SetLevelInfo(texture_ref_.get(), 0, level0); 2048 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 2049 Texture* produced_texture = Produce(texture_ref_.get()); 2050 EXPECT_EQ(produced_texture, texture); 2051 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), 2052 produced_texture->target()); 2053 2054 GLuint client_id = texture2_->client_id(); 2055 manager_->RemoveTexture(client_id); 2056 Consume(client_id, produced_texture); 2057 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id); 2058 EXPECT_EQ(produced_texture, restored_texture->texture()); 2059 2060 // See if we can clear the previously uncleared level now. 2061 EXPECT_EQ(level0, 2062 GetLevelInfo(restored_texture.get(), GL_TEXTURE_RECTANGLE_ARB, 0)); 2063 EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _, _)) 2064 .WillRepeatedly(Return(true)); 2065 EXPECT_TRUE(manager_->ClearTextureLevel( 2066 decoder_.get(), restored_texture.get(), GL_TEXTURE_RECTANGLE_ARB, 0)); 2067 } 2068 2069 TEST_F(ProduceConsumeTextureTest, ProduceConsumeExternal) { 2070 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_EXTERNAL_OES); 2071 Texture* texture = texture_ref_->texture(); 2072 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target()); 2073 LevelInfo level0( 2074 GL_TEXTURE_EXTERNAL_OES, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false); 2075 SetLevelInfo(texture_ref_.get(), 0, level0); 2076 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 2077 Texture* produced_texture = Produce(texture_ref_.get()); 2078 EXPECT_EQ(produced_texture, texture); 2079 2080 GLuint client_id = texture2_->client_id(); 2081 manager_->RemoveTexture(client_id); 2082 Consume(client_id, produced_texture); 2083 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id); 2084 EXPECT_EQ(produced_texture, restored_texture->texture()); 2085 EXPECT_EQ(level0, 2086 GetLevelInfo(restored_texture.get(), GL_TEXTURE_EXTERNAL_OES, 0)); 2087 } 2088 2089 TEST_P(ProduceConsumeTextureTest, ProduceConsumeTextureWithImage) { 2090 GLenum target = GetParam(); 2091 manager_->SetTarget(texture_ref_.get(), target); 2092 Texture* texture = texture_ref_->texture(); 2093 EXPECT_EQ(static_cast<GLenum>(target), texture->target()); 2094 scoped_refptr<gfx::GLImage> image(gfx::GLImage::CreateGLImage(0)); 2095 manager_->SetLevelInfo(texture_ref_.get(), 2096 target, 2097 0, 2098 GL_RGBA, 2099 0, 2100 0, 2101 1, 2102 0, 2103 GL_RGBA, 2104 GL_UNSIGNED_BYTE, 2105 true); 2106 manager_->SetLevelImage(texture_ref_.get(), target, 0, image); 2107 GLuint service_id = texture->service_id(); 2108 Texture* produced_texture = Produce(texture_ref_.get()); 2109 2110 GLuint client_id = texture2_->client_id(); 2111 manager_->RemoveTexture(client_id); 2112 Consume(client_id, produced_texture); 2113 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id); 2114 EXPECT_EQ(produced_texture, restored_texture->texture()); 2115 EXPECT_EQ(service_id, restored_texture->service_id()); 2116 EXPECT_EQ(image.get(), restored_texture->texture()->GetLevelImage(target, 0)); 2117 } 2118 2119 static const GLenum kTextureTargets[] = {GL_TEXTURE_2D, GL_TEXTURE_EXTERNAL_OES, 2120 GL_TEXTURE_RECTANGLE_ARB, }; 2121 2122 INSTANTIATE_TEST_CASE_P(Target, 2123 ProduceConsumeTextureTest, 2124 ::testing::ValuesIn(kTextureTargets)); 2125 2126 TEST_F(ProduceConsumeTextureTest, ProduceConsumeCube) { 2127 manager_->SetTarget(texture_ref_.get(), GL_TEXTURE_CUBE_MAP); 2128 Texture* texture = texture_ref_->texture(); 2129 EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target()); 2130 LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 2131 GL_RGBA, 2132 1, 2133 1, 2134 1, 2135 0, 2136 GL_UNSIGNED_BYTE, 2137 true); 2138 LevelInfo face5(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 2139 GL_RGBA, 2140 3, 2141 3, 2142 1, 2143 0, 2144 GL_UNSIGNED_BYTE, 2145 true); 2146 SetLevelInfo(texture_ref_.get(), 0, face0); 2147 SetLevelInfo(texture_ref_.get(), 0, face5); 2148 EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture)); 2149 Texture* produced_texture = Produce(texture_ref_.get()); 2150 EXPECT_EQ(produced_texture, texture); 2151 2152 GLuint client_id = texture2_->client_id(); 2153 manager_->RemoveTexture(client_id); 2154 Consume(client_id, produced_texture); 2155 scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id); 2156 EXPECT_EQ(produced_texture, restored_texture->texture()); 2157 EXPECT_EQ( 2158 face0, 2159 GetLevelInfo(restored_texture.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0)); 2160 EXPECT_EQ( 2161 face5, 2162 GetLevelInfo(restored_texture.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0)); 2163 } 2164 2165 class CountingMemoryTracker : public MemoryTracker { 2166 public: 2167 CountingMemoryTracker() { 2168 current_size_[0] = 0; 2169 current_size_[1] = 0; 2170 } 2171 2172 virtual void TrackMemoryAllocatedChange(size_t old_size, 2173 size_t new_size, 2174 Pool pool) OVERRIDE { 2175 DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_)); 2176 current_size_[pool] += new_size - old_size; 2177 } 2178 2179 virtual bool EnsureGPUMemoryAvailable(size_t size_needed) OVERRIDE { 2180 return true; 2181 } 2182 2183 size_t GetSize(Pool pool) { 2184 DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_)); 2185 return current_size_[pool]; 2186 } 2187 2188 private: 2189 virtual ~CountingMemoryTracker() {} 2190 2191 size_t current_size_[2]; 2192 DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker); 2193 }; 2194 2195 class SharedTextureTest : public GpuServiceTest { 2196 public: 2197 static const bool kUseDefaultTextures = false; 2198 2199 SharedTextureTest() : feature_info_(new FeatureInfo()) {} 2200 2201 virtual ~SharedTextureTest() { 2202 } 2203 2204 virtual void SetUp() { 2205 GpuServiceTest::SetUp(); 2206 memory_tracker1_ = new CountingMemoryTracker; 2207 texture_manager1_.reset( 2208 new TextureManager(memory_tracker1_.get(), 2209 feature_info_.get(), 2210 TextureManagerTest::kMaxTextureSize, 2211 TextureManagerTest::kMaxCubeMapTextureSize, 2212 kUseDefaultTextures)); 2213 memory_tracker2_ = new CountingMemoryTracker; 2214 texture_manager2_.reset( 2215 new TextureManager(memory_tracker2_.get(), 2216 feature_info_.get(), 2217 TextureManagerTest::kMaxTextureSize, 2218 TextureManagerTest::kMaxCubeMapTextureSize, 2219 kUseDefaultTextures)); 2220 TestHelper::SetupTextureManagerInitExpectations( 2221 gl_.get(), "", kUseDefaultTextures); 2222 texture_manager1_->Initialize(); 2223 TestHelper::SetupTextureManagerInitExpectations( 2224 gl_.get(), "", kUseDefaultTextures); 2225 texture_manager2_->Initialize(); 2226 } 2227 2228 virtual void TearDown() { 2229 texture_manager2_->Destroy(false); 2230 texture_manager2_.reset(); 2231 texture_manager1_->Destroy(false); 2232 texture_manager1_.reset(); 2233 GpuServiceTest::TearDown(); 2234 } 2235 2236 protected: 2237 scoped_refptr<FeatureInfo> feature_info_; 2238 scoped_refptr<CountingMemoryTracker> memory_tracker1_; 2239 scoped_ptr<TextureManager> texture_manager1_; 2240 scoped_refptr<CountingMemoryTracker> memory_tracker2_; 2241 scoped_ptr<TextureManager> texture_manager2_; 2242 }; 2243 2244 TEST_F(SharedTextureTest, DeleteTextures) { 2245 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10); 2246 scoped_refptr<TextureRef> ref2 = 2247 texture_manager2_->Consume(20, ref1->texture()); 2248 EXPECT_CALL(*gl_, DeleteTextures(1, _)) 2249 .Times(0); 2250 ref1 = NULL; 2251 texture_manager1_->RemoveTexture(10); 2252 testing::Mock::VerifyAndClearExpectations(gl_.get()); 2253 2254 EXPECT_CALL(*gl_, DeleteTextures(1, _)) 2255 .Times(1) 2256 .RetiresOnSaturation(); 2257 ref2 = NULL; 2258 texture_manager2_->RemoveTexture(20); 2259 testing::Mock::VerifyAndClearExpectations(gl_.get()); 2260 } 2261 2262 TEST_F(SharedTextureTest, TextureSafetyAccounting) { 2263 EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures()); 2264 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures()); 2265 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips()); 2266 EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures()); 2267 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures()); 2268 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips()); 2269 2270 // Newly created texture is renderable. 2271 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10); 2272 EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures()); 2273 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures()); 2274 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips()); 2275 2276 // Associate new texture ref to other texture manager, should account for it 2277 // too. 2278 scoped_refptr<TextureRef> ref2 = 2279 texture_manager2_->Consume(20, ref1->texture()); 2280 EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures()); 2281 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures()); 2282 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips()); 2283 2284 // Make texture renderable but uncleared on one texture manager, should affect 2285 // other one. 2286 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D); 2287 EXPECT_TRUE(texture_manager1_->HaveUnrenderableTextures()); 2288 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures()); 2289 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips()); 2290 EXPECT_TRUE(texture_manager2_->HaveUnrenderableTextures()); 2291 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures()); 2292 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips()); 2293 2294 texture_manager1_->SetLevelInfo(ref1.get(), 2295 GL_TEXTURE_2D, 2296 0, 2297 GL_RGBA, 2298 1, 2299 1, 2300 1, 2301 0, 2302 GL_RGBA, 2303 GL_UNSIGNED_BYTE, 2304 false); 2305 EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures()); 2306 EXPECT_TRUE(texture_manager1_->HaveUnsafeTextures()); 2307 EXPECT_TRUE(texture_manager1_->HaveUnclearedMips()); 2308 EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures()); 2309 EXPECT_TRUE(texture_manager2_->HaveUnsafeTextures()); 2310 EXPECT_TRUE(texture_manager2_->HaveUnclearedMips()); 2311 2312 // Make texture cleared on one texture manager, should affect other one. 2313 texture_manager1_->SetLevelCleared(ref1.get(), GL_TEXTURE_2D, 0, true); 2314 EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures()); 2315 EXPECT_FALSE(texture_manager1_->HaveUnclearedMips()); 2316 EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures()); 2317 EXPECT_FALSE(texture_manager2_->HaveUnclearedMips()); 2318 2319 EXPECT_CALL(*gl_, DeleteTextures(1, _)) 2320 .Times(1) 2321 .RetiresOnSaturation(); 2322 texture_manager1_->RemoveTexture(10); 2323 texture_manager2_->RemoveTexture(20); 2324 } 2325 2326 TEST_F(SharedTextureTest, FBOCompletenessCheck) { 2327 const GLenum kCompleteValue = GL_FRAMEBUFFER_COMPLETE; 2328 FramebufferManager framebuffer_manager1(1, 1); 2329 texture_manager1_->set_framebuffer_manager(&framebuffer_manager1); 2330 FramebufferManager framebuffer_manager2(1, 1); 2331 texture_manager2_->set_framebuffer_manager(&framebuffer_manager2); 2332 2333 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10); 2334 framebuffer_manager1.CreateFramebuffer(10, 10); 2335 scoped_refptr<Framebuffer> framebuffer1 = 2336 framebuffer_manager1.GetFramebuffer(10); 2337 framebuffer1->AttachTexture( 2338 GL_COLOR_ATTACHMENT0, ref1.get(), GL_TEXTURE_2D, 0, 0); 2339 EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1.get())); 2340 EXPECT_NE(kCompleteValue, framebuffer1->IsPossiblyComplete()); 2341 2342 // Make FBO complete in manager 1. 2343 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D); 2344 texture_manager1_->SetLevelInfo(ref1.get(), 2345 GL_TEXTURE_2D, 2346 0, 2347 GL_RGBA, 2348 1, 2349 1, 2350 1, 2351 0, 2352 GL_RGBA, 2353 GL_UNSIGNED_BYTE, 2354 true); 2355 EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete()); 2356 framebuffer_manager1.MarkAsComplete(framebuffer1.get()); 2357 EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1.get())); 2358 2359 // Share texture with manager 2. 2360 scoped_refptr<TextureRef> ref2 = 2361 texture_manager2_->Consume(20, ref1->texture()); 2362 framebuffer_manager2.CreateFramebuffer(20, 20); 2363 scoped_refptr<Framebuffer> framebuffer2 = 2364 framebuffer_manager2.GetFramebuffer(20); 2365 framebuffer2->AttachTexture( 2366 GL_COLOR_ATTACHMENT0, ref2.get(), GL_TEXTURE_2D, 0, 0); 2367 EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2.get())); 2368 EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete()); 2369 framebuffer_manager2.MarkAsComplete(framebuffer2.get()); 2370 EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2.get())); 2371 2372 // Change level for texture, both FBOs should be marked incomplete 2373 texture_manager1_->SetLevelInfo(ref1.get(), 2374 GL_TEXTURE_2D, 2375 0, 2376 GL_RGBA, 2377 1, 2378 1, 2379 1, 2380 0, 2381 GL_RGBA, 2382 GL_UNSIGNED_BYTE, 2383 true); 2384 EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1.get())); 2385 EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete()); 2386 framebuffer_manager1.MarkAsComplete(framebuffer1.get()); 2387 EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1.get())); 2388 EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2.get())); 2389 EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete()); 2390 framebuffer_manager2.MarkAsComplete(framebuffer2.get()); 2391 EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2.get())); 2392 2393 EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _)) 2394 .Times(2) 2395 .RetiresOnSaturation(); 2396 framebuffer_manager1.RemoveFramebuffer(10); 2397 framebuffer_manager2.RemoveFramebuffer(20); 2398 EXPECT_CALL(*gl_, DeleteTextures(1, _)) 2399 .Times(1) 2400 .RetiresOnSaturation(); 2401 texture_manager1_->RemoveTexture(10); 2402 texture_manager2_->RemoveTexture(20); 2403 } 2404 2405 TEST_F(SharedTextureTest, Memory) { 2406 size_t initial_memory1 = memory_tracker1_->GetSize(MemoryTracker::kUnmanaged); 2407 size_t initial_memory2 = memory_tracker2_->GetSize(MemoryTracker::kUnmanaged); 2408 2409 // Newly created texture is unrenderable. 2410 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10); 2411 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D); 2412 texture_manager1_->SetLevelInfo(ref1.get(), 2413 GL_TEXTURE_2D, 2414 0, 2415 GL_RGBA, 2416 10, 2417 10, 2418 1, 2419 0, 2420 GL_RGBA, 2421 GL_UNSIGNED_BYTE, 2422 false); 2423 2424 EXPECT_LT(0u, ref1->texture()->estimated_size()); 2425 EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(), 2426 memory_tracker1_->GetSize(MemoryTracker::kUnmanaged)); 2427 2428 // Associate new texture ref to other texture manager, it doesn't account for 2429 // the texture memory, the first memory tracker still has it. 2430 scoped_refptr<TextureRef> ref2 = 2431 texture_manager2_->Consume(20, ref1->texture()); 2432 EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(), 2433 memory_tracker1_->GetSize(MemoryTracker::kUnmanaged)); 2434 EXPECT_EQ(initial_memory2, 2435 memory_tracker2_->GetSize(MemoryTracker::kUnmanaged)); 2436 2437 // Delete the texture, memory should go to the remaining tracker. 2438 texture_manager1_->RemoveTexture(10); 2439 ref1 = NULL; 2440 EXPECT_EQ(initial_memory1, 2441 memory_tracker1_->GetSize(MemoryTracker::kUnmanaged)); 2442 EXPECT_EQ(initial_memory2 + ref2->texture()->estimated_size(), 2443 memory_tracker2_->GetSize(MemoryTracker::kUnmanaged)); 2444 2445 EXPECT_CALL(*gl_, DeleteTextures(1, _)) 2446 .Times(1) 2447 .RetiresOnSaturation(); 2448 ref2 = NULL; 2449 texture_manager2_->RemoveTexture(20); 2450 EXPECT_EQ(initial_memory2, 2451 memory_tracker2_->GetSize(MemoryTracker::kUnmanaged)); 2452 } 2453 2454 TEST_F(SharedTextureTest, Images) { 2455 scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10); 2456 scoped_refptr<TextureRef> ref2 = 2457 texture_manager2_->Consume(20, ref1->texture()); 2458 2459 texture_manager1_->SetTarget(ref1.get(), GL_TEXTURE_2D); 2460 texture_manager1_->SetLevelInfo(ref1.get(), 2461 GL_TEXTURE_2D, 2462 1, 2463 GL_RGBA, 2464 2, 2465 2, 2466 1, 2467 0, 2468 GL_RGBA, 2469 GL_UNSIGNED_BYTE, 2470 true); 2471 EXPECT_FALSE(ref1->texture()->HasImages()); 2472 EXPECT_FALSE(ref2->texture()->HasImages()); 2473 EXPECT_FALSE(texture_manager1_->HaveImages()); 2474 EXPECT_FALSE(texture_manager2_->HaveImages()); 2475 texture_manager1_->SetLevelImage(ref1.get(), 2476 GL_TEXTURE_2D, 2477 1, 2478 gfx::GLImage::CreateGLImage(0).get()); 2479 EXPECT_TRUE(ref1->texture()->HasImages()); 2480 EXPECT_TRUE(ref2->texture()->HasImages()); 2481 EXPECT_TRUE(texture_manager1_->HaveImages()); 2482 EXPECT_TRUE(texture_manager2_->HaveImages()); 2483 texture_manager1_->SetLevelImage(ref1.get(), 2484 GL_TEXTURE_2D, 2485 1, 2486 gfx::GLImage::CreateGLImage(0).get()); 2487 EXPECT_TRUE(ref1->texture()->HasImages()); 2488 EXPECT_TRUE(ref2->texture()->HasImages()); 2489 EXPECT_TRUE(texture_manager1_->HaveImages()); 2490 EXPECT_TRUE(texture_manager2_->HaveImages()); 2491 texture_manager1_->SetLevelInfo(ref1.get(), 2492 GL_TEXTURE_2D, 2493 1, 2494 GL_RGBA, 2495 2, 2496 2, 2497 1, 2498 0, 2499 GL_RGBA, 2500 GL_UNSIGNED_BYTE, 2501 true); 2502 EXPECT_FALSE(ref1->texture()->HasImages()); 2503 EXPECT_FALSE(ref2->texture()->HasImages()); 2504 EXPECT_FALSE(texture_manager1_->HaveImages()); 2505 EXPECT_FALSE(texture_manager1_->HaveImages()); 2506 2507 EXPECT_CALL(*gl_, DeleteTextures(1, _)) 2508 .Times(1) 2509 .RetiresOnSaturation(); 2510 texture_manager1_->RemoveTexture(10); 2511 texture_manager2_->RemoveTexture(20); 2512 } 2513 2514 } // namespace gles2 2515 } // namespace gpu 2516
