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 29 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;
+  static const bool kUseDefaultTextures = false;
 
-  TextureManagerTest()
-      : feature_info_(new FeatureInfo()) {
-  }
+  TextureManagerTest() : feature_info_(new FeatureInfo()) {}
 
   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(), "");
+    manager_.reset(new TextureManager(NULL,
+                                      feature_info_.get(),
+                                      kMaxTextureSize,
+                                      kMaxCubeMapTextureSize,
+                                      kUseDefaultTextures));
+    TestHelper::SetupTextureManagerInitExpectations(
+        gl_.get(), "", kUseDefaultTextures);
     manager_->Initialize();
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
   }
 
   virtual void TearDown() {
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::MockGLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
@@ skipping 78 matching lines @@
   SetParameter(
       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, UseDefaultTexturesTrue) {
+  bool use_default_textures = true;
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
+
+  TestHelper::SetupTextureManagerInitExpectations(
+      gl_.get(), "GL_ANGLE_texture_usage", use_default_textures);
+  TextureManager manager(NULL,
+                         feature_info_.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         use_default_textures);
+  manager.Initialize();
+
+  EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) != NULL);
+  EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) != NULL);
+
+  // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
+
+  manager.Destroy(false);
+}
+
+TEST_F(TextureManagerTest, UseDefaultTexturesFalse) {
+  bool use_default_textures = false;
+  TestHelper::SetupTextureManagerInitExpectations(
+      gl_.get(), "GL_ANGLE_texture_usage", use_default_textures);
+  TextureManager manager(NULL,
+                         feature_info_.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         use_default_textures);
+  manager.Initialize();
+
+  EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_2D) == NULL);
+  EXPECT_TRUE(manager.GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP) == NULL);
+
+  // TODO(vmiura): Test GL_TEXTURE_EXTERNAL_OES & GL_TEXTURE_RECTANGLE_ARB.
+
+  manager.Destroy(false);
+}
+
 TEST_F(TextureManagerTest, TextureUsageExt) {
-  TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
-                                                  "GL_ANGLE_texture_usage");
-  TextureManager manager(
-      NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TestHelper::SetupTextureManagerInitExpectations(
+      gl_.get(), "GL_ANGLE_texture_usage", kUseDefaultTextures);
+  TextureManager manager(NULL,
+                         feature_info_.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   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(), "");
-  TextureManager manager(
-      NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TestHelper::SetupTextureManagerInitExpectations(
+      gl_.get(), "", kUseDefaultTextures);
+  TextureManager manager(NULL,
+                         feature_info_.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   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(), "", kUseDefaultTextures);
   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 100 matching lines @@
         (kMaxCubeMapTextureSize >> level) * 2,
         1));
   }
 }
 
 TEST_F(TextureManagerTest, ValidForTargetNPOT) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-     NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   // Check NPOT width on level 0
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1));
   // Check NPOT height on level 0
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1));
   // Check NPOT width on level 1
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1));
   // Check NPOT height on level 1
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 2, 5, 1));
   manager.Destroy(false);
 }
 
 class TextureTestBase : public testing::Test {
  public:
   static const GLint kMaxTextureSize = 16;
   static const GLint kMaxCubeMapTextureSize = 8;
   static const GLint kMax2dLevels = 5;
   static const GLint kMaxCubeMapLevels = 4;
   static const GLuint kClient1Id = 1;
   static const GLuint kService1Id = 11;
+  static const bool kUseDefaultTextures = false;
 
   TextureTestBase()
       : feature_info_(new FeatureInfo()) {
   }
   virtual ~TextureTestBase() {
     texture_ref_ = NULL;
   }
 
  protected:
   void SetUpBase(MemoryTracker* memory_tracker, std::string extensions) {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::MockGLInterface::SetGLInterface(gl_.get());
 
     if (!extensions.empty()) {
       TestHelper::SetupFeatureInfoInitExpectations(gl_.get(),
                                                    extensions.c_str());
       feature_info_->Initialize();
     }
 
-    manager_.reset(new TextureManager(
-        memory_tracker, feature_info_.get(),
-        kMaxTextureSize, kMaxCubeMapTextureSize));
+    manager_.reset(new TextureManager(memory_tracker,
+                                      feature_info_.get(),
+                                      kMaxTextureSize,
+                                      kMaxCubeMapTextureSize,
+                                      kUseDefaultTextures));
     decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
     manager_->CreateTexture(kClient1Id, kService1Id);
     texture_ref_ = manager_->GetTexture(kClient1Id);
     ASSERT_TRUE(texture_ref_.get() != NULL);
   }
 
   virtual void TearDown() {
     if (texture_ref_.get()) {
       // If it's not in the manager then setting texture_ref_ to NULL will
@@ skipping 413 matching lines @@
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_.get()));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureTest, NPOT2DNPOTOK) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
 
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
   manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
@@ skipping 266 matching lines @@
   manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_UNSIGNED_BYTE));
 }
 
 TEST_F(TextureTest, FloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager,
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, FloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, HalfFloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager,
       texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameteriWithExpectations(
       gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, HalfFloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, EGLImageExternal) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_EGL_image_external");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
   EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, DepthTexture) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_ANGLE_depth_texture");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize();
-  TextureManager manager(
-      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
+  TextureManager manager(NULL,
+                         feature_info.get(),
+                         kMaxTextureSize,
+                         kMaxCubeMapTextureSize,
+                         kUseDefaultTextures);
   manager.CreateTexture(kClient1Id, kService1Id);
   TextureRef* texture_ref = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
   manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   manager.SetLevelInfo(
       texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
       GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
   EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
@@ skipping 912 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()) {
-  }
+  static const bool kUseDefaultTextures = false;
+
+  SharedTextureTest() : feature_info_(new FeatureInfo()) {}
 
   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));
+                           TextureManagerTest::kMaxCubeMapTextureSize,
+                           kUseDefaultTextures));
     memory_tracker2_ = new CountingMemoryTracker;
     texture_manager2_.reset(
         new TextureManager(memory_tracker2_.get(),
                            feature_info_.get(),
                            TextureManagerTest::kMaxTextureSize,
-                           TextureManagerTest::kMaxCubeMapTextureSize));
-    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+                           TextureManagerTest::kMaxCubeMapTextureSize,
+                           kUseDefaultTextures));
+    TestHelper::SetupTextureManagerInitExpectations(
+        gl_.get(), "", kUseDefaultTextures);
     texture_manager1_->Initialize();
-    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+    TestHelper::SetupTextureManagerInitExpectations(
+        gl_.get(), "", kUseDefaultTextures);
     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();
@@ skipping 273 matching lines @@
 
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
       .Times(1)
       .RetiresOnSaturation();
   texture_manager1_->RemoveTexture(10);
   texture_manager2_->RemoveTexture(20);
 }
 
 }  // namespace gles2
 }  // namespace gpu