Revert of command buffer: audit validation of ES3 commands (part 1)

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 3517 matching lines @@
   DoGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
                 &caps.max_vertex_texture_image_units, 1);
   DoGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &caps.max_vertex_uniform_vectors,
                 1);
   DoGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS,
                 &caps.num_compressed_texture_formats, 1);
   DoGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &caps.num_shader_binary_formats,
                 1);
   DoGetIntegerv(GL_BIND_GENERATES_RESOURCE_CHROMIUM,
                 &caps.bind_generates_resource_chromium, 1);
-  if (feature_info_->IsWebGL2OrES3Context()) {
+  if (unsafe_es3_apis_enabled()) {
     // TODO(zmo): Note that some parameter values could be more than 32-bit,
     // but for now we clamp them to 32-bit max.
     DoGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &caps.max_3d_texture_size, 1);
     DoGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &caps.max_array_texture_layers,
                   1);
     DoGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &caps.max_color_attachments, 1);
     DoGetInteger64v(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS,
                     &caps.max_combined_fragment_uniform_components, 1);
     DoGetIntegerv(GL_MAX_COMBINED_UNIFORM_BLOCKS,
                   &caps.max_combined_uniform_blocks, 1);
@@ skipping 41 matching lines @@
     DoGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS,
                   &caps.num_program_binary_formats, 1);
     DoGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT,
                   &caps.uniform_buffer_offset_alignment, 1);
     // TODO(zmo): once we switch to MANGLE, we should query version numbers.
     caps.major_version = 3;
     caps.minor_version = 0;
   }
   if (feature_info_->feature_flags().multisampled_render_to_texture ||
       feature_info_->feature_flags().chromium_framebuffer_multisample ||
-      feature_info_->IsWebGL2OrES3Context()) {
+      unsafe_es3_apis_enabled()) {
     DoGetIntegerv(GL_MAX_SAMPLES, &caps.max_samples, 1);
   }
 
   caps.egl_image_external =
       feature_info_->feature_flags().oes_egl_image_external;
   caps.texture_format_astc =
       feature_info_->feature_flags().ext_texture_format_astc;
   caps.texture_format_atc =
       feature_info_->feature_flags().ext_texture_format_atc;
   caps.texture_format_bgra8888 =
@@ skipping 2605 matching lines @@
         }
         return true;
       case GL_MAX_VERTEX_UNIFORM_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_vertex_uniform_vectors();
         }
         return true;
       }
   }
-  if (feature_info_->IsWebGL2OrES3Context()) {
+  if (unsafe_es3_apis_enabled()) {
     switch (pname) {
       case GL_MAX_VARYING_COMPONENTS: {
         if (gl_version_info().is_es) {
           // We can just delegate this query to the driver.
           *num_written = 1;
           break;
         }
 
         // GL_MAX_VARYING_COMPONENTS is deprecated in the desktop
         // OpenGL core profile, so for simplicity, just compute it
@@ skipping 571 matching lines @@
   DoGetIntegerv(pname, values.get(), params_size);
   for (GLsizei ii = 0; ii < params_size; ++ii) {
     params[ii] = static_cast<GLfloat>(values[ii]);
   }
 }
 
 void GLES2DecoderImpl::DoGetInteger64v(GLenum pname,
                                        GLint64* params,
                                        GLsizei params_size) {
   DCHECK(params);
-  if (feature_info_->IsWebGL2OrES3Context()) {
+  if (unsafe_es3_apis_enabled()) {
     switch (pname) {
       case GL_MAX_ELEMENT_INDEX: {
         DCHECK_EQ(params_size, 1);
         if (gl_version_info().IsAtLeastGLES(3, 0) ||
             gl_version_info().IsAtLeastGL(4, 3)) {
           glGetInteger64v(GL_MAX_ELEMENT_INDEX, params);
         } else {
           // Assume that desktop GL implementations can generally support
           // 32-bit indices.
           if (params) {
@@ skipping 861 matching lines @@
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target,
     GLenum attachment,
     GLenum pname,
     GLint* params,
     GLsizei params_size) {
   const char kFunctionName[] = "glGetFramebufferAttachmentParameteriv";
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
-    if (!feature_info_->IsWebGL2OrES3Context()) {
+    if (!unsafe_es3_apis_enabled()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
           "no framebuffer bound");
       return;
     }
     if (!validators_->backbuffer_attachment.IsValid(attachment)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
           "invalid attachment for backbuffer");
       return;
     }
     switch (pname) {
@@ skipping 1319 matching lines @@
   }
   glUniform4uiv(real_location, count, const_cast<const GLuint*>(value));
 }
 
 void GLES2DecoderImpl::DoUniformMatrix2fv(GLint fake_location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (transpose && !feature_info_->IsWebGL2OrES3Context()) {
+  if (transpose && !unsafe_es3_apis_enabled()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose not FALSE");
     return;
   }
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix2fv",
                                    Program::kUniformMatrix2f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   glUniformMatrix2fv(real_location, count, transpose,
                      const_cast<const GLfloat*>(value));
 }
 
 void GLES2DecoderImpl::DoUniformMatrix3fv(GLint fake_location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (transpose && !feature_info_->IsWebGL2OrES3Context()) {
+  if (transpose && !unsafe_es3_apis_enabled()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose not FALSE");
     return;
   }
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix3fv",
                                    Program::kUniformMatrix3f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   glUniformMatrix3fv(real_location, count, transpose,
                      const_cast<const GLfloat*>(value));
 }
 
 void GLES2DecoderImpl::DoUniformMatrix4fv(GLint fake_location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
-  if (transpose && !feature_info_->IsWebGL2OrES3Context()) {
+  if (transpose && !unsafe_es3_apis_enabled()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose not FALSE");
     return;
   }
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix4fv",
                                    Program::kUniformMatrix4f,
                                    &real_location,
                                    &type,
                                    &count)) {
@@ skipping 1599 matching lines @@
   if (SetVertexAttribValue("glVertexAttribI4uiv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_UINT);
     glVertexAttribI4uiv(index, t);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribIPointer(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
-  if (!feature_info_->IsWebGL2OrES3Context())
+  if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const volatile gles2::cmds::VertexAttribIPointer& c =
       *static_cast<const volatile gles2::cmds::VertexAttribIPointer*>(cmd_data);
   GLuint indx = c.indx;
   GLint size = c.size;
   GLenum type = c.type;
   GLsizei stride = c.stride;
   GLsizei offset = c.offset;
 
   if (!state_.bound_array_buffer.get() ||
@@ skipping 1039 matching lines @@
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetBufferSubDataAsyncCHROMIUM(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
-  if (!feature_info_->IsWebGL2OrES3Context()) {
+  if (!unsafe_es3_apis_enabled()) {
     return error::kUnknownCommand;
   }
   const volatile gles2::cmds::GetBufferSubDataAsyncCHROMIUM& c =
       *static_cast<const volatile gles2::cmds::GetBufferSubDataAsyncCHROMIUM*>(
           cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
 
@@ skipping 81 matching lines @@
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformIndices(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
-  if (!feature_info_->IsWebGL2OrES3Context())
+  if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const volatile gles2::cmds::GetUniformIndices& c =
       *static_cast<const volatile gles2::cmds::GetUniformIndices*>(cmd_data);
   Bucket* bucket = GetBucket(c.names_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   GLsizei count = 0;
   std::vector<char*> names;
   std::vector<GLint> len;
@@ skipping 60 matching lines @@
     return error::kNoError;
   }
 
   *location = program->GetFragDataLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetFragDataLocation(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
-  if (!feature_info_->IsWebGL2OrES3Context())
+  if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const volatile gles2::cmds::GetFragDataLocation& c =
       *static_cast<const volatile gles2::cmds::GetFragDataLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
@@ skipping 47 matching lines @@
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetFragDataIndexHelper(c.program, c.index_shm_id, c.index_shm_offset,
                                 name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformBlockIndex(
     uint32_t immediate_data_size,
     const volatile void* cmd_data) {
-  if (!feature_info_->IsWebGL2OrES3Context())
+  if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const volatile gles2::cmds::GetUniformBlockIndex& c =
       *static_cast<const volatile gles2::cmds::GetUniformBlockIndex*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
@@ skipping 23 matching lines @@
   GLenum name = static_cast<GLenum>(c.name);
   if (!validators_->string_type.IsValid(name)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetString", name, "name");
     return error::kNoError;
   }
 
   const char* str = nullptr;
   std::string extensions;
   switch (name) {
     case GL_VERSION:
-      if (feature_info_->IsWebGL2OrES3Context())
+      if (unsafe_es3_apis_enabled())
         str = "OpenGL ES 3.0 Chromium";
       else
         str = "OpenGL ES 2.0 Chromium";
       break;
     case GL_SHADING_LANGUAGE_VERSION:
-      if (feature_info_->IsWebGL2OrES3Context())
+      if (unsafe_es3_apis_enabled())
         str = "OpenGL ES GLSL ES 3.0 Chromium";
       else
         str = "OpenGL ES GLSL ES 1.0 Chromium";
       break;
     case GL_RENDERER:
     case GL_VENDOR:
       // Return the unmasked VENDOR/RENDERER string for WebGL contexts.
       // They are used by WEBGL_debug_renderer_info.
       if (!feature_info_->IsWebGLContext())
         str = "Chromium";
@@ skipping 6682 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