Add ENUM value to synthesized GL_INVALID_ENUM errors

gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

 // 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.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // DO NOT EDIT!
 
 // It is included by gles2_cmd_decoder.cc
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
@@ skipping 12 matching lines @@
   GLuint shader = c.shader;
   DoAttachShader(program, shader);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindBuffer(
     uint32 immediate_data_size, const gles2::BindBuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint buffer = c.buffer;
   if (!validators_->buffer_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glBindBuffer", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBindBuffer", target, "target");
     return error::kNoError;
   }
   DoBindBuffer(target, buffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindFramebuffer(
     uint32 immediate_data_size, const gles2::BindFramebuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint framebuffer = c.framebuffer;
   if (!validators_->frame_buffer_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glBindFramebuffer", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBindFramebuffer", target, "target");
     return error::kNoError;
   }
   DoBindFramebuffer(target, framebuffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindRenderbuffer(
     uint32 immediate_data_size, const gles2::BindRenderbuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint renderbuffer = c.renderbuffer;
   if (!validators_->render_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBindRenderbuffer", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBindRenderbuffer", target, "target");
     return error::kNoError;
   }
   DoBindRenderbuffer(target, renderbuffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindTexture(
     uint32 immediate_data_size, const gles2::BindTexture& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint texture = c.texture;
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glBindTexture", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBindTexture", target, "target");
     return error::kNoError;
   }
   DoBindTexture(target, texture);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendColor(
     uint32 immediate_data_size, const gles2::BlendColor& c) {
   GLclampf red = static_cast<GLclampf>(c.red);
   GLclampf green = static_cast<GLclampf>(c.green);
   GLclampf blue = static_cast<GLclampf>(c.blue);
   GLclampf alpha = static_cast<GLclampf>(c.alpha);
   glBlendColor(red, green, blue, alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendEquation(
     uint32 immediate_data_size, const gles2::BlendEquation& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->equation.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, "glBlendEquation", "mode GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendEquation", mode, "mode");
     return error::kNoError;
   }
   glBlendEquation(mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendEquationSeparate(
     uint32 immediate_data_size, const gles2::BlendEquationSeparate& c) {
   GLenum modeRGB = static_cast<GLenum>(c.modeRGB);
   GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha);
   if (!validators_->equation.IsValid(modeRGB)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlendEquationSeparate", "modeRGB GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendEquationSeparate", modeRGB, "modeRGB");
     return error::kNoError;
   }
   if (!validators_->equation.IsValid(modeAlpha)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlendEquationSeparate", "modeAlpha GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glBlendEquationSeparate", modeAlpha, "modeAlpha");
     return error::kNoError;
   }
   glBlendEquationSeparate(modeRGB, modeAlpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendFunc(
     uint32 immediate_data_size, const gles2::BlendFunc& c) {
   GLenum sfactor = static_cast<GLenum>(c.sfactor);
   GLenum dfactor = static_cast<GLenum>(c.dfactor);
   if (!validators_->src_blend_factor.IsValid(sfactor)) {
-    SetGLError(GL_INVALID_ENUM, "glBlendFunc", "sfactor GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendFunc", sfactor, "sfactor");
     return error::kNoError;
   }
   if (!validators_->dst_blend_factor.IsValid(dfactor)) {
-    SetGLError(GL_INVALID_ENUM, "glBlendFunc", "dfactor GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendFunc", dfactor, "dfactor");
     return error::kNoError;
   }
   glBlendFunc(sfactor, dfactor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBlendFuncSeparate(
     uint32 immediate_data_size, const gles2::BlendFuncSeparate& c) {
   GLenum srcRGB = static_cast<GLenum>(c.srcRGB);
   GLenum dstRGB = static_cast<GLenum>(c.dstRGB);
   GLenum srcAlpha = static_cast<GLenum>(c.srcAlpha);
   GLenum dstAlpha = static_cast<GLenum>(c.dstAlpha);
   if (!validators_->src_blend_factor.IsValid(srcRGB)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlendFuncSeparate", "srcRGB GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendFuncSeparate", srcRGB, "srcRGB");
     return error::kNoError;
   }
   if (!validators_->dst_blend_factor.IsValid(dstRGB)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlendFuncSeparate", "dstRGB GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendFuncSeparate", dstRGB, "dstRGB");
     return error::kNoError;
   }
   if (!validators_->src_blend_factor.IsValid(srcAlpha)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlendFuncSeparate", "srcAlpha GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendFuncSeparate", srcAlpha, "srcAlpha");
     return error::kNoError;
   }
   if (!validators_->dst_blend_factor.IsValid(dstAlpha)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlendFuncSeparate", "dstAlpha GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlendFuncSeparate", dstAlpha, "dstAlpha");
     return error::kNoError;
   }
   glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBufferSubData(
     uint32 immediate_data_size, const gles2::BufferSubData& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_size = size;
   const void* data = GetSharedMemoryAs<const void*>(
       c.data_shm_id, c.data_shm_offset, data_size);
   if (!validators_->buffer_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glBufferSubData", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBufferSubData", target, "target");
     return error::kNoError;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferSubData", "size < 0");
     return error::kNoError;
   }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
   DoBufferSubData(target, offset, size, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBufferSubDataImmediate(
     uint32 immediate_data_size, const gles2::BufferSubDataImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_size = size;
   const void* data = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   if (!validators_->buffer_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glBufferSubData", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBufferSubData", target, "target");
     return error::kNoError;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferSubData", "size < 0");
     return error::kNoError;
   }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
   DoBufferSubData(target, offset, size, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCheckFramebufferStatus(
     uint32 immediate_data_size, const gles2::CheckFramebufferStatus& c) {
   GLenum target = static_cast<GLenum>(c.target);
   typedef CheckFramebufferStatus::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   if (!validators_->frame_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCheckFramebufferStatus", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCheckFramebufferStatus", target, "target");
     return error::kNoError;
   }
   *result_dst = DoCheckFramebufferStatus(target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClearColor(
     uint32 immediate_data_size, const gles2::ClearColor& c) {
   GLclampf red = static_cast<GLclampf>(c.red);
   GLclampf green = static_cast<GLclampf>(c.green);
@@ skipping 41 matching lines @@
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
   uint32 data_size = imageSize;
   const void* data = GetSharedMemoryAs<const void*>(
       c.data_shm_id, c.data_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCompressedTexSubImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCompressedTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   if (!validators_->compressed_texture_format.IsValid(format)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCompressedTexSubImage2D", "format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCompressedTexSubImage2D", format, "format");
     return error::kNoError;
   }
   if (imageSize < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "imageSize < 0");
     return error::kNoError;
   }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
   DoCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2DImmediate(
     uint32 immediate_data_size,
     const gles2::CompressedTexSubImage2DImmediate& c) {
   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);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLsizei imageSize = static_cast<GLsizei>(c.imageSize);
   uint32 data_size = imageSize;
   const void* data = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCompressedTexSubImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCompressedTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   if (!validators_->compressed_texture_format.IsValid(format)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCompressedTexSubImage2D", "format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCompressedTexSubImage2D", format, "format");
     return error::kNoError;
   }
   if (imageSize < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "imageSize < 0");
     return error::kNoError;
   }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
   DoCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
     uint32 immediate_data_size, const gles2::CopyTexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internalformat = static_cast<GLenum>(c.internalformat);
   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);
   GLint border = static_cast<GLint>(c.border);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glCopyTexImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCopyTexImage2D", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_internal_format.IsValid(internalformat)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCopyTexImage2D", "internalformat GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCopyTexImage2D", internalformat,
+    "internalformat");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
     return error::kNoError;
   }
@@ skipping 10 matching lines @@
     uint32 immediate_data_size, const gles2::CopyTexSubImage2D& c) {
   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 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_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glCopyTexSubImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCopyTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   DoCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateProgram(
     uint32 immediate_data_size, const gles2::CreateProgram& c) {
   uint32 client_id = c.client_id;
   if (!CreateProgramHelper(client_id)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateShader(
     uint32 immediate_data_size, const gles2::CreateShader& c) {
   GLenum type = static_cast<GLenum>(c.type);
   if (!validators_->shader_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glCreateShader", "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCreateShader", type, "type");
     return error::kNoError;
   }
   uint32 client_id = c.client_id;
   if (!CreateShaderHelper(type, client_id)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCullFace(
     uint32 immediate_data_size, const gles2::CullFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->face_type.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, "glCullFace", "mode GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCullFace", mode, "mode");
     return error::kNoError;
   }
   glCullFace(mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteBuffers(
     uint32 immediate_data_size, const gles2::DeleteBuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
@@ skipping 118 matching lines @@
     return error::kOutOfBounds;
   }
   DeleteTexturesHelper(n, textures);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDepthFunc(
     uint32 immediate_data_size, const gles2::DepthFunc& c) {
   GLenum func = static_cast<GLenum>(c.func);
   if (!validators_->cmp_function.IsValid(func)) {
-    SetGLError(GL_INVALID_ENUM, "glDepthFunc", "func GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glDepthFunc", func, "func");
     return error::kNoError;
   }
   glDepthFunc(func);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDepthMask(
     uint32 immediate_data_size, const gles2::DepthMask& c) {
   GLboolean flag = static_cast<GLboolean>(c.flag);
   DoDepthMask(flag);
@@ skipping 13 matching lines @@
   GLuint program = c.program;
   GLuint shader = c.shader;
   DoDetachShader(program, shader);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDisable(
     uint32 immediate_data_size, const gles2::Disable& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   if (!validators_->capability.IsValid(cap)) {
-    SetGLError(GL_INVALID_ENUM, "glDisable", "cap GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glDisable", cap, "cap");
     return error::kNoError;
   }
   DoDisable(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDisableVertexAttribArray(
     uint32 immediate_data_size, const gles2::DisableVertexAttribArray& c) {
   GLuint index = static_cast<GLuint>(c.index);
   DoDisableVertexAttribArray(index);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEnable(
     uint32 immediate_data_size, const gles2::Enable& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   if (!validators_->capability.IsValid(cap)) {
-    SetGLError(GL_INVALID_ENUM, "glEnable", "cap GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glEnable", cap, "cap");
     return error::kNoError;
   }
   DoEnable(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEnableVertexAttribArray(
     uint32 immediate_data_size, const gles2::EnableVertexAttribArray& c) {
   GLuint index = static_cast<GLuint>(c.index);
   DoEnableVertexAttribArray(index);
@@ skipping 12 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFramebufferRenderbuffer(
     uint32 immediate_data_size, const gles2::FramebufferRenderbuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLenum renderbuffertarget = static_cast<GLenum>(c.renderbuffertarget);
   GLuint renderbuffer = c.renderbuffer;
   if (!validators_->frame_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glFramebufferRenderbuffer", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glFramebufferRenderbuffer", target, "target");
     return error::kNoError;
   }
   if (!validators_->attachment.IsValid(attachment)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glFramebufferRenderbuffer", "attachment GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glFramebufferRenderbuffer", attachment,
+    "attachment");
     return error::kNoError;
   }
   if (!validators_->render_buffer_target.IsValid(renderbuffertarget)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glFramebufferRenderbuffer", "renderbuffertarget GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glFramebufferRenderbuffer", renderbuffertarget,
+    "renderbuffertarget");
     return error::kNoError;
   }
   DoFramebufferRenderbuffer(
       target, attachment, renderbuffertarget, renderbuffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
     uint32 immediate_data_size, const gles2::FramebufferTexture2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLenum textarget = static_cast<GLenum>(c.textarget);
   GLuint texture = c.texture;
   GLint level = static_cast<GLint>(c.level);
   if (!validators_->frame_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glFramebufferTexture2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glFramebufferTexture2D", target, "target");
     return error::kNoError;
   }
   if (!validators_->attachment.IsValid(attachment)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glFramebufferTexture2D", "attachment GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glFramebufferTexture2D", attachment, "attachment");
     return error::kNoError;
   }
   if (!validators_->texture_target.IsValid(textarget)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glFramebufferTexture2D", "textarget GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glFramebufferTexture2D", textarget, "textarget");
     return error::kNoError;
   }
   if (!validators_->zero_only.IsValid(level)) {
     SetGLError(
         GL_INVALID_VALUE, "glFramebufferTexture2D", "level GL_INVALID_VALUE");
     return error::kNoError;
   }
   DoFramebufferTexture2D(target, attachment, textarget, texture, level);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFrontFace(
     uint32 immediate_data_size, const gles2::FrontFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->face_mode.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, "glFrontFace", "mode GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glFrontFace", mode, "mode");
     return error::kNoError;
   }
   glFrontFace(mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenBuffers(
     uint32 immediate_data_size, const gles2::GenBuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
@@ skipping 26 matching lines @@
   if (!GenBuffersHelper(n, buffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenerateMipmap(
     uint32 immediate_data_size, const gles2::GenerateMipmap& c) {
   GLenum target = static_cast<GLenum>(c.target);
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glGenerateMipmap", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGenerateMipmap", target, "target");
     return error::kNoError;
   }
   DoGenerateMipmap(target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenFramebuffers(
     uint32 immediate_data_size, const gles2::GenFramebuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
@@ skipping 104 matching lines @@
 error::Error GLES2DecoderImpl::HandleGetBooleanv(
     uint32 immediate_data_size, const gles2::GetBooleanv& c) {
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetBooleanv::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));
   GLboolean* params = result ? result->GetData() : NULL;
   if (!validators_->g_l_state.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glGetBooleanv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetBooleanv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetBufferParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetBufferParameteriv::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_->buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetBufferParameteriv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetBufferParameteriv", target, "target");
     return error::kNoError;
   }
   if (!validators_->buffer_parameter.IsValid(pname)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetBufferParameteriv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetBufferParameteriv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 22 matching lines @@
 error::Error GLES2DecoderImpl::HandleGetFloatv(
     uint32 immediate_data_size, const gles2::GetFloatv& c) {
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetFloatv::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_->g_l_state.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glGetFloatv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetFloatv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 13 matching lines @@
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetFramebufferAttachmentParameteriv::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_->frame_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetFramebufferAttachmentParameteriv", "target GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glGetFramebufferAttachmentParameteriv", target,
+    "target");
     return error::kNoError;
   }
   if (!validators_->attachment.IsValid(attachment)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetFramebufferAttachmentParameteriv", "attachment GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glGetFramebufferAttachmentParameteriv", attachment,
+    "attachment");
     return error::kNoError;
   }
   if (!validators_->frame_buffer_parameter.IsValid(pname)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetFramebufferAttachmentParameteriv", "pname GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glGetFramebufferAttachmentParameteriv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 10 matching lines @@
 error::Error GLES2DecoderImpl::HandleGetIntegerv(
     uint32 immediate_data_size, const gles2::GetIntegerv& c) {
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetIntegerv::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_->g_l_state.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glGetIntegerv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetIntegerv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetProgramiv& c) {
   GLuint program = c.program;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetProgramiv::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_->program_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glGetProgramiv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetProgramiv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetRenderbufferParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetRenderbufferParameteriv::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_->render_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetRenderbufferParameteriv", "target GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glGetRenderbufferParameteriv", target, "target");
     return error::kNoError;
   }
   if (!validators_->render_buffer_parameter.IsValid(pname)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetRenderbufferParameteriv", "pname GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glGetRenderbufferParameteriv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetShaderiv& c) {
   GLuint shader = c.shader;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetShaderiv::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_->shader_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glGetShaderiv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetShaderiv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetTexParameterfv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetTexParameterfv::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_->get_tex_param_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetTexParameterfv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetTexParameterfv", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetTexParameterfv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetTexParameterfv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetTexParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetTexParameteriv::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_->get_tex_param_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetTexParameteriv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetTexParameteriv", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetTexParameteriv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetTexParameteriv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetVertexAttribfv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetVertexAttribfv::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_->vertex_attribute.IsValid(pname)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetVertexAttribfv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetVertexAttribfv", 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;
   }
   CopyRealGLErrorsToWrapper();
@@ skipping 11 matching lines @@
     uint32 immediate_data_size, const gles2::GetVertexAttribiv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetVertexAttribiv::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)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetVertexAttribiv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetVertexAttribiv", 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;
   }
   CopyRealGLErrorsToWrapper();
   DoGetVertexAttribiv(index, pname, params);
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     SetGLError(error, "", "");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleHint(
     uint32 immediate_data_size, const gles2::Hint& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!validators_->hint_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glHint", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glHint", target, "target");
     return error::kNoError;
   }
   if (!validators_->hint_mode.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, "glHint", "mode GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glHint", mode, "mode");
     return error::kNoError;
   }
   glHint(target, mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsBuffer(
     uint32 immediate_data_size, const gles2::IsBuffer& c) {
   GLuint buffer = c.buffer;
   typedef IsBuffer::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsBuffer(buffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsEnabled(
     uint32 immediate_data_size, const gles2::IsEnabled& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   typedef IsEnabled::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   if (!validators_->capability.IsValid(cap)) {
-    SetGLError(GL_INVALID_ENUM, "glIsEnabled", "cap GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glIsEnabled", cap, "cap");
     return error::kNoError;
   }
   *result_dst = DoIsEnabled(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsFramebuffer(
     uint32 immediate_data_size, const gles2::IsFramebuffer& c) {
   GLuint framebuffer = c.framebuffer;
   typedef IsFramebuffer::Result Result;
@@ skipping 86 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
     uint32 immediate_data_size, const gles2::RenderbufferStorage& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum internalformat = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   if (!validators_->render_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glRenderbufferStorage", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glRenderbufferStorage", target, "target");
     return error::kNoError;
   }
   if (!validators_->render_buffer_format.IsValid(internalformat)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glRenderbufferStorage", "internalformat GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glRenderbufferStorage", internalformat,
+    "internalformat");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glRenderbufferStorage", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glRenderbufferStorage", "height < 0");
     return error::kNoError;
   }
@@ skipping 26 matching lines @@
   glScissor(x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFunc(
     uint32 immediate_data_size, const gles2::StencilFunc& c) {
   GLenum func = static_cast<GLenum>(c.func);
   GLint ref = static_cast<GLint>(c.ref);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!validators_->cmp_function.IsValid(func)) {
-    SetGLError(GL_INVALID_ENUM, "glStencilFunc", "func GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilFunc", func, "func");
     return error::kNoError;
   }
   glStencilFunc(func, ref, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFuncSeparate(
     uint32 immediate_data_size, const gles2::StencilFuncSeparate& c) {
   GLenum face = static_cast<GLenum>(c.face);
   GLenum func = static_cast<GLenum>(c.func);
   GLint ref = static_cast<GLint>(c.ref);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!validators_->face_type.IsValid(face)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glStencilFuncSeparate", "face GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilFuncSeparate", face, "face");
     return error::kNoError;
   }
   if (!validators_->cmp_function.IsValid(func)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glStencilFuncSeparate", "func GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilFuncSeparate", func, "func");
     return error::kNoError;
   }
   glStencilFuncSeparate(face, func, ref, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilMask(
     uint32 immediate_data_size, const gles2::StencilMask& c) {
   GLuint mask = static_cast<GLuint>(c.mask);
   DoStencilMask(mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilMaskSeparate(
     uint32 immediate_data_size, const gles2::StencilMaskSeparate& c) {
   GLenum face = static_cast<GLenum>(c.face);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!validators_->face_type.IsValid(face)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glStencilMaskSeparate", "face GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilMaskSeparate", face, "face");
     return error::kNoError;
   }
   DoStencilMaskSeparate(face, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilOp(
     uint32 immediate_data_size, const gles2::StencilOp& c) {
   GLenum fail = static_cast<GLenum>(c.fail);
   GLenum zfail = static_cast<GLenum>(c.zfail);
   GLenum zpass = static_cast<GLenum>(c.zpass);
   if (!validators_->stencil_op.IsValid(fail)) {
-    SetGLError(GL_INVALID_ENUM, "glStencilOp", "fail GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOp", fail, "fail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zfail)) {
-    SetGLError(GL_INVALID_ENUM, "glStencilOp", "zfail GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOp", zfail, "zfail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zpass)) {
-    SetGLError(GL_INVALID_ENUM, "glStencilOp", "zpass GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOp", zpass, "zpass");
     return error::kNoError;
   }
   glStencilOp(fail, zfail, zpass);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilOpSeparate(
     uint32 immediate_data_size, const gles2::StencilOpSeparate& c) {
   GLenum face = static_cast<GLenum>(c.face);
   GLenum fail = static_cast<GLenum>(c.fail);
   GLenum zfail = static_cast<GLenum>(c.zfail);
   GLenum zpass = static_cast<GLenum>(c.zpass);
   if (!validators_->face_type.IsValid(face)) {
-    SetGLError(GL_INVALID_ENUM, "glStencilOpSeparate", "face GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOpSeparate", face, "face");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(fail)) {
-    SetGLError(GL_INVALID_ENUM, "glStencilOpSeparate", "fail GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOpSeparate", fail, "fail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zfail)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glStencilOpSeparate", "zfail GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOpSeparate", zfail, "zfail");
     return error::kNoError;
   }
   if (!validators_->stencil_op.IsValid(zpass)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glStencilOpSeparate", "zpass GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glStencilOpSeparate", zpass, "zpass");
     return error::kNoError;
   }
   glStencilOpSeparate(face, fail, zfail, zpass);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameterf(
     uint32 immediate_data_size, const gles2::TexParameterf& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLfloat param = static_cast<GLfloat>(c.param);
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterf", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterf", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterf", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterf", pname, "pname");
     return error::kNoError;
   }
   DoTexParameterf(target, pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameterfv(
     uint32 immediate_data_size, const gles2::TexParameterfv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32 data_size;
   if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   const GLfloat* params = GetSharedMemoryAs<const GLfloat*>(
       c.params_shm_id, c.params_shm_offset, data_size);
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterfv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterfv", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterfv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterfv", pname, "pname");
     return error::kNoError;
   }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   DoTexParameterfv(target, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameterfvImmediate(
     uint32 immediate_data_size, const gles2::TexParameterfvImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32 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_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterfv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterfv", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterfv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterfv", pname, "pname");
     return error::kNoError;
   }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   DoTexParameterfv(target, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameteri(
     uint32 immediate_data_size, const gles2::TexParameteri& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint param = static_cast<GLint>(c.param);
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteri", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteri", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteri", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteri", pname, "pname");
     return error::kNoError;
   }
   DoTexParameteri(target, pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameteriv(
     uint32 immediate_data_size, const gles2::TexParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32 data_size;
   if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
     return error::kOutOfBounds;
   }
   const GLint* params = GetSharedMemoryAs<const GLint*>(
       c.params_shm_id, c.params_shm_offset, data_size);
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteriv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteriv", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteriv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteriv", pname, "pname");
     return error::kNoError;
   }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   DoTexParameteriv(target, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexParameterivImmediate(
     uint32 immediate_data_size, const gles2::TexParameterivImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   uint32 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_->texture_bind_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteriv", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteriv", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_parameter.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteriv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteriv", pname, "pname");
     return error::kNoError;
   }
   if (params == NULL) {
     return error::kOutOfBounds;
   }
   DoTexParameteriv(target, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleUniform1f(
@@ skipping 738 matching lines @@
   GLint srcY0 = static_cast<GLint>(c.srcY0);
   GLint srcX1 = static_cast<GLint>(c.srcX1);
   GLint srcY1 = static_cast<GLint>(c.srcY1);
   GLint dstX0 = static_cast<GLint>(c.dstX0);
   GLint dstY0 = static_cast<GLint>(c.dstY0);
   GLint dstX1 = static_cast<GLint>(c.dstX1);
   GLint dstY1 = static_cast<GLint>(c.dstY1);
   GLbitfield mask = static_cast<GLbitfield>(c.mask);
   GLenum filter = static_cast<GLenum>(c.filter);
   if (!validators_->blit_filter.IsValid(filter)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glBlitFramebufferEXT", "filter GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBlitFramebufferEXT", filter, "filter");
     return error::kNoError;
   }
   DoBlitFramebufferEXT(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRenderbufferStorageMultisampleEXT(
     uint32 immediate_data_size,
     const gles2::RenderbufferStorageMultisampleEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizei samples = static_cast<GLsizei>(c.samples);
   GLenum internalformat = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   if (!validators_->render_buffer_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glRenderbufferStorageMultisampleEXT", "target GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glRenderbufferStorageMultisampleEXT", target,
+    "target");
     return error::kNoError;
   }
   if (samples < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "samples < 0");
     return error::kNoError;
   }
   if (!validators_->render_buffer_format.IsValid(internalformat)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glRenderbufferStorageMultisampleEXT", "internalformat GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glRenderbufferStorageMultisampleEXT", internalformat,
+    "internalformat");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glRenderbufferStorageMultisampleEXT", "height < 0");
     return error::kNoError;
   }
   DoRenderbufferStorageMultisample(
       target, samples, internalformat, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexStorage2DEXT(
     uint32 immediate_data_size, const gles2::TexStorage2DEXT& 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);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexStorage2DEXT", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexStorage2DEXT", target, "target");
     return error::kNoError;
   }
   if (levels < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT", "levels < 0");
     return error::kNoError;
   }
   if (!validators_->texture_internal_format_storage.IsValid(internalFormat)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glTexStorage2DEXT", "internalFormat GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexStorage2DEXT", internalFormat,
+    "internalFormat");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT", "height < 0");
     return error::kNoError;
   }
@@ skipping 115 matching lines @@
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetMaxValueInBufferCHROMIUM", "count < 0");
     return error::kNoError;
   }
   if (!validators_->get_max_index_type.IsValid(type)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glGetMaxValueInBufferCHROMIUM", "type GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glGetMaxValueInBufferCHROMIUM", type, "type");
     return error::kNoError;
   }
   *result_dst = DoGetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImageIOSurface2DCHROMIUM(
     uint32 immediate_data_size, const gles2::TexImageIOSurface2DCHROMIUM& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLuint ioSurfaceId = static_cast<GLuint>(c.ioSurfaceId);
   GLuint plane = static_cast<GLuint>(c.plane);
   if (!validators_->texture_bind_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glTexImageIOSurface2DCHROMIUM", "target GL_INVALID_ENUM");  // NOLINT
+    SetGLErrorInvalidEnum("glTexImageIOSurface2DCHROMIUM", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glTexImageIOSurface2DCHROMIUM", "height < 0");
     return error::kNoError;
@@ skipping 21 matching lines @@
 error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUM(
     uint32 immediate_data_size, const gles2::ProduceTextureCHROMIUM& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 data_size;
   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
     return error::kOutOfBounds;
   }
   const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
       c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glProduceTextureCHROMIUM", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glProduceTextureCHROMIUM", target, "target");
     return error::kNoError;
   }
   if (mailbox == NULL) {
     return error::kOutOfBounds;
   }
   DoProduceTextureCHROMIUM(target, mailbox);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUMImmediate(
     uint32 immediate_data_size,
     const gles2::ProduceTextureCHROMIUMImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 data_size;
   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLbyte* mailbox = GetImmediateDataAs<const GLbyte*>(
       c, data_size, immediate_data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glProduceTextureCHROMIUM", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glProduceTextureCHROMIUM", target, "target");
     return error::kNoError;
   }
   if (mailbox == NULL) {
     return error::kOutOfBounds;
   }
   DoProduceTextureCHROMIUM(target, mailbox);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUM(
     uint32 immediate_data_size, const gles2::ConsumeTextureCHROMIUM& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 data_size;
   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
     return error::kOutOfBounds;
   }
   const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
       c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glConsumeTextureCHROMIUM", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glConsumeTextureCHROMIUM", target, "target");
     return error::kNoError;
   }
   if (mailbox == NULL) {
     return error::kOutOfBounds;
   }
   DoConsumeTextureCHROMIUM(target, mailbox);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUMImmediate(
     uint32 immediate_data_size,
     const gles2::ConsumeTextureCHROMIUMImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 data_size;
   if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
     return error::kOutOfBounds;
   }
   if (data_size > immediate_data_size) {
     return error::kOutOfBounds;
   }
   const GLbyte* mailbox = GetImmediateDataAs<const GLbyte*>(
       c, data_size, immediate_data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glConsumeTextureCHROMIUM", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glConsumeTextureCHROMIUM", target, "target");
     return error::kNoError;
   }
   if (mailbox == NULL) {
     return error::kOutOfBounds;
   }
   DoConsumeTextureCHROMIUM(target, mailbox);
   return error::kNoError;
 }
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_