Fix a bug in texture validation.

gpu/command_buffer/service/context_group.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/context_group.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 95 matching lines @@
       mailbox_manager_ = new MailboxManagerImpl;
     transfer_buffer_manager_ = new TransferBufferManager(memory_tracker_.get());
   }
 }
 
 bool ContextGroup::Initialize(GLES2Decoder* decoder,
                               ContextType context_type,
                               const DisallowedFeatures& disallowed_features) {
   if (HaveContexts()) {
     if (context_type != feature_info_->context_type()) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because the type of "
-                 << "the context does not fit with the group.";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because the type of "
+                  << "the context does not fit with the group.";
       return false;
     }
     // If we've already initialized the group just add the context.
     decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder));
     return true;
   }
 
   DisallowedFeatures adjusted_disallowed_features =
       AdjustDisallowedFeatures(context_type, disallowed_features);
 
   if (!feature_info_->Initialize(context_type, adjusted_disallowed_features)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because FeatureInfo "
-               << "initialization failed.";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because FeatureInfo "
+                << "initialization failed.";
     return false;
   }
 
   transfer_buffer_manager_->Initialize();
 
   const GLint kMinRenderbufferSize = 512;  // GL says 1 pixel!
   GLint max_renderbuffer_size = 0;
   if (!QueryGLFeature(
       GL_MAX_RENDERBUFFER_SIZE, kMinRenderbufferSize,
       &max_renderbuffer_size)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-               << "renderbuffer size too small (" << max_renderbuffer_size
-               << ", should be " << kMinRenderbufferSize << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                << "renderbuffer size too small (" << max_renderbuffer_size
+                << ", should be " << kMinRenderbufferSize << ").";
     return false;
   }
   GLint max_samples = 0;
   if (feature_info_->feature_flags().chromium_framebuffer_multisample ||
       feature_info_->feature_flags().multisampled_render_to_texture) {
     if (feature_info_->feature_flags(
             ).use_img_for_multisampled_render_to_texture) {
       glGetIntegerv(GL_MAX_SAMPLES_IMG, &max_samples);
     } else {
       glGetIntegerv(GL_MAX_SAMPLES, &max_samples);
@@ skipping 12 matching lines @@
     GetIntegerv(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT,
                 &max_dual_source_draw_buffers_);
     DCHECK(max_dual_source_draw_buffers_ >= 1);
   }
 
   if (feature_info_->gl_version_info().IsES3Capable()) {
     const GLint kMinTransformFeedbackSeparateAttribs = 4;
     if (!QueryGLFeatureU(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
                          kMinTransformFeedbackSeparateAttribs,
                          &max_transform_feedback_separate_attribs_)) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-                 << "transform feedback separate attribs is too small ("
-                 << max_transform_feedback_separate_attribs_ << ", should be "
-                 << kMinTransformFeedbackSeparateAttribs << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                  << "transform feedback separate attribs is too small ("
+                  << max_transform_feedback_separate_attribs_ << ", should be "
+                  << kMinTransformFeedbackSeparateAttribs << ").";
       return false;
     }
 
     const GLint kMinUniformBufferBindings = 24;
     if (!QueryGLFeatureU(GL_MAX_UNIFORM_BUFFER_BINDINGS,
                          kMinUniformBufferBindings,
                          &max_uniform_buffer_bindings_)) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-                 << "uniform buffer bindings is too small ("
-                 << max_uniform_buffer_bindings_ << ", should be "
-                 << kMinUniformBufferBindings << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                  << "uniform buffer bindings is too small ("
+                  << max_uniform_buffer_bindings_ << ", should be "
+                  << kMinUniformBufferBindings << ").";
       return false;
     }
 
     // TODO(zmo): Should we check max UNIFORM_BUFFER_OFFSET_ALIGNMENT is 256?
     GetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT,
                 &uniform_buffer_offset_alignment_);
   }
 
   buffer_manager_.reset(
       new BufferManager(memory_tracker_.get(), feature_info_.get()));
   framebuffer_manager_.reset(new FramebufferManager(
       max_draw_buffers_, max_color_attachments_, feature_info_->context_type(),
       framebuffer_completeness_cache_));
   renderbuffer_manager_.reset(new RenderbufferManager(
       memory_tracker_.get(), max_renderbuffer_size, max_samples,
       feature_info_.get()));
   shader_manager_.reset(new ShaderManager());
   sampler_manager_.reset(new SamplerManager(feature_info_.get()));
 
   // Lookup GL things we need to know.
   const GLint kGLES2RequiredMinimumVertexAttribs = 8u;
   if (!QueryGLFeatureU(
       GL_MAX_VERTEX_ATTRIBS, kGLES2RequiredMinimumVertexAttribs,
       &max_vertex_attribs_)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because too few "
-               << "vertex attributes supported (" << max_vertex_attribs_
-               << ", should be " << kGLES2RequiredMinimumVertexAttribs << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
+                << "vertex attributes supported (" << max_vertex_attribs_
+                << ", should be " << kGLES2RequiredMinimumVertexAttribs << ").";
     return false;
   }
 
   const GLuint kGLES2RequiredMinimumTextureUnits = 8u;
   if (!QueryGLFeatureU(
       GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, kGLES2RequiredMinimumTextureUnits,
       &max_texture_units_)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because too few "
-               << "texture units supported (" << max_texture_units_
-               << ", should be " << kGLES2RequiredMinimumTextureUnits << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
+                << "texture units supported (" << max_texture_units_
+                << ", should be " << kGLES2RequiredMinimumTextureUnits << ").";
     return false;
   }
 
   GLint max_texture_size = 0;
   GLint max_cube_map_texture_size = 0;
   GLint max_rectangle_texture_size = 0;
   GLint max_3d_texture_size = 0;
+  GLint max_array_texture_layers = 0;
 
   const GLint kMinTextureSize = 2048;  // GL actually says 64!?!?
   const GLint kMinCubeMapSize = 256;  // GL actually says 16!?!?
   const GLint kMinRectangleTextureSize = 64;
   const GLint kMin3DTextureSize = 256;
+  const GLint kMinArrayTextureLayers = 256;
 
   if (!QueryGLFeature(GL_MAX_TEXTURE_SIZE, kMinTextureSize,
                       &max_texture_size)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-               << "2d texture size is too small (" << max_texture_size
-               << ", should be " << kMinTextureSize << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                << "2d texture size is too small (" << max_texture_size
+                << ", should be " << kMinTextureSize << ").";
     return false;
   }
   if (!QueryGLFeature(GL_MAX_CUBE_MAP_TEXTURE_SIZE, kMinCubeMapSize,
                       &max_cube_map_texture_size)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-               << "cube texture size is too small ("
-               << max_cube_map_texture_size << ", should be " << kMinCubeMapSize
-               << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                << "cube texture size is too small ("
+                << max_cube_map_texture_size << ", should be "
+                << kMinCubeMapSize << ").";
     return false;
   }
   if (feature_info_->gl_version_info().IsES3Capable() &&
       !QueryGLFeature(GL_MAX_3D_TEXTURE_SIZE, kMin3DTextureSize,
                       &max_3d_texture_size)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-               << "3d texture size is too small (" << max_3d_texture_size
-               << ", should be " << kMin3DTextureSize << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                << "3d texture size is too small (" << max_3d_texture_size
+                << ", should be " << kMin3DTextureSize << ").";
+    return false;
+  }
+  if (feature_info_->gl_version_info().IsES3Capable() &&
+      !QueryGLFeature(GL_MAX_ARRAY_TEXTURE_LAYERS, kMinArrayTextureLayers,
+                      &max_array_texture_layers)) {
+    DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                << "array texture layers is too small ("
+                << max_array_texture_layers
+                << ", should be " << kMinArrayTextureLayers << ").";
     return false;
   }
   if (feature_info_->feature_flags().arb_texture_rectangle &&
       !QueryGLFeature(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB,
                       kMinRectangleTextureSize, &max_rectangle_texture_size)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-               << "rectangle texture size is too small ("
-               << max_rectangle_texture_size << ", should be "
-               << kMinRectangleTextureSize << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                << "rectangle texture size is too small ("
+                << max_rectangle_texture_size << ", should be "
+                << kMinRectangleTextureSize << ").";
     return false;
   }
 
   if (feature_info_->workarounds().max_texture_size) {
     max_texture_size = std::min(
         max_texture_size,
         feature_info_->workarounds().max_texture_size);
     max_rectangle_texture_size = std::min(
         max_rectangle_texture_size,
         feature_info_->workarounds().max_texture_size);
   }
   if (feature_info_->workarounds().max_cube_map_texture_size) {
     max_cube_map_texture_size = std::min(
         max_cube_map_texture_size,
         feature_info_->workarounds().max_cube_map_texture_size);
   }
 
   texture_manager_.reset(new TextureManager(memory_tracker_.get(),
                                             feature_info_.get(),
                                             max_texture_size,
                                             max_cube_map_texture_size,
                                             max_rectangle_texture_size,
                                             max_3d_texture_size,
+                                            max_array_texture_layers,
                                             bind_generates_resource_));
   texture_manager_->set_framebuffer_manager(framebuffer_manager_.get());
 
   const GLint kMinTextureImageUnits = 8;
   const GLint kMinVertexTextureImageUnits = 0;
   if (!QueryGLFeatureU(GL_MAX_TEXTURE_IMAGE_UNITS, kMinTextureImageUnits,
                        &max_texture_image_units_)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because too few "
-               << "texture image units supported (" << max_texture_image_units_
-               << ", should be " << kMinTextureImageUnits << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
+                << "texture image units supported ("
+                << max_texture_image_units_
+                << ", should be " << kMinTextureImageUnits << ").";
   }
   if (!QueryGLFeatureU(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
                        kMinVertexTextureImageUnits,
                        &max_vertex_texture_image_units_)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because too few "
-               << "vertex texture image units supported ("
-               << max_vertex_texture_image_units_ << ", should be "
-               << kMinTextureImageUnits << ").";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
+                << "vertex texture image units supported ("
+                << max_vertex_texture_image_units_ << ", should be "
+                << kMinTextureImageUnits << ").";
     return false;
   }
 
   if (feature_info_->gl_version_info().BehavesLikeGLES()) {
     GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS,
         &max_fragment_uniform_vectors_);
     GetIntegerv(GL_MAX_VARYING_VECTORS, &max_varying_vectors_);
     GetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &max_vertex_uniform_vectors_);
   } else {
     GetIntegerv(
         GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max_fragment_uniform_vectors_);
     max_fragment_uniform_vectors_ /= 4;
     GetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_vectors_);
     max_varying_vectors_ /= 4;
     GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, &max_vertex_uniform_vectors_);
     max_vertex_uniform_vectors_ /= 4;
   }
 
   const GLint kMinFragmentUniformVectors = 16;
   const GLint kMinVaryingVectors = 8;
   const GLint kMinVertexUniformVectors = 128;
   if (!CheckGLFeatureU(
       kMinFragmentUniformVectors, &max_fragment_uniform_vectors_) ||
       !CheckGLFeatureU(kMinVaryingVectors, &max_varying_vectors_) ||
       !CheckGLFeatureU(
       kMinVertexUniformVectors, &max_vertex_uniform_vectors_)) {
-    LOG(ERROR) << "ContextGroup::Initialize failed because too few "
-               << "uniforms or varyings supported.";
+    DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
+                << "uniforms or varyings supported.";
     return false;
   }
 
   // Some shaders in Skia need more than the min available vertex and
   // fragment shader uniform vectors in case of OSMesa GL Implementation
   if (feature_info_->workarounds().max_fragment_uniform_vectors) {
     max_fragment_uniform_vectors_ = std::min(
         max_fragment_uniform_vectors_,
         static_cast<uint32_t>(
             feature_info_->workarounds().max_fragment_uniform_vectors));
@@ skipping 14 matching lines @@
   if (context_type != CONTEXT_TYPE_WEBGL1 &&
       context_type != CONTEXT_TYPE_OPENGLES2) {
     const GLuint kMinVertexOutputComponents = 64;
     const GLuint kMinFragmentInputComponents = 60;
     const GLint kMin_MaxProgramTexelOffset = 7;
     const GLint kMax_MinProgramTexelOffset = -8;
 
     if (!QueryGLFeatureU(GL_MAX_VERTEX_OUTPUT_COMPONENTS,
                          kMinVertexOutputComponents,
                          &max_vertex_output_components_)) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-                 << "vertex output components is too small ("
-                 << max_vertex_output_components_ << ", should be "
-                 << kMinVertexOutputComponents << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                  << "vertex output components is too small ("
+                  << max_vertex_output_components_ << ", should be "
+                  << kMinVertexOutputComponents << ").";
       return false;
     }
     if (!QueryGLFeatureU(GL_MAX_FRAGMENT_INPUT_COMPONENTS,
                          kMinFragmentInputComponents,
                          &max_fragment_input_components_)) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-                 << "fragment input components is too small ("
-                 << max_fragment_input_components_ << ", should be "
-                 << kMinFragmentInputComponents << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                  << "fragment input components is too small ("
+                  << max_fragment_input_components_ << ", should be "
+                  << kMinFragmentInputComponents << ").";
       return false;
     }
     if (!QueryGLFeature(GL_MAX_PROGRAM_TEXEL_OFFSET, kMin_MaxProgramTexelOffset,
                         &max_program_texel_offset_)) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-                 << "program texel offset is too small ("
-                 << max_program_texel_offset_ << ", should be "
-                 << kMin_MaxProgramTexelOffset << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                  << "program texel offset is too small ("
+                  << max_program_texel_offset_ << ", should be "
+                  << kMin_MaxProgramTexelOffset << ").";
       return false;
     }
     glGetIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &min_program_texel_offset_);
     if (enforce_gl_minimums_) {
       min_program_texel_offset_ =
           std::max(min_program_texel_offset_, kMax_MinProgramTexelOffset);
     }
     if (min_program_texel_offset_ > kMax_MinProgramTexelOffset) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because minimum "
-                 << "program texel offset is too big ("
-                 << min_program_texel_offset_ << ", should be "
-                 << kMax_MinProgramTexelOffset << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because minimum "
+                  << "program texel offset is too big ("
+                  << min_program_texel_offset_ << ", should be "
+                  << kMax_MinProgramTexelOffset << ").";
       return false;
     }
 
     const GLint kES3MinCubeMapSize = 2048;
     if (max_cube_map_texture_size < kES3MinCubeMapSize) {
-      LOG(ERROR) << "ContextGroup::Initialize failed because maximum "
-                 << "cube texture size is too small ("
-                 << max_cube_map_texture_size << ", should be "
-                 << kES3MinCubeMapSize << ").";
+      DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
+                  << "cube texture size is too small ("
+                  << max_cube_map_texture_size << ", should be "
+                  << kES3MinCubeMapSize << ").";
       return false;
     }
   }
 
   path_manager_.reset(new PathManager());
 
   program_manager_.reset(
       new ProgramManager(program_cache_, max_varying_vectors_,
                          max_dual_source_draw_buffers_, gpu_preferences_,
                          feature_info_.get()));
 
   if (!texture_manager_->Initialize()) {
-    LOG(ERROR) << "Context::Group::Initialize failed because texture manager "
-               << "failed to initialize.";
+    DLOG(ERROR) << "Context::Group::Initialize failed because texture manager "
+                << "failed to initialize.";
     return false;
   }
 
   decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder));
   return true;
 }
 
 namespace {
 
 bool IsNull(const base::WeakPtr<gles2::GLES2Decoder>& decoder) {
@@ skipping 144 matching lines @@
     GLuint client_id, GLuint* service_id) const {
   Buffer* buffer = buffer_manager_->GetBuffer(client_id);
   if (!buffer)
     return false;
   *service_id = buffer->service_id();
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu