Add ENUM value to synthesized GL_INVALID_ENUM errors

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 659 matching lines @@
     last_error_ = msg;
   }
   if (error_message_callback_) {
     std::string temp(GLES2Util::GetStringError(error)  + " : " +
                      function_name + ": " + (msg ? msg : ""));
     error_message_callback_->OnErrorMessage(temp.c_str(), 0);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
+void GLES2Implementation::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());
+}
+
 bool GLES2Implementation::GetBucketContents(uint32 bucket_id,
                                             std::vector<int8>* data) {
   TRACE_EVENT0("gpu", "GLES2::GetBucketContents");
   GPU_DCHECK(data);
   const uint32 kStartSize = 32 * 1024;
   ScopedTransferBufferPtr buffer(kStartSize, helper_, transfer_buffer_);
   if (!buffer.valid()) {
     return false;
   }
   typedef cmd::GetBucketStart::Result Result;
@@ skipping 1656 matching lines @@
   }
 }
 
 void GLES2Implementation::ActiveTexture(GLenum texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glActiveTexture("
       << GLES2Util::GetStringEnum(texture) << ")");
   GLuint texture_index = texture - GL_TEXTURE0;
   if (texture_index >= static_cast<GLuint>(
       gl_state_.int_state.max_combined_texture_image_units)) {
-    SetGLError(
-        GL_INVALID_ENUM, "glActiveTexture", "texture_unit out of range.");
+    SetGLErrorInvalidEnum(
+        "glActiveTexture", texture, "texture");
     return;
   }
 
   active_texture_unit_ = texture_index;
   helper_->ActiveTexture(texture);
 }
 
 // NOTE #1: On old versions of OpenGL, calling glBindXXX with an unused id
 // generates a new resource. On newer versions of OpenGL they don't. The code
 // related to binding below will need to change if we switch to the new OpenGL
@@ skipping 248 matching lines @@
       break;
     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
       *param = info->type();
       break;
     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
       *param = info->normalized();
       break;
     case GL_CURRENT_VERTEX_ATTRIB:
       return false;  // pass through to service side.
     default:
-      SetGLError(GL_INVALID_ENUM, "glGetVertexAttrib", "invalid enum");
+      SetGLErrorInvalidEnum("glGetVertexAttrib", pname, "pname");
       break;
   }
   return true;
 }
 #endif  // GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 
 void GLES2Implementation::GetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribfv("
@@ skipping 80 matching lines @@
 
 void* GLES2Implementation::MapBufferSubDataCHROMIUM(
     GLuint target, GLintptr offset, GLsizeiptr size, GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapBufferSubDataCHROMIUM("
       << target << ", " << offset << ", " << size << ", "
       << GLES2Util::GetStringEnum(access) << ")");
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (access != GL_WRITE_ONLY) {
-    SetGLError(
-        GL_INVALID_ENUM, "glMapBufferSubDataCHROMIUM", "bad access mode");
+    SetGLErrorInvalidEnum(
+        "glMapBufferSubDataCHROMIUM", access, "access");
     return NULL;
   }
   if (offset < 0 || size < 0) {
     SetGLError(GL_INVALID_VALUE, "glMapBufferSubDataCHROMIUM", "bad range");
     return NULL;
   }
   int32 shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
@@ skipping 40 matching lines @@
      GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapTexSubImage2DCHROMIUM("
       << target << ", " << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << GLES2Util::GetStringEnum(access) << ")");
   if (access != GL_WRITE_ONLY) {
-    SetGLError(
-        GL_INVALID_ENUM, "glMapTexSubImage2DCHROMIUM", "bad access mode");
+    SetGLErrorInvalidEnum(
+        "glMapTexSubImage2DCHROMIUM", access, "access");
     return NULL;
   }
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glMapTexSubImage2DCHROMIUM", "bad dimensions");
     return NULL;
   }
   uint32 size;
@@ skipping 111 matching lines @@
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (GLuint i = 0; i < count; ++i) {
       GPU_CLIENT_LOG(
           "  " << i << ": " << GLES2Util::GetStringGLState(pnames[i]));
     }
   });
   int num_results = 0;
   for (GLuint ii = 0; ii < count; ++ii) {
     int num = util_.GLGetNumValuesReturned(pnames[ii]);
     if (!num) {
-      SetGLError(GL_INVALID_ENUM, "glGetMultipleIntegervCHROMIUM", "bad pname");
+      SetGLErrorInvalidEnum(
+          "glGetMultipleIntegervCHROMIUM", pnames[ii], "pname");
       return;
     }
     num_results += num;
   }
   if (static_cast<size_t>(size) != num_results * sizeof(GLint)) {
     SetGLError(GL_INVALID_VALUE, "glGetMultipleIntegervCHROMIUM", "bad size");
     return;
   }
   for (int ii = 0; ii < num_results; ++ii) {
     if (results[ii] != 0) {
@@ skipping 241 matching lines @@
 
 void GLES2Implementation::GetQueryivEXT(
     GLenum target, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT("
                  << GLES2Util::GetStringQueryTarget(target) << ", "
                  << GLES2Util::GetStringQueryParameter(pname) << ", "
                  << static_cast<const void*>(params) << ")");
 
   if (pname != GL_CURRENT_QUERY_EXT) {
-    SetGLError(GL_INVALID_ENUM, "glGetQueryivEXT", "invalid pname");
+    SetGLErrorInvalidEnum("glGetQueryivEXT", pname, "pname");
     return;
   }
   *params = (current_query_ && current_query_->target() == target) ?
       current_query_->id() : 0;
   GPU_CLIENT_LOG("  " << *params);
 }
 
 void GLES2Implementation::GetQueryObjectuivEXT(
     GLuint id, GLenum pname, GLuint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
@@ skipping 30 matching lines @@
           FinishHelper();
           GPU_CHECK(query->CheckResultsAvailable(helper_));
         }
       }
       *params = query->GetResult();
       break;
     case GL_QUERY_RESULT_AVAILABLE_EXT:
       *params = query->CheckResultsAvailable(helper_);
       break;
     default:
-      SetGLError(GL_INVALID_ENUM, "glQueryObjectuivEXT", "unknown pname");
+      SetGLErrorInvalidEnum("glQueryObjectuivEXT", pname, "pname");
       break;
   }
   GPU_CLIENT_LOG("  " << *params);
 }
 
 void GLES2Implementation::DrawArraysInstancedANGLE(
     GLenum mode, GLint first, GLsizei count, GLsizei primcount) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawArraysInstancedANGLE("
       << GLES2Util::GetStringDrawMode(mode) << ", "
@@ skipping 143 matching lines @@
 
 void GLES2Implementation::PopGroupMarkerEXT() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPopGroupMarkerEXT()");
   helper_->PopGroupMarkerEXT();
   debug_marker_manager_.PopGroup();
 }
 
 }  // namespace gles2
 }  // namespace gpu