Enforce compressed texture restrictions

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 <map>
 #include <set>
@@ skipping 601 matching lines @@
     }
   }
 
   if (error != GL_NO_ERROR) {
     // There was an error, clear the corresponding wrapped error.
     error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
   }
   return error;
 }
 
-void GLES2Implementation::SetGLError(GLenum error, const char* msg) {
+void GLES2Implementation::SetGLError(
+    GLenum error, const char* function_name, const char* msg) {
   GPU_CLIENT_LOG("[" << this << "] Client Synthesized Error: "
-                 << GLES2Util::GetStringError(error) << ": " << msg);
+                 << GLES2Util::GetStringError(error) << ": "
+                 << function_name << ": " << msg);
   if (msg) {
     last_error_ = msg;
   }
   if (error_message_callback_) {
     std::string temp(GLES2Util::GetStringError(error)  + " : " +
-                     (msg ? msg : ""));
+                     function_name + ": " + (msg ? msg : ""));
     error_message_callback_->OnErrorMessage(temp.c_str(), 0);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
 bool GLES2Implementation::GetBucketContents(uint32 bucket_id,
                                             std::vector<int8>* data) {
   TRACE_EVENT0("gpu", "GLES2::GetBucketContents");
   GPU_DCHECK(data);
   const uint32 kStartSize = 32 * 1024;
@@ skipping 329 matching lines @@
 
 void GLES2Implementation::DrawElements(
     GLenum mode, GLsizei count, GLenum type, const void* indices) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glDrawElements("
       << GLES2Util::GetStringDrawMode(mode) << ", "
       << count << ", "
       << GLES2Util::GetStringIndexType(type) << ", "
       << static_cast<const void*>(indices) << ")");
   if (count < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawElements: count less than 0.");
+    SetGLError(GL_INVALID_VALUE, "glDrawElements", "count less than 0.");
     return;
   }
   if (count == 0) {
     return;
   }
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   bool have_client_side =
       client_side_buffer_helper_->HaveEnabledClientSideBuffers();
   GLsizei num_elements = 0;
   GLuint offset = ToGLuint(indices);
@@ skipping 194 matching lines @@
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 bool GLES2Implementation::DeleteProgramHelper(GLuint program) {
   if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
       this, 1, &program, &GLES2Implementation::DeleteProgramStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteProgram: id not created by this context.");
+        "glDeleteProgram", "id not created by this context.");
     return false;
   }
   return true;
 }
 
 void GLES2Implementation::DeleteProgramStub(
     GLsizei n, const GLuint* programs) {
   GPU_DCHECK_EQ(1, n);
   share_group_->program_info_manager()->DeleteInfo(programs[0]);
   helper_->DeleteProgram(programs[0]);
 }
 
 bool GLES2Implementation::DeleteShaderHelper(GLuint shader) {
   if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
       this, 1, &shader, &GLES2Implementation::DeleteShaderStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteShader: id not created by this context.");
+        "glDeleteShader", "id not created by this context.");
     return false;
   }
   return true;
 }
 
 void GLES2Implementation::DeleteShaderStub(
     GLsizei n, const GLuint* shaders) {
   GPU_DCHECK_EQ(1, n);
   share_group_->program_info_manager()->DeleteInfo(shaders[0]);
   helper_->DeleteShader(shaders[0]);
@@ skipping 78 matching lines @@
 void GLES2Implementation::ShaderBinary(
     GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary,
     GLsizei length) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glShaderBinary(" << n << ", "
       << static_cast<const void*>(shaders) << ", "
       << GLES2Util::GetStringEnum(binaryformat) << ", "
       << static_cast<const void*>(binary) << ", "
       << length << ")");
   if (n < 0) {
-    SetGLError(GL_INVALID_VALUE, "glShaderBinary n < 0.");
+    SetGLError(GL_INVALID_VALUE, "glShaderBinary", "n < 0.");
     return;
   }
   if (length < 0) {
-    SetGLError(GL_INVALID_VALUE, "glShaderBinary length < 0.");
+    SetGLError(GL_INVALID_VALUE, "glShaderBinary", "length < 0.");
     return;
   }
   // TODO(gman): ShaderBinary should use buckets.
   unsigned int shader_id_size = n * sizeof(*shaders);
   ScopedTransferBufferArray<GLint> buffer(
       shader_id_size + length, helper_, transfer_buffer_);
   if (!buffer.valid() || buffer.num_elements() != shader_id_size + length) {
-    SetGLError(GL_OUT_OF_MEMORY, "glShaderBinary: out of memory.");
+    SetGLError(GL_OUT_OF_MEMORY, "glShaderBinary", "out of memory.");
     return;
   }
   void* shader_ids = buffer.elements();
   void* shader_data = buffer.elements() + shader_id_size;
   memcpy(shader_ids, shaders, shader_id_size);
   memcpy(shader_data, binary, length);
   helper_->ShaderBinary(
       n,
       buffer.shm_id(),
       buffer.offset(),
@@ skipping 92 matching lines @@
           GPU_CLIENT_LOG("  " << ii << ": ---\n" << str << "\n---");
         } else {
           GPU_CLIENT_LOG("  " << ii << ": ---\n" << source[ii] << "\n---");
         }
       } else {
         GPU_CLIENT_LOG("  " << ii << ": NULL");
       }
     }
   });
   if (count < 0) {
-    SetGLError(GL_INVALID_VALUE, "glShaderSource count < 0");
+    SetGLError(GL_INVALID_VALUE, "glShaderSource", "count < 0");
     return;
   }
   if (shader == 0) {
-    SetGLError(GL_INVALID_VALUE, "glShaderSource shader == 0");
+    SetGLError(GL_INVALID_VALUE, "glShaderSource", "shader == 0");
     return;
   }
 
   // Compute the total size.
   uint32 total_size = 1;
   for (GLsizei ii = 0; ii < count; ++ii) {
     if (source[ii]) {
       total_size += (length && length[ii] >= 0) ?
           static_cast<size_t>(length[ii]) : strlen(source[ii]);
     }
@@ skipping 28 matching lines @@
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 void GLES2Implementation::BufferDataHelper(
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
   if (size == 0) {
     return;
   }
 
   if (size < 0) {
-    SetGLError(GL_INVALID_VALUE, "glBufferData: size < 0");
+    SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0");
     return;
   }
 
   // If there is no data just send BufferData
   if (!data) {
     helper_->BufferData(target, size, 0, 0, usage);
     return;
   }
 
   // See if we can send all at once.
@@ skipping 29 matching lines @@
   BufferDataHelper(target, size, data, usage);
 }
 
 void GLES2Implementation::BufferSubDataHelper(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   if (size == 0) {
     return;
   }
 
   if (size < 0) {
-    SetGLError(GL_INVALID_VALUE, "glBufferSubData: size < 0");
+    SetGLError(GL_INVALID_VALUE, "glBufferSubData", "size < 0");
     return;
   }
 
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
   BufferSubDataHelperImpl(target, offset, size, data, &buffer);
 }
 
 void GLES2Implementation::BufferSubDataHelperImpl(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data,
     ScopedTransferBufferPtr* buffer) {
@@ skipping 33 matching lines @@
     GLsizei height, GLint border, GLsizei image_size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glCompressedTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringCompressedTextureFormat(internalformat) << ", "
       << width << ", " << height << ", " << border << ", "
       << image_size << ", "
       << static_cast<const void*>(data) << ")");
   if (width < 0 || height < 0 || level < 0) {
-    SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D dimension < 0");
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
   SetBucketContents(kResultBucketId, data, image_size);
   helper_->CompressedTexImage2DBucket(
       target, level, internalformat, width, height, border, kResultBucketId);
   // Free the bucket. This is not required but it does free up the memory.
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 void GLES2Implementation::CompressedTexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLsizei image_size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glCompressedTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringCompressedTextureFormat(format) << ", "
       << image_size << ", "
       << static_cast<const void*>(data) << ")");
   if (width < 0 || height < 0 || level < 0) {
-    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D dimension < 0");
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "dimension < 0");
     return;
   }
   SetBucketContents(kResultBucketId, data, image_size);
   helper_->CompressedTexSubImage2DBucket(
       target, level, xoffset, yoffset, width, height, format, kResultBucketId);
   // Free the bucket. This is not required but it does free up the memory.
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
   helper_->SetBucketSize(kResultBucketId, 0);
 }
@@ skipping 40 matching lines @@
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
       << width << ", " << height << ", " << border << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D dimension < 0");
+    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
     return;
   }
   uint32 size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, format, type, unpack_alignment_, &size,
           &unpadded_row_size, &padded_row_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D: image size too large");
+    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "image size too large");
     return;
   }
 
   // If there's no data just issue TexImage2D
   if (!pixels) {
     helper_->TexImage2D(
        target, level, internalformat, width, height, border, format, type,
        0, 0);
     return;
   }
 
   // compute the advance bytes per row for the src pixels
   uint32 src_padded_row_size;
   if (unpack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         unpack_row_length_, format, type, unpack_alignment_,
         &src_padded_row_size)) {
-      SetGLError(GL_INVALID_VALUE, "glTexImage2D: unpack row length too large");
+      SetGLError(
+          GL_INVALID_VALUE, "glTexImage2D", "unpack row length too large");
       return;
     }
   } else {
     src_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip rows and skip pixels
   pixels = reinterpret_cast<const int8*>(pixels) +
       unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
@@ skipping 34 matching lines @@
   GPU_CLIENT_LOG("[" << this << "] glTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D dimension < 0");
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
 
   uint32 temp_size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
         width, height, format, type, unpack_alignment_, &temp_size,
         &unpadded_row_size, &padded_row_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "size to large");
     return;
   }
 
   // compute the advance bytes per row for the src pixels
   uint32 src_padded_row_size;
   if (unpack_row_length_ > 0) {
     if (!GLES2Util::ComputeImagePaddedRowSize(
         unpack_row_length_, format, type, unpack_alignment_,
         &src_padded_row_size)) {
-      SetGLError(GL_INVALID_VALUE, "glTexImage2D: unpack row length too large");
+      SetGLError(
+          GL_INVALID_VALUE, "glTexImage2D", "unpack row length too large");
       return;
     }
   } else {
     src_padded_row_size = padded_row_size;
   }
 
   // advance pixels pointer past the skip rows and skip pixels
   pixels = reinterpret_cast<const int8*>(pixels) +
       unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
@@ skipping 104 matching lines @@
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glGetActiveAttrib("
       << program << ", " << index << ", " << bufsize << ", "
       << static_cast<const void*>(length) << ", "
       << static_cast<const void*>(size) << ", "
       << static_cast<const void*>(type) << ", "
       << static_cast<const void*>(name) << ", ");
   if (bufsize < 0) {
-    SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib: bufsize < 0");
+    SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib", "bufsize < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetActiveAttrib");
   bool success = share_group_->program_info_manager()->GetActiveAttrib(
         this, program, index, bufsize, length, size, type, name);
   if (success) {
     if (size) {
       GPU_CLIENT_LOG("  size: " << *size);
     }
     if (type) {
@@ skipping 49 matching lines @@
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glGetActiveUniform("
       << program << ", " << index << ", " << bufsize << ", "
       << static_cast<const void*>(length) << ", "
       << static_cast<const void*>(size) << ", "
       << static_cast<const void*>(type) << ", "
       << static_cast<const void*>(name) << ", ");
   if (bufsize < 0) {
-    SetGLError(GL_INVALID_VALUE, "glGetActiveUniform: bufsize < 0");
+    SetGLError(GL_INVALID_VALUE, "glGetActiveUniform", "bufsize < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetActiveUniform");
   bool success = share_group_->program_info_manager()->GetActiveUniform(
       this, program, index, bufsize, length, size, type, name);
   if (success) {
     if (size) {
       GPU_CLIENT_LOG("  size: " << *size);
     }
     if (type) {
       GPU_CLIENT_LOG("  type: " << GLES2Util::GetStringEnum(*type));
     }
     if (name) {
       GPU_CLIENT_LOG("  name: " << name);
     }
   }
 }
 
 void GLES2Implementation::GetAttachedShaders(
     GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glGetAttachedShaders("
       << program << ", " << maxcount << ", "
       << static_cast<const void*>(count) << ", "
       << static_cast<const void*>(shaders) << ", ");
   if (maxcount < 0) {
-    SetGLError(GL_INVALID_VALUE, "glGetAttachedShaders: maxcount < 0");
+    SetGLError(GL_INVALID_VALUE, "glGetAttachedShaders", "maxcount < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetAttachedShaders");
   typedef gles2::GetAttachedShaders::Result Result;
   uint32 size = Result::ComputeSize(maxcount);
   Result* result = static_cast<Result*>(transfer_buffer_->Alloc(size));
   if (!result) {
     return;
   }
   result->SetNumResults(0);
@@ skipping 153 matching lines @@
     GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
     GLenum type, void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glReadPixels("
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringReadPixelFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (width < 0 || height < 0) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions < 0");
+    SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return;
   }
   if (width == 0 || height == 0) {
     return;
   }
 
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
   TRACE_EVENT0("gpu", "GLES2::ReadPixels");
   typedef gles2::ReadPixels::Result Result;
 
   int8* dest = reinterpret_cast<int8*>(pixels);
   uint32 temp_size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, 2, format, type, pack_alignment_, &temp_size, &unpadded_row_size,
       &padded_row_size)) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels: size too large.");
+    SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
     return;
   }
   // Transfer by rows.
   // The max rows we can transfer.
   while (height) {
     GLsizei desired_size = padded_row_size * height - 1 + unpadded_row_size;
     ScopedTransferBufferPtr buffer(desired_size, helper_, transfer_buffer_);
     if (!buffer.valid()) {
       return;
     }
@@ skipping 42 matching lines @@
   }
 }
 
 void GLES2Implementation::ActiveTexture(GLenum texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] 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.");
+    SetGLError(
+        GL_INVALID_ENUM, "glActiveTexture", "texture_unit out of range.");
     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 81 matching lines @@
   return false;
 }
 #endif
 
 void GLES2Implementation::DeleteBuffersHelper(
     GLsizei n, const GLuint* buffers) {
   if (!GetIdHandler(id_namespaces::kBuffers)->FreeIds(
       this, n, buffers, &GLES2Implementation::DeleteBuffersStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteBuffers: id not created by this context.");
+        "glDeleteBuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (buffers[ii] == bound_array_buffer_id_) {
       bound_array_buffer_id_ = 0;
     }
     if (buffers[ii] == bound_element_array_buffer_id_) {
       bound_element_array_buffer_id_ = 0;
     }
   }
 }
 
 void GLES2Implementation::DeleteBuffersStub(
     GLsizei n, const GLuint* buffers) {
   helper_->DeleteBuffersImmediate(n, buffers);
 }
 
 
 void GLES2Implementation::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* framebuffers) {
   if (!GetIdHandler(id_namespaces::kFramebuffers)->FreeIds(
       this, n, framebuffers, &GLES2Implementation::DeleteFramebuffersStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteFramebuffers: id not created by this context.");
+        "glDeleteFramebuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (framebuffers[ii] == bound_framebuffer_) {
       bound_framebuffer_ = 0;
     }
   }
 }
 
 void GLES2Implementation::DeleteFramebuffersStub(
     GLsizei n, const GLuint* framebuffers) {
   helper_->DeleteFramebuffersImmediate(n, framebuffers);
 }
 
 void GLES2Implementation::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* renderbuffers) {
   if (!GetIdHandler(id_namespaces::kRenderbuffers)->FreeIds(
       this, n, renderbuffers, &GLES2Implementation::DeleteRenderbuffersStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteRenderbuffers: id not created by this context.");
+        "glDeleteRenderbuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (renderbuffers[ii] == bound_renderbuffer_) {
       bound_renderbuffer_ = 0;
     }
   }
 }
 
 void GLES2Implementation::DeleteRenderbuffersStub(
     GLsizei n, const GLuint* renderbuffers) {
   helper_->DeleteRenderbuffersImmediate(n, renderbuffers);
 }
 
 void GLES2Implementation::DeleteTexturesHelper(
     GLsizei n, const GLuint* textures) {
   if (!GetIdHandler(id_namespaces::kTextures)->FreeIds(
       this, n, textures, &GLES2Implementation::DeleteTexturesStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteTextures: id not created by this context.");
+        "glDeleteTextures", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     for (GLint tt = 0;
          tt < gl_state_.int_state.max_combined_texture_image_units;
          ++tt) {
       TextureUnit& unit = texture_units_[tt];
       if (textures[ii] == unit.bound_texture_2d) {
         unit.bound_texture_2d = 0;
       }
@@ skipping 27 matching lines @@
 #endif
   helper_->EnableVertexAttribArray(index);
 }
 
 void GLES2Implementation::DrawArrays(GLenum mode, GLint first, GLsizei count) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glDrawArrays("
       << GLES2Util::GetStringDrawMode(mode) << ", "
       << first << ", " << count << ")");
   if (count < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawArrays: count < 0");
+    SetGLError(GL_INVALID_VALUE, "glDrawArrays", "count < 0");
     return;
   }
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   bool have_client_side =
       client_side_buffer_helper_->HaveEnabledClientSideBuffers();
   if (have_client_side) {
     client_side_buffer_helper_->SetupSimulatedClientSideBuffers(
         this, helper_, first + count, 0);
   }
 #endif
@@ skipping 30 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");
+      SetGLError(GL_INVALID_ENUM, "glGetVertexAttrib", "invalid enum");
       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("[" << this << "] glGetVertexAttribfv("
@@ skipping 80 matching lines @@
 
 void* GLES2Implementation::MapBufferSubDataCHROMIUM(
     GLuint target, GLintptr offset, GLsizeiptr size, GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] 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, "MapBufferSubDataCHROMIUM: bad access mode");
+    SetGLError(
+        GL_INVALID_ENUM, "glMapBufferSubDataCHROMIUM", "bad access mode");
     return NULL;
   }
   if (offset < 0 || size < 0) {
-    SetGLError(GL_INVALID_VALUE, "MapBufferSubDataCHROMIUM: bad range");
+    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) {
-    SetGLError(GL_OUT_OF_MEMORY, "MapBufferSubDataCHROMIUM: out of memory");
+    SetGLError(GL_OUT_OF_MEMORY, "glMapBufferSubDataCHROMIUM", "out of memory");
     return NULL;
   }
 
   std::pair<MappedBufferMap::iterator, bool> result =
      mapped_buffers_.insert(std::make_pair(
          mem,
          MappedBuffer(
              access, shm_id, mem, shm_offset, target, offset, size)));
   GPU_DCHECK(result.second);
   GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
       "[" << this << "] glUnmapBufferSubDataCHROMIUM(" << mem << ")");
   MappedBufferMap::iterator it = mapped_buffers_.find(mem);
   if (it == mapped_buffers_.end()) {
     SetGLError(
-        GL_INVALID_VALUE, "UnmapBufferSubDataCHROMIUM: buffer not mapped");
+        GL_INVALID_VALUE, "UnmapBufferSubDataCHROMIUM", "buffer not mapped");
     return;
   }
   const MappedBuffer& mb = it->second;
   helper_->BufferSubData(
       mb.target, mb.offset, mb.size, mb.shm_id, mb.shm_offset);
   mapped_memory_->FreePendingToken(mb.shm_memory, helper_->InsertToken());
   // Flushing after unmap lets the service side start processing commands
   // sooner. However, on lowend devices, the thread thrashing causes is
   // worse than the latency hit.
 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
@@ skipping 14 matching lines @@
      GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] 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, "MapTexSubImage2DCHROMIUM: bad access mode");
+    SetGLError(
+        GL_INVALID_ENUM, "glMapTexSubImage2DCHROMIUM", "bad access mode");
     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, "MapTexSubImage2DCHROMIUM: bad dimensions");
+    SetGLError(
+        GL_INVALID_VALUE, "glMapTexSubImage2DCHROMIUM", "bad dimensions");
     return NULL;
   }
   uint32 size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, unpack_alignment_, &size, NULL, NULL)) {
     SetGLError(
-        GL_INVALID_VALUE, "MapTexSubImage2DCHROMIUM: image size too large");
+        GL_INVALID_VALUE, "glMapTexSubImage2DCHROMIUM", "image size too large");
     return NULL;
   }
   int32 shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
-    SetGLError(GL_OUT_OF_MEMORY, "MapTexSubImage2DCHROMIUM: out of memory");
+    SetGLError(GL_OUT_OF_MEMORY, "glMapTexSubImage2DCHROMIUM", "out of memory");
     return NULL;
   }
 
   std::pair<MappedTextureMap::iterator, bool> result =
      mapped_textures_.insert(std::make_pair(
          mem,
          MappedTexture(
              access, shm_id, mem, shm_offset,
              target, level, xoffset, yoffset, width, height, format, type)));
   GPU_DCHECK(result.second);
   GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapTexSubImage2DCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
       "[" << this << "] glUnmapTexSubImage2DCHROMIUM(" << mem << ")");
   MappedTextureMap::iterator it = mapped_textures_.find(mem);
   if (it == mapped_textures_.end()) {
     SetGLError(
-        GL_INVALID_VALUE, "UnmapTexSubImage2DCHROMIUM: texture not mapped");
+        GL_INVALID_VALUE, "UnmapTexSubImage2DCHROMIUM", "texture not mapped");
     return;
   }
   const MappedTexture& mt = it->second;
   helper_->TexSubImage2D(
       mt.target, mt.level, mt.xoffset, mt.yoffset, mt.width, mt.height,
       mt.format, mt.type, mt.shm_id, mt.shm_offset, GL_FALSE);
   mapped_memory_->FreePendingToken(mt.shm_memory, helper_->InsertToken());
 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
   helper_->CommandBufferHelper::Flush();
 #endif
@@ skipping 70 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");
+      SetGLError(GL_INVALID_ENUM, "glGetMultipleIntegervCHROMIUM", "bad pname");
       return;
     }
     num_results += num;
   }
   if (static_cast<size_t>(size) != num_results * sizeof(GLint)) {
-    SetGLError(GL_INVALID_VALUE, "glGetMultipleIntegervCHROMIUM: bad size");
+    SetGLError(GL_INVALID_VALUE, "glGetMultipleIntegervCHROMIUM", "bad size");
     return;
   }
   for (int ii = 0; ii < num_results; ++ii) {
     if (results[ii] != 0) {
       SetGLError(GL_INVALID_VALUE,
-                 "glGetMultipleIntegervCHROMIUM: results not set to zero.");
+                 "glGetMultipleIntegervCHROMIUM", "results not set to zero.");
       return;
     }
   }
   uint32 size_needed =
       count * sizeof(pnames[0]) + num_results * sizeof(results[0]);
   void* buffer = transfer_buffer_->Alloc(size_needed);
   if (!buffer) {
     return;
   }
   GLenum* pnames_buffer = static_cast<GLenum*>(buffer);
@@ skipping 25 matching lines @@
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetProgramInfoCHROMIUM(program, kResultBucketId);
   GetBucketContents(kResultBucketId, result);
 }
 
 void GLES2Implementation::GetProgramInfoCHROMIUM(
     GLuint program, GLsizei bufsize, GLsizei* size, void* info) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   if (bufsize < 0) {
-    SetGLError(GL_INVALID_VALUE, "glProgramInfoCHROMIUM: bufsize less than 0.");
+    SetGLError(
+        GL_INVALID_VALUE, "glProgramInfoCHROMIUM", "bufsize less than 0.");
     return;
   }
   if (size == NULL) {
-    SetGLError(GL_INVALID_VALUE, "glProgramInfoCHROMIUM: size is null.");
+    SetGLError(GL_INVALID_VALUE, "glProgramInfoCHROMIUM", "size is null.");
     return;
   }
   // Make sure they've set size to 0 else the value will be undefined on
   // lost context.
   GPU_DCHECK(*size == 0);
   std::vector<int8> result;
   GetProgramInfoCHROMIUMHelper(program, &result);
   if (result.empty()) {
     return;
   }
   *size = result.size();
   if (!info) {
     return;
   }
   if (static_cast<size_t>(bufsize) < result.size()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glProgramInfoCHROMIUM: bufsize is too small for result.");
+               "glProgramInfoCHROMIUM", "bufsize is too small for result.");
     return;
   }
   memcpy(info, &result[0], result.size());
 }
 
 GLuint GLES2Implementation::CreateStreamTextureCHROMIUM(GLuint texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] CreateStreamTextureCHROMIUM("
       << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::CreateStreamTextureCHROMIUM");
@@ skipping 37 matching lines @@
   }
 }
 
 void GLES2Implementation::DeleteQueriesEXTHelper(
     GLsizei n, const GLuint* queries) {
   // TODO(gman): Remove this as queries are not shared resources.
   if (!GetIdHandler(id_namespaces::kQueries)->FreeIds(
       this, n, queries, &GLES2Implementation::DeleteQueriesStub)) {
     SetGLError(
         GL_INVALID_VALUE,
-        "glDeleteTextures: id not created by this context.");
+        "glDeleteTextures", "id not created by this context.");
     return;
   }
   // When you delete a query you can't mark its memory as unused until it's
   // completed.
   // Note: If you don't do this you won't mess up the service but you will mess
   // up yourself.
 
   // TODO(gman): Consider making this faster by putting pending quereies
   // on some queue to be removed when they are finished.
   bool query_pending = false;
@@ skipping 36 matching lines @@
 
 void GLES2Implementation::BeginQueryEXT(GLenum target, GLuint id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] BeginQueryEXT("
                  << GLES2Util::GetStringQueryTarget(target)
                  << ", " << id << ")");
 
   // if any outstanding queries INV_OP
   if (current_query_) {
     SetGLError(
-        GL_INVALID_OPERATION, "glBeginQueryEXT: query already in progress");
+        GL_INVALID_OPERATION, "glBeginQueryEXT", "query already in progress");
     return;
   }
 
   // id = 0 INV_OP
   if (id == 0) {
-    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: id is 0");
+    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "id is 0");
     return;
   }
 
   // TODO(gman) if id not GENned INV_OPERATION
 
   // if id does not have an object
   QueryTracker::Query* query = query_tracker_->GetQuery(id);
   if (!query) {
     query = query_tracker_->CreateQuery(id, target);
   } else if (query->target() != target) {
-    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: target does not match");
+    SetGLError(
+        GL_INVALID_OPERATION, "glBeginQueryEXT", "target does not match");
     return;
   }
 
   current_query_ = query;
 
   // init memory, inc count
   query->MarkAsActive();
 
   // tell service about id, shared memory and count
   helper_->BeginQueryEXT(target, id, query->shm_id(), query->shm_offset());
 }
 
 void GLES2Implementation::EndQueryEXT(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] EndQueryEXT("
                  << GLES2Util::GetStringQueryTarget(target) << ")");
 
   if (!current_query_) {
-    SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT: no active query");
+    SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT", "no active query");
     return;
   }
 
   if (current_query_->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
-               "glEndQueryEXT: target does not match active query");
+               "glEndQueryEXT", "target does not match active query");
     return;
   }
 
   helper_->EndQueryEXT(target, current_query_->submit_count());
   current_query_->MarkAsPending(helper_->InsertToken());
   current_query_ = NULL;
 }
 
 void GLES2Implementation::GetQueryivEXT(
     GLenum target, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] 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");
+    SetGLError(GL_INVALID_ENUM, "glGetQueryivEXT", "invalid 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();
   GPU_CLIENT_LOG("[" << this << "] GetQueryivEXT(" << id << ", "
                  << GLES2Util::GetStringQueryObjectParameter(pname) << ", "
                  << static_cast<const void*>(params) << ")");
 
   QueryTracker::Query* query = query_tracker_->GetQuery(id);
   if (!query) {
-    SetGLError(GL_INVALID_OPERATION, "glQueryObjectuivEXT: unknown query id");
+    SetGLError(GL_INVALID_OPERATION, "glQueryObjectuivEXT", "unknown query id");
     return;
   }
 
   if (query == current_query_) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glQueryObjectuivEXT: query active. Did you to call glEndQueryEXT?");
+        "glQueryObjectuivEXT", "query active. Did you to call glEndQueryEXT?");
     return;
   }
 
   if (query->NeverUsed()) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glQueryObjectuivEXT: Never used. Did you call glBeginQueryEXT?");
+        "glQueryObjectuivEXT", "Never used. Did you call glBeginQueryEXT?");
     return;
   }
 
   switch (pname) {
     case GL_QUERY_RESULT_EXT:
       if (!query->CheckResultsAvailable(helper_)) {
         helper_->WaitForToken(query->token());
         if (!query->CheckResultsAvailable(helper_)) {
           // TODO(gman): Speed this up.
           Finish();
           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");
+      SetGLError(GL_INVALID_ENUM, "glQueryObjectuivEXT", "unknown 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("[" << this << "] glDrawArraysInstancedANGLE("
       << GLES2Util::GetStringDrawMode(mode) << ", "
       << first << ", " << count << ", " << primcount << ")");
   if (count < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawArraysInstancedANGLE: count < 0");
+    SetGLError(GL_INVALID_VALUE, "glDrawArraysInstancedANGLE", "count < 0");
     return;
   }
   if (primcount < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawArraysInstancedANGLE: primcount < 0");
+    SetGLError(GL_INVALID_VALUE, "glDrawArraysInstancedANGLE", "primcount < 0");
     return;
   }
   if (primcount == 0) {
     return;
   }
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   bool have_client_side =
       client_side_buffer_helper_->HaveEnabledClientSideBuffers();
   if (have_client_side) {
     client_side_buffer_helper_->SetupSimulatedClientSideBuffers(
@@ skipping 14 matching lines @@
     GLsizei primcount) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glDrawElementsInstancedANGLE("
       << GLES2Util::GetStringDrawMode(mode) << ", "
       << count << ", "
       << GLES2Util::GetStringIndexType(type) << ", "
       << static_cast<const void*>(indices) << ", "
       << primcount << ")");
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE,
-               "glDrawElementsInstancedANGLE: count less than 0.");
+               "glDrawElementsInstancedANGLE", "count less than 0.");
     return;
   }
   if (count == 0) {
     return;
   }
   if (primcount < 0) {
     SetGLError(GL_INVALID_VALUE,
-               "glDrawElementsInstancedANGLE: primcount < 0");
+               "glDrawElementsInstancedANGLE", "primcount < 0");
     return;
   }
   if (primcount == 0) {
     return;
   }
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   bool have_client_side =
       client_side_buffer_helper_->HaveEnabledClientSideBuffers();
   GLsizei num_elements = 0;
   GLuint offset = ToGLuint(indices);
@@ skipping 42 matching lines @@
   helper_->GenMailboxCHROMIUM(kResultBucketId);
 
   std::vector<GLbyte> result;
   GetBucketContents(kResultBucketId, &result);
 
   std::copy(result.begin(), result.end(), mailbox);
 }
 
 }  // namespace gles2
 }  // namespace gpu