Remove default textures in (!bind_generates_resource) context groups.

gpu/command_buffer/service/test_helper.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/test_helper.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
@@ skipping 43 matching lines @@
 const GLint TestHelper::kMaxVertexTextureImageUnits;
 const GLint TestHelper::kMaxFragmentUniformVectors;
 const GLint TestHelper::kMaxFragmentUniformComponents;
 const GLint TestHelper::kMaxVaryingVectors;
 const GLint TestHelper::kMaxVaryingFloats;
 const GLint TestHelper::kMaxVertexUniformVectors;
 const GLint TestHelper::kMaxVertexUniformComponents;
 #endif
 
 void TestHelper::SetupTextureInitializationExpectations(
-    ::gfx::MockGLInterface* gl, GLenum target) {
+    ::gfx::MockGLInterface* gl,
+    GLenum target,
+    bool use_default_textures) {
   InSequence sequence;
 
   bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
   bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
 
   static GLuint texture_2d_ids[] = {
     kServiceBlackTexture2dId,
     kServiceDefaultTexture2dId };
   static GLuint texture_cube_map_ids[] = {
     kServiceBlackTextureCubemapId,
@@ skipping 16 matching lines @@
     case GL_TEXTURE_EXTERNAL_OES:
       texture_ids = &texture_external_oes_ids[0];
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
       texture_ids = &texture_rectangle_arb_ids[0];
       break;
     default:
       NOTREACHED();
   }
 
-  int array_size = 2;
+  int array_size = use_default_textures ? 2 : 1;
 
   EXPECT_CALL(*gl, GenTextures(array_size, _))
       .WillOnce(SetArrayArgument<1>(texture_ids,
                                     texture_ids + array_size))
           .RetiresOnSaturation();
   for (int ii = 0; ii < array_size; ++ii) {
     EXPECT_CALL(*gl, BindTexture(target, texture_ids[ii]))
         .Times(1)
         .RetiresOnSaturation();
     if (needs_initialization) {
@@ skipping 20 matching lines @@
       }
     }
   }
   EXPECT_CALL(*gl, BindTexture(target, 0))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupTextureManagerInitExpectations(
     ::gfx::MockGLInterface* gl,
-    const char* extensions) {
+    const char* extensions,
+    bool use_default_textures) {
   InSequence sequence;
 
-  SetupTextureInitializationExpectations(gl, GL_TEXTURE_2D);
-  SetupTextureInitializationExpectations(gl, GL_TEXTURE_CUBE_MAP);
+  SetupTextureInitializationExpectations(
+      gl, GL_TEXTURE_2D, use_default_textures);
+  SetupTextureInitializationExpectations(
+      gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
   bool ext_image_external = false;
   bool arb_texture_rectangle = false;
   base::CStringTokenizer t(extensions, extensions + strlen(extensions), " ");
   while (t.GetNext()) {
     if (t.token() == "GL_OES_EGL_image_external") {
       ext_image_external = true;
       break;
     }
     if (t.token() == "GL_ARB_texture_rectangle") {
       arb_texture_rectangle = true;
       break;
     }
   }
 
   if (ext_image_external) {
-    SetupTextureInitializationExpectations(gl, GL_TEXTURE_EXTERNAL_OES);
+    SetupTextureInitializationExpectations(
+        gl, GL_TEXTURE_EXTERNAL_OES, use_default_textures);
   }
   if (arb_texture_rectangle) {
-    SetupTextureInitializationExpectations(gl, GL_TEXTURE_RECTANGLE_ARB);
+    SetupTextureInitializationExpectations(
+        gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures);
   }
 }
 
 void TestHelper::SetupTextureDestructionExpectations(
-    ::gfx::MockGLInterface* gl, GLenum target) {
+    ::gfx::MockGLInterface* gl,
+    GLenum target,
+    bool use_default_textures) {
+  if (!use_default_textures)
+    return;
+
   GLuint texture_id = 0;
   switch (target) {
     case GL_TEXTURE_2D:
       texture_id = kServiceDefaultTexture2dId;
       break;
     case GL_TEXTURE_CUBE_MAP:
       texture_id = kServiceDefaultTextureCubemapId;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
       texture_id = kServiceDefaultExternalTextureId;
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
       texture_id = kServiceDefaultRectangleTextureId;
       break;
     default:
       NOTREACHED();
   }
 
   EXPECT_CALL(*gl, DeleteTextures(1, Pointee(texture_id)))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupTextureManagerDestructionExpectations(
     ::gfx::MockGLInterface* gl,
-    const char* extensions) {
-  SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D);
-  SetupTextureDestructionExpectations(gl, GL_TEXTURE_CUBE_MAP);
+    const char* extensions,
+    bool use_default_textures) {
+  SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D, use_default_textures);
+  SetupTextureDestructionExpectations(
+      gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
   bool ext_image_external = false;
   bool arb_texture_rectangle = false;
   base::CStringTokenizer t(extensions, extensions + strlen(extensions), " ");
   while (t.GetNext()) {
     if (t.token() == "GL_OES_EGL_image_external") {
       ext_image_external = true;
       break;
     }
     if (t.token() == "GL_ARB_texture_rectangle") {
       arb_texture_rectangle = true;
       break;
     }
   }
 
   if (ext_image_external) {
-    SetupTextureDestructionExpectations(gl, GL_TEXTURE_EXTERNAL_OES);
+    SetupTextureDestructionExpectations(
+        gl, GL_TEXTURE_EXTERNAL_OES, use_default_textures);
   }
   if (arb_texture_rectangle) {
-    SetupTextureDestructionExpectations(gl, GL_TEXTURE_RECTANGLE_ARB);
+    SetupTextureDestructionExpectations(
+        gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures);
   }
 
   EXPECT_CALL(*gl, DeleteTextures(4, _))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupContextGroupInitExpectations(
-      ::gfx::MockGLInterface* gl,
-      const DisallowedFeatures& disallowed_features,
-      const char* extensions,
-      const char* gl_version) {
+    ::gfx::MockGLInterface* gl,
+    const DisallowedFeatures& disallowed_features,
+    const char* extensions,
+    const char* gl_version,
+    bool bind_generates_resource) {
   InSequence sequence;
 
   SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", gl_version);
 
   std::string l_version(StringToLowerASCII(std::string(gl_version)));
   bool is_es3 = (l_version.substr(0, 12) == "opengl es 3.");
 
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_RENDERBUFFER_SIZE, _))
       .WillOnce(SetArgumentPointee<1>(kMaxRenderbufferSize))
       .RetiresOnSaturation();
@@ skipping 28 matching lines @@
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, _))
       .WillOnce(SetArgumentPointee<1>(kMaxFragmentUniformComponents))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VARYING_FLOATS, _))
       .WillOnce(SetArgumentPointee<1>(kMaxVaryingFloats))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, _))
       .WillOnce(SetArgumentPointee<1>(kMaxVertexUniformComponents))
       .RetiresOnSaturation();
 
-  SetupTextureManagerInitExpectations(gl, extensions);
+  bool use_default_textures = bind_generates_resource;
+  SetupTextureManagerInitExpectations(gl, extensions, use_default_textures);
 }
 
 void TestHelper::SetupFeatureInfoInitExpectations(
       ::gfx::MockGLInterface* gl, const char* extensions) {
   SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", "");
 }
 
 void TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
      ::gfx::MockGLInterface* gl,
      const char* extensions,
@@ skipping 338 matching lines @@
   gfx::SetGLImplementation(implementation);
 }
 
 ScopedGLImplementationSetter::~ScopedGLImplementationSetter() {
   gfx::SetGLImplementation(old_implementation_);
 }
 
 }  // namespace gles2
 }  // namespace gpu