Minor improvement in uniform block backing buffer validation.

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 8681 matching lines @@
   if (!framebuffer->ValidateAndAdjustDrawBuffers(
       fragment_output_type_mask, fragment_output_written_mask)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
           "buffer format and fragment output variable type incompatible");
       return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::ValidateUniformBlockBackings(const char* func_name) {
-  if (feature_info_->IsWebGL1OrES2Context()) {
-    // Uniform blocks do not exist in ES2 contexts.
+  DCHECK(feature_info_->IsWebGL1OrES2Context());

[piman, 2016/11/01 22:26:39]

Did you mean DCHECK(feature_info_->IsWebGL2OrES3Context()) ?

[Zhenyao Mo, 2016/11/01 22:33:40]

Right. Thanks for catching this.

Let's see if any tests crash. I am sure they will.  If not, I'll look into
adding tests to catch this before landing.

+  DCHECK(state_.current_program.get());
+  int32_t max_index = -1;
+  for (auto info : state_.current_program->uniform_block_size_info()) {
+    int32_t index = static_cast<int32_t>(info.binding);
+    if (index > max_index)
+      max_index = index;
+  }
+  if (max_index < 0)
     return true;
+  std::vector<GLsizeiptr> uniform_block_sizes(max_index + 1);
+  for (int32_t ii = 0; ii <= max_index; ++ii)
+    uniform_block_sizes[ii] = 0;
+  for (auto info : state_.current_program->uniform_block_size_info()) {
+    uint32_t index = info.binding;
+    uniform_block_sizes[index] =
+        state_.indexed_uniform_buffer_bindings->GetEffectiveBufferSize(index);
   }
-  DCHECK(state_.current_program.get());
-  for (auto info : state_.current_program->uniform_block_size_info()) {
-    uint32_t buffer_size = static_cast<uint32_t>(
-        state_.indexed_uniform_buffer_bindings->GetEffectiveBufferSize(
-            info.binding));
-    if (info.data_size > buffer_size) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
-          "uniform blocks are not backed by a buffer with sufficient data");
-      return false;
-    }
-  }
-  return true;
+  return buffer_manager()->RequestBuffersAccess(
+      state_.GetErrorState(), state_.indexed_uniform_buffer_bindings.get(),
+      uniform_block_sizes, 1, func_name, "uniform buffers");
 }
 
 bool GLES2DecoderImpl::CheckUniformForApiType(
     const Program::UniformInfo* info,
     const char* function_name,
     Program::UniformApiType api_type) {
   DCHECK(info);
   if ((api_type & info->accepts_api_type) == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "wrong uniform function for type");
@@ skipping 1090 matching lines @@
       if (!buffer_manager()->RequestBuffersAccess(
               state_.GetErrorState(),
               state_.bound_transform_feedback.get(),
               state_.current_program->GetTransformFeedbackVaryingSizes(),
               count,
               function_name,
               "transformfeedback buffers")) {
         return error::kNoError;
       }
     }
+
+    if (!ValidateUniformBlockBackings(function_name)) {
+      return error::kNoError;
+    }
   }
 
   if (count == 0 || primcount == 0) {
     LOCAL_RENDER_WARNING("Render count or primcount is 0.");
     return error::kNoError;
   }
 
   base::CheckedNumeric<GLuint> checked_max_vertex = first;
   checked_max_vertex += count - 1;
   // first and count-1 are both a non-negative int, so their sum fits an
@@ skipping 16 matching lines @@
     }
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(
         function_name, max_vertex_accessed, &simulated_fixed_attribs,
         primcount)) {
       bool textures_set = !PrepareTexturesForRender();
       ApplyDirtyState();
       if (!ValidateAndAdjustDrawBuffers(function_name)) {
         return error::kNoError;
       }
-      if (!ValidateUniformBlockBackings(function_name)) {
-        return error::kNoError;
-      }
       if (!instanced) {
         glDrawArrays(mode, first, count);
       } else {
         glDrawArraysInstancedANGLE(mode, first, count, primcount);
       }
       if (textures_set) {
         RestoreStateForTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
@@ skipping 81 matching lines @@
   }
 
   if (state_.bound_transform_feedback.get() &&
       state_.bound_transform_feedback->active() &&
       !state_.bound_transform_feedback->paused()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
         "transformfeedback is active and not paused");
     return error::kNoError;
   }
 
-  if (count == 0 || primcount == 0) {
-    return error::kNoError;
-  }
-
   if (feature_info_->IsWebGL2OrES3Context()) {
     if (!AttribsTypeMatch()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                          "vertexAttrib function must match shader attrib type");
       return error::kNoError;
     }
+    if (!ValidateUniformBlockBackings(function_name)) {
+      return error::kNoError;
+    }
+  }
+
+  if (count == 0 || primcount == 0) {
+    return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
   if (!element_array_buffer->GetMaxValueForRange(
           offset, count, type,
           state_.enable_flags.primitive_restart_fixed_index,
           &max_vertex_accessed)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "range out of bounds for buffer");
     return error::kNoError;
@@ skipping 20 matching lines @@
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       bool used_client_side_array = false;
       if (element_array_buffer->IsClientSideArray()) {
         used_client_side_array = true;
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
         indices = element_array_buffer->GetRange(offset, 0);
       }
       if (!ValidateAndAdjustDrawBuffers(function_name)) {
         return error::kNoError;
       }
-      if (!ValidateUniformBlockBackings(function_name)) {
-        return error::kNoError;
-      }
       if (state_.enable_flags.primitive_restart_fixed_index &&
           feature_info_->feature_flags().
               emulate_primitive_restart_fixed_index) {
         glEnable(GL_PRIMITIVE_RESTART);
         buffer_manager()->SetPrimitiveRestartFixedIndexIfNecessary(type);
       }
       if (!instanced) {
         glDrawElements(mode, count, type, indices);
       } else {
         glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
@@ skipping 8739 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu