Adds a GLMock object so we can check the code is...

gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

 // This file is auto-generated. DO NOT EDIT!
 
 // It is included by gles2_cmd_decoder.cc
 
 parse_error::ParseError GLES2DecoderImpl::HandleActiveTexture(
     uint32 immediate_data_size, const gles2::ActiveTexture& c) {
   GLenum texture = static_cast<GLenum>(c.texture);
   glActiveTexture(texture);
   return parse_error::kParseNoError;
 }
@@ skipping 54 matching lines @@
 
 parse_error::ParseError GLES2DecoderImpl::HandleBindBuffer(
     uint32 immediate_data_size, const gles2::BindBuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint buffer;
   if (!id_map_.GetServiceId(c.buffer, &buffer)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   DoBindBuffer(target, buffer);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleBindFramebuffer(
     uint32 immediate_data_size, const gles2::BindFramebuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint framebuffer;
   if (!id_map_.GetServiceId(c.framebuffer, &framebuffer)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumFrameBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBindFramebufferEXT(target, framebuffer);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleBindRenderbuffer(
     uint32 immediate_data_size, const gles2::BindRenderbuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint renderbuffer;
   if (!id_map_.GetServiceId(c.renderbuffer, &renderbuffer)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumRenderBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBindRenderbufferEXT(target, renderbuffer);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleBindTexture(
     uint32 immediate_data_size, const gles2::BindTexture& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint texture;
   if (!id_map_.GetServiceId(c.texture, &texture)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBindTexture(target, texture);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleBlendEquation(
     uint32 immediate_data_size, const gles2::BlendEquation& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!ValidateGLenumEquation(mode)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBlendEquation(mode);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumEquation(modeRGB)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumEquation(modeAlpha)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBlendEquationSeparate(modeRGB, modeAlpha);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumSrcBlendFactor(sfactor)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumDstBlendFactor(dfactor)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBlendFunc(sfactor, dfactor);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumSrcBlendFactor(srcRGB)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumDstBlendFactor(dstRGB)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumSrcBlendFactor(srcAlpha)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumDstBlendFactor(dstAlpha)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (data == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glBufferSubData(target, offset, size, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (data == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glBufferSubData(target, offset, size, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCheckFramebufferStatus(
     uint32 immediate_data_size, const gles2::CheckFramebufferStatus& c) {
   GLenum target = static_cast<GLenum>(c.target);
   if (!ValidateGLenumFrameBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glCheckFramebufferStatusEXT(target);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleClear(
     uint32 immediate_data_size, const gles2::Clear& c) {
   GLbitfield mask = static_cast<GLbitfield>(c.mask);
   glClear(mask);
@@ skipping 52 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 (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (data == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (data == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCopyTexSubImage2D(
     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 (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCreateProgram(
     uint32 immediate_data_size, const gles2::CreateProgram& c) {
   uint32 client_id = c.client_id;
   CreateProgramHelper(client_id);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCreateShader(
     uint32 immediate_data_size, const gles2::CreateShader& c) {
   GLenum type = static_cast<GLenum>(c.type);
   if (!ValidateGLenumShaderType(type)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   uint32 client_id = c.client_id;
   CreateShaderHelper(type, client_id);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleCullFace(
     uint32 immediate_data_size, const gles2::CullFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!ValidateGLenumFaceType(mode)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glCullFace(mode);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDeleteBuffers(
     uint32 immediate_data_size, const gles2::DeleteBuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size = n * sizeof(GLuint);
@@ skipping 94 matching lines @@
     return parse_error::kParseOutOfBounds;
   }
   DeleteGLObjects<GLDeleteTexturesHelper>(n, textures);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDepthFunc(
     uint32 immediate_data_size, const gles2::DepthFunc& c) {
   GLenum func = static_cast<GLenum>(c.func);
   if (!ValidateGLenumCmpFunction(func)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glDepthFunc(func);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDepthMask(
     uint32 immediate_data_size, const gles2::DepthMask& c) {
   GLboolean flag = static_cast<GLboolean>(c.flag);
   glDepthMask(flag);
@@ skipping 21 matching lines @@
     return parse_error::kParseNoError;
   }
   glDetachShader(program, shader);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDisable(
     uint32 immediate_data_size, const gles2::Disable& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   if (!ValidateGLenumCapability(cap)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glDisable(cap);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDisableVertexAttribArray(
     uint32 immediate_data_size, const gles2::DisableVertexAttribArray& c) {
   GLuint index = static_cast<GLuint>(c.index);
   DoDisableVertexAttribArray(index);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleDrawArrays(
     uint32 immediate_data_size, const gles2::DrawArrays& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   GLint first = static_cast<GLint>(c.first);
   GLsizei count = static_cast<GLsizei>(c.count);
   if (!ValidateGLenumDrawMode(mode)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   DoDrawArrays(mode, first, count);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleEnable(
     uint32 immediate_data_size, const gles2::Enable& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   if (!ValidateGLenumCapability(cap)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glEnable(cap);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleEnableVertexAttribArray(
     uint32 immediate_data_size, const gles2::EnableVertexAttribArray& c) {
   GLuint index = static_cast<GLuint>(c.index);
   DoEnableVertexAttribArray(index);
@@ skipping 16 matching lines @@
     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;
   if (!id_map_.GetServiceId(c.renderbuffer, &renderbuffer)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumFrameBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumAttachment(attachment)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumRenderBufferTarget(renderbuffertarget)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glFramebufferRenderbufferEXT(
       target, attachment, renderbuffertarget, renderbuffer);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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;
   if (!id_map_.GetServiceId(c.texture, &texture)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLint level = static_cast<GLint>(c.level);
   if (!ValidateGLenumFrameBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumAttachment(attachment)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureTarget(textarget)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleFrontFace(
     uint32 immediate_data_size, const gles2::FrontFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!ValidateGLenumFaceMode(mode)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glFrontFace(mode);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGenBuffers(
     uint32 immediate_data_size, const gles2::GenBuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size = n * sizeof(GLuint);
@@ skipping 16 matching lines @@
     return parse_error::kParseOutOfBounds;
   }
   GenGLObjects<GLGenBuffersHelper>(n, buffers);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGenerateMipmap(
     uint32 immediate_data_size, const gles2::GenerateMipmap& c) {
   GLenum target = static_cast<GLenum>(c.target);
   if (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glGenerateMipmapEXT(target);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGenFramebuffers(
     uint32 immediate_data_size, const gles2::GenFramebuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size = n * sizeof(GLuint);
@@ skipping 89 matching lines @@
 parse_error::ParseError GLES2DecoderImpl::HandleGetBufferParameteriv(
     uint32 immediate_data_size, const gles2::GetBufferParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumBufferParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetBufferParameteriv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetError(
@@ skipping 25 matching lines @@
     const gles2::GetFramebufferAttachmentParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumFrameBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumAttachment(attachment)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumFrameBufferParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetIntegerv(
@@ skipping 18 matching lines @@
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumProgramParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetProgramiv(program, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetProgramInfoLog(
@@ skipping 26 matching lines @@
 parse_error::ParseError GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
     uint32 immediate_data_size, const gles2::GetRenderbufferParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumRenderBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumRenderBufferParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetRenderbufferParameterivEXT(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetShaderiv(
     uint32 immediate_data_size, const gles2::GetShaderiv& c) {
   GLuint shader;
   if (!id_map_.GetServiceId(c.shader, &shader)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumShaderParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetShaderiv(shader, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetShaderInfoLog(
@@ skipping 47 matching lines @@
     return parse_error::kParseOutOfBounds;
   }
   glGetShaderSource(shader, bufsize, length, source);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetString(
     uint32 immediate_data_size, const gles2::GetString& c) {
   GLenum name = static_cast<GLenum>(c.name);
   if (!ValidateGLenumStringType(name)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glGetString(name);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetTexParameterfv(
     uint32 immediate_data_size, const gles2::GetTexParameterfv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLfloat* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLfloat*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetTexParameterfv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetTexParameteriv(
     uint32 immediate_data_size, const gles2::GetTexParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetTexParameteriv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetVertexAttribfv(
     uint32 immediate_data_size, const gles2::GetVertexAttribfv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLfloat* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLfloat*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumVertexAttribute(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetVertexAttribfv(index, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleGetVertexAttribiv(
     uint32 immediate_data_size, const gles2::GetVertexAttribiv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   GLint* params;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   uint32 params_size = num_values * sizeof(*params);
   params = GetSharedMemoryAs<GLint*>(
       c.params_shm_id, c.params_shm_offset, params_size);
   if (!ValidateGLenumVertexAttribute(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glGetVertexAttribiv(index, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumHintTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumHintMode(mode)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glHint(target, mode);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleIsBuffer(
     uint32 immediate_data_size, const gles2::IsBuffer& c) {
   GLuint buffer;
   if (!id_map_.GetServiceId(c.buffer, &buffer)) {
     SetGLError(GL_INVALID_VALUE);
     return parse_error::kParseNoError;
   }
   GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   *result_dst = glIsBuffer(buffer);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleIsEnabled(
     uint32 immediate_data_size, const gles2::IsEnabled& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!ValidateGLenumCapability(cap)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   *result_dst = glIsEnabled(cap);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleIsFramebuffer(
     uint32 immediate_data_size, const gles2::IsFramebuffer& c) {
   GLuint framebuffer;
   if (!id_map_.GetServiceId(c.framebuffer, &framebuffer)) {
@@ skipping 84 matching lines @@
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumRenderBufferTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumRenderBufferFormat(internalformat)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glRenderbufferStorageEXT(target, internalformat, width, height);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleSampleCoverage(
     uint32 immediate_data_size, const gles2::SampleCoverage& c) {
   GLclampf value = static_cast<GLclampf>(c.value);
   GLboolean invert = static_cast<GLboolean>(c.invert);
@@ skipping 10 matching lines @@
   glScissor(x, y, width, height);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumCmpFunction(func)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glStencilFunc(func, ref, mask);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumFaceType(face)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumCmpFunction(func)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glStencilFuncSeparate(face, func, ref, mask);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleStencilMask(
     uint32 immediate_data_size, const gles2::StencilMask& c) {
   GLuint mask = static_cast<GLuint>(c.mask);
   glStencilMask(mask);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumFaceType(face)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glStencilMaskSeparate(face, mask);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumStencilOp(fail)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumStencilOp(zfail)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumStencilOp(zpass)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glStencilOp(fail, zfail, zpass);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumFaceType(face)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumStencilOp(fail)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumStencilOp(zfail)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumStencilOp(zpass)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glStencilOpSeparate(face, fail, zfail, zpass);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glTexParameterf(target, pname, param);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 =
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 1);
   const GLfloat* params = GetSharedMemoryAs<const GLfloat*>(
       c.params_shm_id, c.params_shm_offset, data_size);
   if (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glTexParameterfv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 =
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 1);
   const GLfloat* params = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
   if (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glTexParameterfv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   glTexParameteri(target, pname, param);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 =
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 1);
   const GLint* params = GetSharedMemoryAs<const GLint*>(
       c.params_shm_id, c.params_shm_offset, data_size);
   if (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glTexParameteriv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError 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 =
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 1);
   const GLint* params = GetImmediateDataAs<const GLint*>(
       c, data_size, immediate_data_size);
   if (!ValidateGLenumTextureBindTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureParameter(pname)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (params == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glTexParameteriv(target, pname, params);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleTexSubImage2D(
     uint32 immediate_data_size, const gles2::TexSubImage2D& 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);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size = GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_);
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   if (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureFormat(format)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumPixelType(type)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (pixels == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleTexSubImage2DImmediate(
     uint32 immediate_data_size, const gles2::TexSubImage2DImmediate& 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);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size = GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_);
   const void* pixels = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   if (!ValidateGLenumTextureTarget(target)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumTextureFormat(format)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (!ValidateGLenumPixelType(type)) {
-    SetGLError(GL_INVALID_VALUE);
+    SetGLError(GL_INVALID_ENUM);
     return parse_error::kParseNoError;
   }
   if (pixels == NULL) {
     return parse_error::kParseOutOfBounds;
   }
   glTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
   return parse_error::kParseNoError;
 }
 
@@ skipping 590 matching lines @@
   glViewport(x, y, width, height);
   return parse_error::kParseNoError;
 }
 
 parse_error::ParseError GLES2DecoderImpl::HandleSwapBuffers(
     uint32 immediate_data_size, const gles2::SwapBuffers& c) {
   DoSwapBuffers();
   return parse_error::kParseNoError;
 }