Initialize default texture for GL_TEXTURE_3D and GL_TEXTURE_2D_ARRAY

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 40 matching lines @@
   var.mappedName = name;  // No name hashing.
   return var;
 }
 
 }  // namespace anonymous
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLuint TestHelper::kServiceBlackTexture2dId;
 const GLuint TestHelper::kServiceDefaultTexture2dId;
+const GLuint TestHelper::kServiceBlackTexture3dId;
+const GLuint TestHelper::kServiceDefaultTexture3dId;
+const GLuint TestHelper::kServiceBlackTexture2dArrayId;
+const GLuint TestHelper::kServiceDefaultTexture2dArrayId;
 const GLuint TestHelper::kServiceBlackTextureCubemapId;
 const GLuint TestHelper::kServiceDefaultTextureCubemapId;
 const GLuint TestHelper::kServiceBlackExternalTextureId;
 const GLuint TestHelper::kServiceDefaultExternalTextureId;
 const GLuint TestHelper::kServiceBlackRectangleTextureId;
 const GLuint TestHelper::kServiceDefaultRectangleTextureId;
 
 const GLint TestHelper::kMaxSamples;
 const GLint TestHelper::kMaxRenderbufferSize;
 const GLint TestHelper::kMaxTextureSize;
@@ skipping 15 matching lines @@
 std::vector<std::string> TestHelper::split_extensions_;
 
 void TestHelper::SetupTextureInitializationExpectations(
     ::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);
+  bool is_3d_or_2d_array_target = (target == GL_TEXTURE_3D ||
+      target == GL_TEXTURE_2D_ARRAY);
 
   static GLuint texture_2d_ids[] = {
     kServiceBlackTexture2dId,
     kServiceDefaultTexture2dId };
+  static GLuint texture_3d_ids[] = {
+    kServiceBlackTexture3dId,
+    kServiceDefaultTexture3dId };
+  static GLuint texture_2d_array_ids[] = {
+    kServiceBlackTexture2dArrayId,
+    kServiceDefaultTexture2dArrayId };
   static GLuint texture_cube_map_ids[] = {
     kServiceBlackTextureCubemapId,
     kServiceDefaultTextureCubemapId };
   static GLuint texture_external_oes_ids[] = {
     kServiceBlackExternalTextureId,
     kServiceDefaultExternalTextureId };
   static GLuint texture_rectangle_arb_ids[] = {
     kServiceBlackRectangleTextureId,
     kServiceDefaultRectangleTextureId };
 
   const GLuint* texture_ids = NULL;
   switch (target) {
     case GL_TEXTURE_2D:
       texture_ids = &texture_2d_ids[0];
       break;
+    case GL_TEXTURE_3D:
+      texture_ids = &texture_3d_ids[0];
+      break;
+    case GL_TEXTURE_2D_ARRAY:
+      texture_ids = &texture_2d_array_ids[0];
+      break;
     case GL_TEXTURE_CUBE_MAP:
       texture_ids = &texture_cube_map_ids[0];
       break;
     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:
@@ skipping 20 matching lines @@
           GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
           GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
         };
         for (size_t ii = 0; ii < arraysize(faces); ++ii) {
           EXPECT_CALL(*gl, TexImage2D(faces[ii], 0, GL_RGBA, 1, 1, 0, GL_RGBA,
                                       GL_UNSIGNED_BYTE, _))
               .Times(1)
               .RetiresOnSaturation();
         }
       } else {
-        EXPECT_CALL(*gl, TexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
-                                    GL_UNSIGNED_BYTE, _))
-            .Times(1)
-            .RetiresOnSaturation();
+        if (is_3d_or_2d_array_target) {
+          EXPECT_CALL(*gl, TexImage3D(target, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA,
+                                      GL_UNSIGNED_BYTE, _))
+              .Times(1)
+              .RetiresOnSaturation();
+        } else {
+          EXPECT_CALL(*gl, TexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
+                                      GL_UNSIGNED_BYTE, _))
+              .Times(1)
+              .RetiresOnSaturation();
+        }
       }
     }
   }
   EXPECT_CALL(*gl, BindTexture(target, 0))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupTextureManagerInitExpectations(
     ::gfx::MockGLInterface* gl,
+    bool is_es3_enabled,
     const char* extensions,
     bool use_default_textures) {
   InSequence sequence;
 
   SetupTextureInitializationExpectations(
       gl, GL_TEXTURE_2D, use_default_textures);
   SetupTextureInitializationExpectations(
       gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
+  if (is_es3_enabled) {
+    SetupTextureInitializationExpectations(
+        gl, GL_TEXTURE_3D, use_default_textures);
+    SetupTextureInitializationExpectations(
+        gl, GL_TEXTURE_2D_ARRAY, 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;
@@ skipping 16 matching lines @@
     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_3D:
+      texture_id = kServiceDefaultTexture3dId;
+      break;
+    case GL_TEXTURE_2D_ARRAY:
+      texture_id = kServiceDefaultTexture2dArrayId;
+      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,
+    bool is_es3_enabled,
     const char* extensions,
     bool use_default_textures) {
   SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D, use_default_textures);
   SetupTextureDestructionExpectations(
       gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
+  if (is_es3_enabled) {
+    SetupTextureDestructionExpectations(
+        gl, GL_TEXTURE_3D, use_default_textures);
+    SetupTextureDestructionExpectations(
+        gl, GL_TEXTURE_2D_ARRAY,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, use_default_textures);
   }
   if (arb_texture_rectangle) {
     SetupTextureDestructionExpectations(
         gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures);
   }
 
-  EXPECT_CALL(*gl, DeleteTextures(4, _))
+  EXPECT_CALL(*gl, DeleteTextures(TextureManager::kNumDefaultTextures, _))
       .Times(1)
       .RetiresOnSaturation();
 }
 
 void TestHelper::SetupContextGroupInitExpectations(
     ::gfx::MockGLInterface* gl,
     const DisallowedFeatures& disallowed_features,
     const char* extensions,
     const char* gl_version,
     bool bind_generates_resource) {
@@ skipping 62 matching lines @@
         .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();
   }
 
   bool use_default_textures = bind_generates_resource;
-  SetupTextureManagerInitExpectations(gl, extensions, use_default_textures);
+  SetupTextureManagerInitExpectations(
+      gl, false, 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 541 matching lines @@
   gfx::SetGLImplementation(implementation);
 }
 
 ScopedGLImplementationSetter::~ScopedGLImplementationSetter() {
   gfx::SetGLImplementation(old_implementation_);
 }
 
 }  // namespace gles2
 }  // namespace gpu