Remove default textures in (!bind_generates_resource) context groups.

gpu/command_buffer/service/texture_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
@@ skipping 31 matching lines @@
 class TextureManagerTest : public testing::Test {
  public:
   static const GLint kMaxTextureSize = 16;
   static const GLint kMaxCubeMapTextureSize = 8;
   static const GLint kMaxExternalTextureSize = 16;
   static const GLint kMax2dLevels = 5;
   static const GLint kMaxCubeMapLevels = 4;
   static const GLint kMaxExternalLevels = 1;
 
   TextureManagerTest()
-      : feature_info_(new FeatureInfo()) {
-  }
+      : feature_info_(new FeatureInfo()), use_default_textures_(false) {}
 
   virtual ~TextureManagerTest() {
   }
 
  protected:
   virtual void SetUp() {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::MockGLInterface::SetGLInterface(gl_.get());
 
     manager_.reset(new TextureManager(
         NULL, feature_info_.get(),
         kMaxTextureSize, kMaxCubeMapTextureSize));
-    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+    TestHelper::SetupTextureManagerInitExpectations(
+        gl_.get(), "", use_default_textures_);
+    manager_->set_use_default_textures(use_default_textures_);
     manager_->Initialize();
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
   }
 
   virtual void TearDown() {
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::MockGLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
   void SetParameter(
       TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
     TestHelper::SetTexParameteriWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
         texture_ref, pname, value, error);
   }
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
   scoped_ptr<MockErrorState> error_state_;
+  bool use_default_textures_;

[piman, 2014/04/04 02:50:28]

Same here, is there anything that sets this?

[vmiura, 2014/04/04 18:32:57]

Changed to kUseDefaultTextures.

 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLint TextureManagerTest::kMaxTextureSize;
 const GLint TextureManagerTest::kMaxCubeMapTextureSize;
 const GLint TextureManagerTest::kMaxExternalTextureSize;
 const GLint TextureManagerTest::kMax2dLevels;
 const GLint TextureManagerTest::kMaxCubeMapLevels;
 const GLint TextureManagerTest::kMaxExternalLevels;
@@ skipping 56 matching lines @@
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
   EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
   SetParameter(texture_ref, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM);
   EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
   SetParameter(texture_ref, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM);
   EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
   SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
 }
 
 TEST_F(TextureManagerTest, TextureUsageExt) {
-  TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
-                                                  "GL_ANGLE_texture_usage");
+  bool use_default_textures = false;
+  TestHelper::SetupTextureManagerInitExpectations(
+      gl_.get(), "GL_ANGLE_texture_usage", use_default_textures);
   TextureManager manager(
       NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.Initialize();
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create texture.
   manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE,GL_NO_ERROR);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
             texture_ref->texture()->usage());
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
-  TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+  bool use_default_textures = false;
+  TestHelper::SetupTextureManagerInitExpectations(
+      gl_.get(), "", use_default_textures);
   TextureManager manager(
       NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.Initialize();
   // Check we can create texture.
   manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
   TextureRef* texture = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture != NULL);
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
-  TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), "");
+  TestHelper::SetupTextureManagerDestructionExpectations(
+      gl_.get(), "", use_default_textures);
   manager.Destroy(true);
   // Check that resources got freed.
   texture = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture == NULL);
 }
 
 TEST_F(TextureManagerTest, MaxValues) {
   // Check we get the right values for the max sizes.
   EXPECT_EQ(kMax2dLevels, manager_->MaxLevelsForTarget(GL_TEXTURE_2D));
   EXPECT_EQ(kMaxCubeMapLevels,
@@ skipping 1908 matching lines @@
  private:
   virtual ~CountingMemoryTracker() {}
 
   size_t current_size_[2];
   DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
 };
 
 class SharedTextureTest : public testing::Test {
  public:
   SharedTextureTest()
-      : feature_info_(new FeatureInfo()) {
-  }
+      : feature_info_(new FeatureInfo()), use_default_textures_(false) {}
 
   virtual ~SharedTextureTest() {
   }
 
   virtual void SetUp() {
     gl_.reset(new ::gfx::MockGLInterface());
     ::gfx::MockGLInterface::SetGLInterface(gl_.get());
 
     memory_tracker1_ = new CountingMemoryTracker;
     texture_manager1_.reset(
         new TextureManager(memory_tracker1_.get(),
                            feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize));
     memory_tracker2_ = new CountingMemoryTracker;
     texture_manager2_.reset(
         new TextureManager(memory_tracker2_.get(),
                            feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
                            TextureManagerTest::kMaxCubeMapTextureSize));
-    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+    TestHelper::SetupTextureManagerInitExpectations(
+        gl_.get(), "", use_default_textures_);
+    texture_manager1_->set_use_default_textures(use_default_textures_);
     texture_manager1_->Initialize();
-    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+    TestHelper::SetupTextureManagerInitExpectations(
+        gl_.get(), "", use_default_textures_);
+    texture_manager2_->set_use_default_textures(use_default_textures_);
     texture_manager2_->Initialize();
   }
 
   virtual void TearDown() {
     texture_manager2_->Destroy(false);
     texture_manager2_.reset();
     texture_manager1_->Destroy(false);
     texture_manager1_.reset();
     ::gfx::MockGLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
  protected:
   scoped_ptr< ::gfx::MockGLInterface > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_refptr<CountingMemoryTracker> memory_tracker1_;
   scoped_ptr<TextureManager> texture_manager1_;
   scoped_refptr<CountingMemoryTracker> memory_tracker2_;
   scoped_ptr<TextureManager> texture_manager2_;
+  bool use_default_textures_;
 };
 
 TEST_F(SharedTextureTest, DeleteTextures) {
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   scoped_refptr<TextureRef> ref2 =
       texture_manager2_->Consume(20, ref1->texture());
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(0);
   ref1 = NULL;
   texture_manager1_->RemoveTexture(10);
@@ skipping 254 matching lines @@
 
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
       .RetiresOnSaturation();
   texture_manager1_->RemoveTexture(10);
   texture_manager2_->RemoveTexture(20);
 }
 
 }  // namespace gles2
 }  // namespace gpu