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,
+    const char* gl_version,
     const char* extensions,
     bool use_default_textures) {
   InSequence sequence;
 
+  gfx::GLVersionInfo gl_info(gl_version, "", extensions);
+
   SetupTextureInitializationExpectations(
       gl, GL_TEXTURE_2D, use_default_textures);
   SetupTextureInitializationExpectations(
       gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
+  if (gl_info.is_es3) {

[Zhenyao Mo, 2015/09/14 21:12:06]

This is also incorrect.  I assume you want to setup 3D texture stuff if ES3
support is enabled in command buffer, not the underlying driver is ES3.  Say you
are running on Linux desktop with GL 4.3, you may still want to handle 3D
textures if ES3 is enabled.

So I think you want to pass in a boolean (or enum) to control if you wanna
enable es3 or not.

[qiankun, 2015/09/15 09:14:59]

Done.

+    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,
+    const char* gl_version,

[Zhenyao Mo, 2015/09/14 21:12:06]

same here.

[qiankun, 2015/09/15 09:14:58]

Done.

     const char* extensions,
     bool use_default_textures) {
   SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D, use_default_textures);
   SetupTextureDestructionExpectations(
       gl, GL_TEXTURE_CUBE_MAP, use_default_textures);
 
+  gfx::GLVersionInfo gl_info(gl_version, "", extensions);
+
+  if (gl_info.is_es3) {
+    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(6, _))
       .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, gl_version, 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 520 matching lines @@
   gfx::SetGLImplementation(implementation);
 }
 
 ScopedGLImplementationSetter::~ScopedGLImplementationSetter() {
   gfx::SetGLImplementation(old_implementation_);
 }
 
 }  // namespace gles2
 }  // namespace gpu