Improve indexed gl state related GL commands.

gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

 // Copyright 2014 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.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 41 matching lines @@
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::BindBufferBase& c =
       *static_cast<const gles2::cmds::BindBufferBase*>(cmd_data);
   (void)c;
   GLenum target = static_cast<GLenum>(c.target);
   GLuint index = static_cast<GLuint>(c.index);
   GLuint buffer = c.buffer;
+  if (!validators_->indexed_buffer_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindBufferBase", target, "target");
+    return error::kNoError;
+  }
   DoBindBufferBase(target, index, buffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindBufferRange(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::BindBufferRange& c =
       *static_cast<const gles2::cmds::BindBufferRange*>(cmd_data);
   (void)c;
   GLenum target = static_cast<GLenum>(c.target);
   GLuint index = static_cast<GLuint>(c.index);
   GLuint buffer = c.buffer;
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
+  if (!validators_->indexed_buffer_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindBufferRange", target, "target");
+    return error::kNoError;
+  }
   DoBindBufferRange(target, index, buffer, offset, size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindFramebuffer(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindFramebuffer& c =
       *static_cast<const gles2::cmds::BindFramebuffer*>(cmd_data);
   (void)c;
@@ skipping 54 matching lines @@
 error::Error GLES2DecoderImpl::HandleBindTransformFeedback(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::BindTransformFeedback& c =
       *static_cast<const gles2::cmds::BindTransformFeedback*>(cmd_data);
   (void)c;
   GLenum target = static_cast<GLenum>(c.target);
   GLuint transformfeedback = c.transformfeedback;
+  if (!validators_->transform_feedback_bind_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glBindTransformFeedback", target,
+                                    "target");
+    return error::kNoError;
+  }
   DoBindTransformFeedback(target, transformfeedback);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendColor(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   const gles2::cmds::BlendColor& c =
       *static_cast<const gles2::cmds::BlendColor*>(cmd_data);
   (void)c;
   GLclampf red = static_cast<GLclampf>(c.red);
@@ skipping 190 matching lines @@
                                                    const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::ClearBufferfi& c =
       *static_cast<const gles2::cmds::ClearBufferfi*>(cmd_data);
   (void)c;
   GLenum buffer = static_cast<GLenum>(c.buffer);
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   GLfloat depth = static_cast<GLfloat>(c.depth);
   GLint stencil = static_cast<GLint>(c.stencil);
+  if (!validators_->bufferfi.IsValid(buffer)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glClearBufferfi", buffer, "buffer");
+    return error::kNoError;
+  }
   DoClearBufferfi(buffer, drawbuffers, depth, stencil);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearBufferfvImmediate(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::ClearBufferfvImmediate& c =
       *static_cast<const gles2::cmds::ClearBufferfvImmediate*>(cmd_data);
   (void)c;
   GLenum buffer = static_cast<GLenum>(c.buffer);
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLfloat* value =
       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
+  if (!validators_->bufferfv.IsValid(buffer)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glClearBufferfv", buffer, "buffer");
+    return error::kNoError;
+  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
   DoClearBufferfv(buffer, drawbuffers, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearBufferivImmediate(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::ClearBufferivImmediate& c =
       *static_cast<const gles2::cmds::ClearBufferivImmediate*>(cmd_data);
   (void)c;
   GLenum buffer = static_cast<GLenum>(c.buffer);
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(GLint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLint* value =
       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
+  if (!validators_->bufferiv.IsValid(buffer)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glClearBufferiv", buffer, "buffer");
+    return error::kNoError;
+  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
   DoClearBufferiv(buffer, drawbuffers, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearBufferuivImmediate(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::ClearBufferuivImmediate& c =
       *static_cast<const gles2::cmds::ClearBufferuivImmediate*>(cmd_data);
   (void)c;
   GLenum buffer = static_cast<GLenum>(c.buffer);
   GLint drawbuffers = static_cast<GLint>(c.drawbuffers);
   uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(GLuint), 4, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLuint* value =
       GetImmediateDataAs<const GLuint*>(c, data_size, immediate_data_size);
+  if (!validators_->bufferuiv.IsValid(buffer)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glClearBufferuiv", buffer, "buffer");
+    return error::kNoError;
+  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
   DoClearBufferuiv(buffer, drawbuffers, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearColor(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   const gles2::cmds::ClearColor& c =
@@ skipping 134 matching lines @@
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLint zoffset = static_cast<GLint>(c.zoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
   GLenum format = static_cast<GLenum>(c.format);
   GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
   uint32_t data_size = imageSize;
   const void* data = GetSharedMemoryAs<const void*>(
       c.data_shm_id, c.data_shm_offset, data_size);
+  if (!validators_->texture_3_d_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage3D", target,
+                                    "target");
+    return error::kNoError;
+  }
+  if (!validators_->compressed_texture_format.IsValid(format)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glCompressedTexSubImage3D", format,
+                                    "format");
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
   DoCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
                             height, depth, format, imageSize, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCopyBufferSubData(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::CopyBufferSubData& c =
       *static_cast<const gles2::cmds::CopyBufferSubData*>(cmd_data);
   (void)c;
   GLenum readtarget = static_cast<GLenum>(c.readtarget);
   GLenum writetarget = static_cast<GLenum>(c.writetarget);
   GLintptr readoffset = static_cast<GLintptr>(c.readoffset);
   GLintptr writeoffset = static_cast<GLintptr>(c.writeoffset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
+  if (!validators_->buffer_target.IsValid(readtarget)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyBufferSubData", readtarget,
+                                    "readtarget");
+    return error::kNoError;
+  }
+  if (!validators_->buffer_target.IsValid(writetarget)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyBufferSubData", writetarget,
+                                    "writetarget");
+    return error::kNoError;
+  }
   glCopyBufferSubData(readtarget, writetarget, readoffset, writeoffset, size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CopyTexImage2D& c =
       *static_cast<const gles2::cmds::CopyTexImage2D*>(cmd_data);
   (void)c;
@@ skipping 78 matching lines @@
     return error;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLint zoffset = static_cast<GLint>(c.zoffset);
   GLint x = static_cast<GLint>(c.x);
   GLint y = static_cast<GLint>(c.y);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
+  if (!validators_->texture_3_d_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glCopyTexSubImage3D", target, "target");
+    return error::kNoError;
+  }
   glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
                       height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateProgram(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   const gles2::cmds::CreateProgram& c =
       *static_cast<const gles2::cmds::CreateProgram*>(cmd_data);
   (void)c;
@@ skipping 399 matching lines @@
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::FramebufferTextureLayer& c =
       *static_cast<const gles2::cmds::FramebufferTextureLayer*>(cmd_data);
   (void)c;
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLuint texture = c.texture;
   GLint level = static_cast<GLint>(c.level);
   GLint layer = static_cast<GLint>(c.layer);
+  if (!validators_->frame_buffer_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTextureLayer", target,
+                                    "target");
+    return error::kNoError;
+  }
+  if (!validators_->attachment.IsValid(attachment)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glFramebufferTextureLayer", attachment,
+                                    "attachment");
+    return error::kNoError;
+  }
   DoFramebufferTextureLayer(target, attachment, texture, level, layer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFrontFace(uint32_t immediate_data_size,
                                                const void* cmd_data) {
   const gles2::cmds::FrontFace& c =
       *static_cast<const gles2::cmds::FrontFace*>(cmd_data);
   (void)c;
   GLenum mode = static_cast<GLenum>(c.mode);
@@ skipping 200 matching lines @@
       *static_cast<const gles2::cmds::GetBufferParameteri64v*>(cmd_data);
   (void)c;
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetBufferParameteri64v::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint64* params = result ? result->GetData() : NULL;
+  if (!validators_->buffer_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteri64v", target,
+                                    "target");
+    return error::kNoError;
+  }
+  if (!validators_->buffer_parameter_64.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetBufferParameteri64v", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   DoGetBufferParameteri64v(target, pname, params);
   result->SetNumResults(num_values);
   return error::kNoError;
@@ skipping 132 matching lines @@
   const gles2::cmds::GetInteger64v& c =
       *static_cast<const gles2::cmds::GetInteger64v*>(cmd_data);
   (void)c;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetInteger64v::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint64* params = result ? result->GetData() : NULL;
+  if (!validators_->g_l_state.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetInteger64v", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetInteger64v");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   DoGetInteger64v(pname, params);
   GLenum error = LOCAL_PEEK_GL_ERROR("GetInteger64v");
@@ skipping 11 matching lines @@
       *static_cast<const gles2::cmds::GetIntegeri_v*>(cmd_data);
   (void)c;
   GLenum pname = static_cast<GLenum>(c.pname);
   GLuint index = static_cast<GLuint>(c.index);
   typedef cmds::GetIntegeri_v::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(c.data_shm_id, c.data_shm_offset,
                                               Result::ComputeSize(num_values));
   GLint* data = result ? result->GetData() : NULL;
+  if (!validators_->indexed_g_l_state.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetIntegeri_v", pname, "pname");
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
-  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetIntegeri_v");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
-  glGetIntegeri_v(pname, index, data);
-  GLenum error = LOCAL_PEEK_GL_ERROR("GetIntegeri_v");
-  if (error == GL_NO_ERROR) {
-    result->SetNumResults(num_values);
-  }
+  DoGetIntegeri_v(pname, index, data);
+  result->SetNumResults(num_values);
   return error::kNoError;
 }
-
 error::Error GLES2DecoderImpl::HandleGetInteger64i_v(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetInteger64i_v& c =
       *static_cast<const gles2::cmds::GetInteger64i_v*>(cmd_data);
   (void)c;
   GLenum pname = static_cast<GLenum>(c.pname);
   GLuint index = static_cast<GLuint>(c.index);
   typedef cmds::GetInteger64i_v::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(c.data_shm_id, c.data_shm_offset,
                                               Result::ComputeSize(num_values));
   GLint64* data = result ? result->GetData() : NULL;
+  if (!validators_->indexed_g_l_state.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetInteger64i_v", pname, "pname");
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
-  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetInteger64i_v");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
-  glGetInteger64i_v(pname, index, data);
-  GLenum error = LOCAL_PEEK_GL_ERROR("GetInteger64i_v");
-  if (error == GL_NO_ERROR) {
-    result->SetNumResults(num_values);
-  }
+  DoGetInteger64i_v(pname, index, data);
+  result->SetNumResults(num_values);
   return error::kNoError;
 }
-
 error::Error GLES2DecoderImpl::HandleGetIntegerv(uint32_t immediate_data_size,
                                                  const void* cmd_data) {
   const gles2::cmds::GetIntegerv& c =
       *static_cast<const gles2::cmds::GetIntegerv*>(cmd_data);
   (void)c;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetIntegerv::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
@@ skipping 101 matching lines @@
       *static_cast<const gles2::cmds::GetSamplerParameterfv*>(cmd_data);
   (void)c;
   GLuint sampler = c.sampler;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetSamplerParameterfv::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLfloat* params = result ? result->GetData() : NULL;
+  if (!validators_->sampler_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetSamplerParameterfv", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetSamplerParameterfv");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   DoGetSamplerParameterfv(sampler, pname, params);
   GLenum error = LOCAL_PEEK_GL_ERROR("GetSamplerParameterfv");
@@ skipping 12 matching lines @@
       *static_cast<const gles2::cmds::GetSamplerParameteriv*>(cmd_data);
   (void)c;
   GLuint sampler = c.sampler;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetSamplerParameteriv::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint* params = result ? result->GetData() : NULL;
+  if (!validators_->sampler_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetSamplerParameteriv", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetSamplerParameteriv");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   DoGetSamplerParameteriv(sampler, pname, params);
   GLenum error = LOCAL_PEEK_GL_ERROR("GetSamplerParameteriv");
@@ skipping 44 matching lines @@
       *static_cast<const gles2::cmds::GetSynciv*>(cmd_data);
   (void)c;
   GLuint sync = static_cast<GLuint>(c.sync);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetSynciv::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.values_shm_id, c.values_shm_offset, Result::ComputeSize(num_values));
   GLint* values = result ? result->GetData() : NULL;
+  if (!validators_->sync_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetSynciv", pname, "pname");
+    return error::kNoError;
+  }
   if (values == NULL) {
     return error::kOutOfBounds;
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetSynciv");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   GLsync service_sync = 0;
   if (!group_->GetSyncServiceId(sync, &service_sync)) {
@@ skipping 161 matching lines @@
       *static_cast<const gles2::cmds::GetVertexAttribIiv*>(cmd_data);
   (void)c;
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetVertexAttribIiv::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint* params = result ? result->GetData() : NULL;
+  if (!validators_->vertex_attribute.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetVertexAttribIiv", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetVertexAttribIiv");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   DoGetVertexAttribIiv(index, pname, params);
   GLenum error = LOCAL_PEEK_GL_ERROR("GetVertexAttribIiv");
@@ skipping 12 matching lines @@
       *static_cast<const gles2::cmds::GetVertexAttribIuiv*>(cmd_data);
   (void)c;
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetVertexAttribIuiv::Result Result;
   GLsizei num_values = 0;
   GetNumValuesReturnedForGLGet(pname, &num_values);
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLuint* params = result ? result->GetData() : NULL;
+  if (!validators_->vertex_attribute.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetVertexAttribIuiv", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("GetVertexAttribIuiv");
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   DoGetVertexAttribIuiv(index, pname, params);
   GLenum error = LOCAL_PEEK_GL_ERROR("GetVertexAttribIuiv");
@@ skipping 54 matching lines @@
     return error::kNoError;
   }
   if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLenum* attachments =
       GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
+  if (!validators_->frame_buffer_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glInvalidateFramebuffer", target,
+                                    "target");
+    return error::kNoError;
+  }
   if (attachments == NULL) {
     return error::kOutOfBounds;
   }
   DoInvalidateFramebuffer(target, count, attachments);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleInvalidateSubFramebufferImmediate(
     uint32_t immediate_data_size,
     const void* cmd_data) {
@@ skipping 16 matching lines @@
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLenum* attachments =
       GetImmediateDataAs<const GLenum*>(c, data_size, immediate_data_size);
   GLint x = static_cast<GLint>(c.x);
   GLint y = static_cast<GLint>(c.y);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
+  if (!validators_->frame_buffer_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glInvalidateSubFramebuffer", target,
+                                    "target");
+    return error::kNoError;
+  }
   if (attachments == NULL) {
     return error::kOutOfBounds;
   }
   DoInvalidateSubFramebuffer(target, count, attachments, x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsBuffer(uint32_t immediate_data_size,
                                               const void* cmd_data) {
   const gles2::cmds::IsBuffer& c =
@@ skipping 223 matching lines @@
 }
 
 error::Error GLES2DecoderImpl::HandleReadBuffer(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::ReadBuffer& c =
       *static_cast<const gles2::cmds::ReadBuffer*>(cmd_data);
   (void)c;
   GLenum src = static_cast<GLenum>(c.src);
+  if (!validators_->read_buffer.IsValid(src)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glReadBuffer", src, "src");
+    return error::kNoError;
+  }
   DoReadBuffer(src);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleReleaseShaderCompiler(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::ReleaseShaderCompiler& c =
       *static_cast<const gles2::cmds::ReleaseShaderCompiler*>(cmd_data);
   (void)c;
@@ skipping 60 matching lines @@
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::SamplerParameterf& c =
       *static_cast<const gles2::cmds::SamplerParameterf*>(cmd_data);
   (void)c;
   GLuint sampler = c.sampler;
   GLenum pname = static_cast<GLenum>(c.pname);
   GLfloat param = static_cast<GLfloat>(c.param);
+  if (!validators_->sampler_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glSamplerParameterf", pname, "pname");
+    return error::kNoError;
+  }
   DoSamplerParameterf(sampler, pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleSamplerParameterfvImmediate(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::SamplerParameterfvImmediate& c =
       *static_cast<const gles2::cmds::SamplerParameterfvImmediate*>(cmd_data);
   (void)c;
   GLuint sampler = c.sampler;
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLfloat* params =
       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
+  if (!validators_->sampler_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glSamplerParameterfv", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   DoSamplerParameterfv(sampler, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleSamplerParameteri(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::SamplerParameteri& c =
       *static_cast<const gles2::cmds::SamplerParameteri*>(cmd_data);
   (void)c;
   GLuint sampler = c.sampler;
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint param = static_cast<GLint>(c.param);
+  if (!validators_->sampler_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glSamplerParameteri", pname, "pname");
+    return error::kNoError;
+  }
   DoSamplerParameteri(sampler, pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleSamplerParameterivImmediate(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::SamplerParameterivImmediate& c =
       *static_cast<const gles2::cmds::SamplerParameterivImmediate*>(cmd_data);
   (void)c;
   GLuint sampler = c.sampler;
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLint* params =
       GetImmediateDataAs<const GLint*>(c, data_size, immediate_data_size);
+  if (!validators_->sampler_parameter.IsValid(pname)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glSamplerParameteriv", pname, "pname");
+    return error::kNoError;
+  }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   DoSamplerParameteriv(sampler, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScissor(uint32_t immediate_data_size,
                                              const void* cmd_data) {
   const gles2::cmds::Scissor& c =
@@ skipping 366 matching lines @@
     return error::kUnknownCommand;
   const gles2::cmds::TexStorage3D& c =
       *static_cast<const gles2::cmds::TexStorage3D*>(cmd_data);
   (void)c;
   GLenum target = static_cast<GLenum>(c.target);
   GLsizei levels = static_cast<GLsizei>(c.levels);
   GLenum internalFormat = static_cast<GLenum>(c.internalFormat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
+  if (!validators_->texture_3_d_target.IsValid(target)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage3D", target, "target");
+    return error::kNoError;
+  }
+  if (!validators_->texture_internal_format_storage.IsValid(internalFormat)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexStorage3D", internalFormat,
+                                    "internalFormat");
+    return error::kNoError;
+  }
   DoTexStorage3D(target, levels, internalFormat, width, height, depth);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTransformFeedbackVaryingsBucket(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::TransformFeedbackVaryingsBucket& c =
@@ skipping 11 matching lines @@
   std::vector<GLint> len;
   if (!bucket->GetAsStrings(&count, &strs, &len)) {
     return error::kInvalidArguments;
   }
   const char** varyings =
       strs.size() > 0 ? const_cast<const char**>(&strs[0]) : NULL;
   const GLint* length =
       len.size() > 0 ? const_cast<const GLint*>(&len[0]) : NULL;
   (void)length;
   GLenum buffermode = static_cast<GLenum>(c.buffermode);
+  if (!validators_->buffer_mode.IsValid(buffermode)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTransformFeedbackVaryings", buffermode,
+                                    "buffermode");
+    return error::kNoError;
+  }
   DoTransformFeedbackVaryings(program, count, varyings, buffermode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleUniform1f(uint32_t immediate_data_size,
                                                const void* cmd_data) {
   const gles2::cmds::Uniform1f& c =
       *static_cast<const gles2::cmds::Uniform1f*>(cmd_data);
   (void)c;
   GLint location = static_cast<GLint>(c.location);
@@ skipping 1345 matching lines @@
 
 error::Error GLES2DecoderImpl::HandleBeginTransformFeedback(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::BeginTransformFeedback& c =
       *static_cast<const gles2::cmds::BeginTransformFeedback*>(cmd_data);
   (void)c;
   GLenum primitivemode = static_cast<GLenum>(c.primitivemode);
+  if (!validators_->transform_feedback_primitive_mode.IsValid(primitivemode)) {
+    LOCAL_SET_GL_ERROR_INVALID_ENUM("glBeginTransformFeedback", primitivemode,
+                                    "primitivemode");
+    return error::kNoError;
+  }
   DoBeginTransformFeedback(primitivemode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEndTransformFeedback(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::EndTransformFeedback& c =
@@ skipping 808 matching lines @@
         state_.enable_flags.cached_sample_alpha_to_one_ext = enabled;
         return true;
       }
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_