Initialize default texture for GL_TEXTURE_3D and GL_TEXTURE_2D_ARRAY

gpu/command_buffer/service/texture_manager.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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 1395 matching lines @@
 bool TextureManager::Initialize() {
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
   // resources and all contexts that share resource share the same default
   // texture.
   default_textures_[kTexture2D] = CreateDefaultAndBlackTextures(
       GL_TEXTURE_2D, &black_texture_ids_[kTexture2D]);
   default_textures_[kCubeMap] = CreateDefaultAndBlackTextures(
       GL_TEXTURE_CUBE_MAP, &black_texture_ids_[kCubeMap]);
 
+  if (feature_info_->IsES3Capable()) {

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

IsES3Enabled(). Otherwise we are still emulating ES2 behaviors in command buffer
and there is no need to deal with 3D textures.

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

Done.

+    default_textures_[kTexture3D] = CreateDefaultAndBlackTextures(
+        GL_TEXTURE_3D, &black_texture_ids_[kTexture3D]);
+    default_textures_[kTexture2DArray] = CreateDefaultAndBlackTextures(
+        GL_TEXTURE_2D_ARRAY, &black_texture_ids_[kTexture2DArray]);
+  }
+
   if (feature_info_->feature_flags().oes_egl_image_external) {
     default_textures_[kExternalOES] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_EXTERNAL_OES, &black_texture_ids_[kExternalOES]);
   }
 
   if (feature_info_->feature_flags().arb_texture_rectangle) {
     default_textures_[kRectangleARB] = CreateDefaultAndBlackTextures(
         GL_TEXTURE_RECTANGLE_ARB, &black_texture_ids_[kRectangleARB]);
   }
 
@@ skipping 10 matching lines @@
 scoped_refptr<TextureRef>
     TextureManager::CreateDefaultAndBlackTextures(
         GLenum target,
         GLuint* black_texture) {
   static uint8 black[] = {0, 0, 0, 255};
 
   // Sampling a texture not associated with any EGLImage sibling will return
   // black values according to the spec.
   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);
 
   // Make default textures and texture for replacing non-renderable textures.
   GLuint ids[2];
   const int num_ids = use_default_textures_ ? 2 : 1;
   glGenTextures(num_ids, ids);
   for (int ii = 0; ii < num_ids; ++ii) {
     glBindTexture(target, ids[ii]);
     if (needs_initialization) {
       if (needs_faces) {
         for (int jj = 0; jj < GLES2Util::kNumFaces; ++jj) {
           glTexImage2D(GLES2Util::IndexToGLFaceTarget(jj), 0, GL_RGBA, 1, 1, 0,
                        GL_RGBA, GL_UNSIGNED_BYTE, black);
         }
       } else {
-        glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
-                     GL_UNSIGNED_BYTE, black);
+        if (is_3d_or_2d_array_target) {
+          glTexImage3D(target, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA,
+                       GL_UNSIGNED_BYTE, black);
+        } else {
+          glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
+                       GL_UNSIGNED_BYTE, black);
+        }
       }
     }
   }
   glBindTexture(target, 0);
 
   scoped_refptr<TextureRef> default_texture;
   if (use_default_textures_) {
     default_texture = TextureRef::Create(this, 0, ids[1]);
     SetTarget(default_texture.get(), target);
     if (needs_faces) {
@@ skipping 723 matching lines @@
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
 
   // Dump all sub-levels held by the texture. They will appear below the main
   // gl/textures/client_X/texture_Y dump.
   ref->texture()->DumpLevelMemory(pmd, memory_tracker_->ClientTracingId(),
                                   dump_name);
 }
 
 }  // namespace gles2
 }  // namespace gpu