Add ENUM value to synthesized GL_INVALID_ENUM errors

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 489 matching lines @@
   virtual bool MakeCurrent();
   virtual void ReleaseCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
   virtual ContextGroup* GetContextGroup() { return group_.get(); }
   virtual QueryManager* GetQueryManager() { return query_manager_.get(); }
   virtual bool ProcessPendingQueries();
 
   virtual void SetGLError(
       GLenum error, const char* function_name, const char* msg);
+  virtual void SetGLErrorInvalidEnum(
+      const char* function_name, GLenum value, const char* label);
   virtual void SetResizeCallback(
       const base::Callback<void(gfx::Size)>& callback);
 
   virtual void SetMsgCallback(const MsgCallback& callback);
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager);
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id);
 
   virtual uint32 GetGLError() OVERRIDE;
@@ skipping 2770 matching lines @@
 }
 
 void GLES2DecoderImpl::DoFlush() {
   glFlush();
   ProcessPendingQueries();
 }
 
 void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
   GLuint texture_index = texture_unit - GL_TEXTURE0;
   if (texture_index >= group_->max_texture_units()) {
-    SetGLError(
-        GL_INVALID_ENUM, "glActiveTexture", "texture_unit out of range.");
+    SetGLErrorInvalidEnum(
+        "glActiveTexture", texture_unit, "texture_unit");
     return;
   }
   active_texture_unit_ = texture_index;
   glActiveTexture(texture_unit);
 }
 
 void GLES2DecoderImpl::DoBindBuffer(GLenum target, GLuint client_id) {
   BufferManager::BufferInfo* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
@@ skipping 1449 matching lines @@
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterf", "unknown texture");
     return;
   }
 
   if (!texture_manager()->SetParameter(
       info, pname, static_cast<GLint>(param))) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterf", "param GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterf", pname, "pname");
     return;
   }
   glTexParameterf(target, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   if (!texture_manager()->SetParameter(info, pname, param)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteri", "param GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteri", pname, "pname");
     return;
   }
   glTexParameteri(target, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameterfv(
     GLenum target, GLenum pname, const GLfloat* params) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterfv", "unknown texture");
     return;
   }
 
   if (!texture_manager()->SetParameter(
       info, pname, static_cast<GLint>(params[0]))) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameterfv", "param GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameterfv", pname, "pname");
     return;
   }
   glTexParameterfv(target, pname, params);
 }
 
 void GLES2DecoderImpl::DoTexParameteriv(
   GLenum target, GLenum pname, const GLint* params) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteriv", "unknown texture");
     return;
   }
 
   if (!texture_manager()->SetParameter(info, pname, *params)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteriv", "param GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexParameteriv", pname, "pname");
     return;
   }
   glTexParameteriv(target, pname, params);
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
   if (!current_program_) {
     // The program does not exist.
     SetGLError(GL_INVALID_OPERATION, function_name, "no program in use");
     return false;
@@ skipping 282 matching lines @@
     GLenum error, const char* function_name, const char* msg) {
   if (msg) {
     last_error_ = msg;
     LogMessage(GetLogPrefix() + ": " + std::string("GL ERROR :") +
                GLES2Util::GetStringEnum(error) + " : " +
                function_name + ": " + msg);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
+void GLES2DecoderImpl::SetGLErrorInvalidEnum(
+    const char* function_name, GLenum value, const char* label) {
+  SetGLError(GL_INVALID_ENUM, function_name,
+             (std::string(label) + " was " +
+              GLES2Util::GetStringEnum(value)).c_str());
+}
+
 const std::string& GLES2DecoderImpl::GetLogPrefix() const {
   const std::string& prefix(debug_marker_manager_.GetMarker());
   return prefix.empty() ? this_in_hex_ : prefix;
 }
 
 void GLES2DecoderImpl::LogMessage(const std::string& msg) {
   if (log_message_count_ < kMaxLogMessages ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGLErrorLimit)) {
     ++log_message_count_;
@@ skipping 441 matching lines @@
 error::Error GLES2DecoderImpl::DoDrawArrays(
     const char* function_name,
     bool instanced,
     GLenum mode,
     GLint first,
     GLsizei count,
     GLsizei primcount) {
   if (ShouldDeferDraws())
     return error::kDeferCommandUntilLater;
   if (!validators_->draw_mode.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, function_name, "mode GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum(function_name, mode, "mode");
     return error::kNoError;
   }
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (primcount < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
@@ skipping 96 matching lines @@
 
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (offset < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "offset < 0");
     return error::kNoError;
   }
   if (!validators_->draw_mode.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, function_name, "mode GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum(function_name, mode, "mode");
     return error::kNoError;
   }
   if (!validators_->index_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, function_name, "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum(function_name, type, "type");
     return error::kNoError;
   }
   if (primcount < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
 
   if (!CheckBoundFramebuffersValid(function_name)) {
     return error::kNoError;
   }
@@ skipping 578 matching lines @@
   }
 
   GLuint indx = c.indx;
   GLint size = c.size;
   GLenum type = c.type;
   GLboolean normalized = c.normalized;
   GLsizei stride = c.stride;
   GLsizei offset = c.offset;
   const void* ptr = reinterpret_cast<const void*>(offset);
   if (!validators_->vertex_attrib_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glVertexAttribPointer", "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glVertexAttribPointer", type, "type");
     return error::kNoError;
   }
   if (!validators_->vertex_attrib_size.IsValid(size)) {
     SetGLError(GL_INVALID_VALUE,
                "glVertexAttribPointer", "size GL_INVALID_VALUE");
     return error::kNoError;
   }
   if (indx >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttribPointer", "index out of range");
     return error::kNoError;
@@ skipping 90 matching lines @@
   }
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   Result* result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!pixels || !result) {
     return error::kOutOfBounds;
   }
 
   if (!validators_->read_pixel_format.IsValid(format)) {
-    SetGLError(GL_INVALID_ENUM, "glReadPixels", "format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glReadPixels", format, "format");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glReadPixels", "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glReadPixels", type, "type");
     return error::kNoError;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFrameBufferSize();
 
   GLint max_x;
@@ skipping 104 matching lines @@
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePixelStorei(
     uint32 immediate_data_size, const gles2::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
   if (!validators_->pixel_store.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM, "glPixelStorei", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glPixelStorei", pname, "pname");
     return error::kNoError;
   }
   switch (pname) {
     case GL_PACK_ALIGNMENT:
     case GL_UNPACK_ALIGNMENT:
         if (!validators_->pixel_store_alignment.IsValid(param)) {
             SetGLError(GL_INVALID_VALUE,
                        "glPixelStore", "param GL_INVALID_VALUE");
             return error::kNoError;
         }
@@ skipping 183 matching lines @@
     return error::kInvalidArguments;
   }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetString(
     uint32 immediate_data_size, const gles2::GetString& c) {
   GLenum name = static_cast<GLenum>(c.name);
   if (!validators_->string_type.IsValid(name)) {
-    SetGLError(GL_INVALID_ENUM, "glGetString", "name GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetString", name, "name");
     return error::kNoError;
   }
   const char* gl_str = reinterpret_cast<const char*>(glGetString(name));
   const char* str = NULL;
   std::string extensions;
   switch (name) {
     case GL_VERSION:
       str = "OpenGL ES 2.0 Chromium";
       break;
     case GL_SHADING_LANGUAGE_VERSION:
@@ skipping 32 matching lines @@
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {
   if (!validators_->buffer_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glBufferData", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBufferData", target, "target");
     return;
   }
   if (!validators_->buffer_usage.IsValid(usage)) {
-    SetGLError(GL_INVALID_ENUM, "glBufferData", "usage GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glBufferData", usage, "usage");
     return;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0");
     return;
   }
   BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glBufferData", "unknown buffer");
     return;
@@ skipping 206 matching lines @@
     case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: {
         int num_blocks_across =
             (width + kS3TCBlockWidth - 1) / kS3TCBlockWidth;
         int num_blocks_down =
             (height + kS3TCBlockHeight - 1) / kS3TCBlockHeight;
         int num_blocks = num_blocks_across * num_blocks_down;
         bytes_required = num_blocks * kS3TCDXT3AndDXT5BlockSize;
         break;
       }
     default:
-      SetGLError(GL_INVALID_ENUM, function_name, "invalid format");
+      SetGLErrorInvalidEnum(function_name, format, "format");
       return false;
   }
 
   if (size != bytes_required) {
     SetGLError(
         GL_INVALID_VALUE, function_name, "size is not correct for dimensions");
     return false;
   }
 
   return true;
@@ skipping 65 matching lines @@
   GLenum target,
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLsizei image_size,
   const void* data) {
   // TODO(gman): Validate image_size is correct for width, height and format.
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glCompressedTexImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glCompressedTexImage2D", target, "target");
     return error::kNoError;
   }
   if (!validators_->compressed_texture_format.IsValid(
       internal_format)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glCompressedTexImage2D", "internal_format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum(
+        "glCompressedTexImage2D", internal_format, "internal_format");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D", "dimensions out of range");
     return error::kNoError;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
@@ skipping 118 matching lines @@
     return error::kInvalidArguments;
   }
   uint32 data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
   if (!data) {
     return error::kInvalidArguments;
   }
   if (!validators_->texture_target.IsValid(target)) {
     SetGLError(
-        GL_INVALID_ENUM, "glCompressedTexSubImage2D", "target GL_INVALID_ENUM");
+        GL_INVALID_ENUM, "glCompressedTexSubImage2D", "target");
     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 (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;
   }
@@ skipping 33 matching lines @@
   GLint level,
   GLenum internal_format,
   GLsizei width,
   GLsizei height,
   GLint border,
   GLenum format,
   GLenum type,
   const void* pixels,
   uint32 pixels_size) {
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexImage2D", target, "target");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(internal_format)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glTexImage2D", "internal_format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexImage2D", internal_format, "internal_format");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
-    SetGLError(GL_INVALID_ENUM, "glTexImage2D", "format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexImage2D", format, "format");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glTexImage2D", "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexImage2D", type, "type");
     return error::kNoError;
   }
   if (format != internal_format) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexImage2D", "format != internalFormat");
     return error::kNoError;
   }
   if (!ValidateTextureParameters("glTexImage2D", target, format, type, level)) {
     return error::kNoError;
   }
@@ skipping 486 matching lines @@
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexSubImage2D", format, "format");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");
     return error::kNoError;
   }
   if (pixels == NULL) {
     return error::kOutOfBounds;
   }
   DoTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
   return error::kNoError;
 }
 
@@ skipping 12 matching lines @@
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   if (!validators_->texture_target.IsValid(target)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "target GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "format GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexSubImage2D", format, "format");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");
     return error::kNoError;
   }
   if (pixels == NULL) {
     return error::kOutOfBounds;
   }
   DoTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
     uint32 immediate_data_size, const gles2::GetVertexAttribPointerv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef gles2::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   if (!validators_->vertex_pointer.IsValid(pname)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glGetVertexAttribPointerv", "pname GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum("glGetVertexAttribPointerv", pname, "pname");
     return error::kNoError;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetVertexAttribPointerv", "index out of range.");
     return error::kNoError;
   }
   result->SetNumResults(1);
   *result->GetData() =
       vertex_attrib_manager_->GetVertexAttribInfo(index)->offset();
@@ skipping 116 matching lines @@
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
   if (!validators_->shader_type.IsValid(shader_type)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glGetShaderPrecisionFormat", "shader_type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum(
+        "glGetShaderPrecisionFormat", shader_type, "shader_type");
     return error::kNoError;
   }
   if (!validators_->shader_precision.IsValid(precision_type)) {
-    SetGLError(GL_INVALID_ENUM,
-               "glGetShaderPrecisionFormat", "precision_type GL_INVALID_ENUM");
+    SetGLErrorInvalidEnum(
+        "glGetShaderPrecisionFormat", precision_type, "precision_type");
     return error::kNoError;
   }
 
   result->success = 1;  // true
   switch (precision_type) {
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
       // These values are for a 32-bit twos-complement integer format.
       result->min_range = 31;
@@ skipping 377 matching lines @@
   // can't change them between the time we validate them and the time we use
   // them.
   scoped_array<GLenum> enums(new GLenum[count]);
   memcpy(enums.get(), pnames, pnames_size);
 
   // Count up the space needed for the result.
   uint32 num_results = 0;
   for (GLuint ii = 0; ii < count; ++ii) {
     uint32 num = util_.GLGetNumValuesReturned(enums[ii]);
     if (num == 0) {
-      SetGLError(GL_INVALID_ENUM,
-                 "glGetMulitpleCHROMIUM", "pname GL_INVALID_ENUM");
+      SetGLErrorInvalidEnum("glGetMulitpleCHROMIUM", enums[ii], "pname");
       return error::kNoError;
     }
     // Num will never be more than 4.
     DCHECK_LE(num, 4u);
     if (!SafeAdd(num_results, num, &num_results)) {
       return error::kOutOfBounds;
     }
   }
 
   uint32 result_size = 0;
@@ skipping 749 matching lines @@
 }
 
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu