Fix a bug in texture validation.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1687 matching lines @@
   texture_->RemoveTextureRef(this, manager_->have_context_);
   manager_ = NULL;
 }
 
 TextureManager::TextureManager(MemoryTracker* memory_tracker,
                                FeatureInfo* feature_info,
                                GLint max_texture_size,
                                GLint max_cube_map_texture_size,
                                GLint max_rectangle_texture_size,
                                GLint max_3d_texture_size,
+                               GLint max_array_texture_layers,
                                bool use_default_textures)
     : memory_type_tracker_(new MemoryTypeTracker(memory_tracker)),
       memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       framebuffer_manager_(NULL),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
       max_rectangle_texture_size_(max_rectangle_texture_size),
       max_3d_texture_size_(max_3d_texture_size),
+      max_array_texture_layers_(max_array_texture_layers),
       max_levels_(ComputeMipMapCount(GL_TEXTURE_2D,
                                      max_texture_size,
                                      max_texture_size,
-                                     max_texture_size)),
+                                     0)),
       max_cube_map_levels_(ComputeMipMapCount(GL_TEXTURE_CUBE_MAP,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size,
-                                              max_cube_map_texture_size)),
+                                              0)),
       max_3d_levels_(ComputeMipMapCount(GL_TEXTURE_3D,
                                         max_3d_texture_size,
                                         max_3d_texture_size,
                                         max_3d_texture_size)),
       use_default_textures_(use_default_textures),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       num_images_(0),
       texture_count_(0),
       have_context_(true),
@@ skipping 98 matching lines @@
       }
     }
   }
 
   *black_texture = ids[0];
   return default_texture;
 }
 
 bool TextureManager::ValidForTarget(
     GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth) {
+  if (level < 0 || level >= MaxLevelsForTarget(target))
+    return false;
   GLsizei max_size = MaxSizeForTarget(target) >> level;
-  return level >= 0 &&
-         width >= 0 &&
+  GLsizei max_depth =
+      (target == GL_TEXTURE_2D_ARRAY ? max_array_texture_layers() : max_size);
+  return width >= 0 &&
          height >= 0 &&
          depth >= 0 &&
-         level < MaxLevelsForTarget(target) &&
          width <= max_size &&
          height <= max_size &&
-         depth <= max_size &&
+         depth <= max_depth &&
          (level == 0 || feature_info_->feature_flags().npot_ok ||
           (!GLES2Util::IsNPOT(width) &&
            !GLES2Util::IsNPOT(height) &&
            !GLES2Util::IsNPOT(depth))) &&
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
   DCHECK(ref);
@@ skipping 1325 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu