Enforce compressed texture restrictions

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 479 matching lines @@
   virtual bool ResizeOffscreenFrameBuffer(const gfx::Size& size);
   void UpdateParentTextureInfo();
   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* msg);
+  virtual void SetGLError(
+      GLenum error, const char* function_name, const char* msg);
   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);
 
   // Restores the current state to the user's settings.
@@ skipping 259 matching lines @@
     return program_manager()->GetProgramInfo(client_id);
   }
 
   // Gets the program info for the given program. If it's not a program
   // generates a GL error. Returns NULL if not program.
   ProgramManager::ProgramInfo* GetProgramInfoNotShader(
       GLuint client_id, const char* function_name) {
     ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
     if (!info) {
       if (GetShaderInfo(client_id)) {
-        SetGLError(GL_INVALID_OPERATION,
-                   (std::string(function_name) +
-                    ": shader passed for program").c_str());
+        SetGLError(
+            GL_INVALID_OPERATION, function_name, "shader passed for program");
       } else {
-        SetGLError(GL_INVALID_VALUE,
-                   (std::string(function_name) + ": unknown program").c_str());
+        SetGLError(GL_INVALID_VALUE, function_name, "unknown program");
       }
     }
     return info;
   }
 
 
   // Creates a ShaderInfo for the given shader.
   ShaderManager::ShaderInfo* CreateShaderInfo(
       GLuint client_id,
       GLuint service_id,
       GLenum shader_type) {
     return shader_manager()->CreateShaderInfo(
         client_id, service_id, shader_type);
   }
 
   // Gets the shader info for the given shader. Returns NULL if none exists.
   ShaderManager::ShaderInfo* GetShaderInfo(GLuint client_id) {
     return shader_manager()->GetShaderInfo(client_id);
   }
 
   // Gets the shader info for the given shader. If it's not a shader generates a
   // GL error. Returns NULL if not shader.
   ShaderManager::ShaderInfo* GetShaderInfoNotProgram(
       GLuint client_id, const char* function_name) {
     ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
     if (!info) {
       if (GetProgramInfo(client_id)) {
         SetGLError(
-            GL_INVALID_OPERATION,
-            (std::string(function_name) +
-             ": program passed for shader").c_str());
+            GL_INVALID_OPERATION, function_name, "program passed for shader");
       } else {
-        SetGLError(GL_INVALID_VALUE,
-                   (std::string(function_name) + ": unknown shader").c_str());
+        SetGLError(
+            GL_INVALID_VALUE, function_name, "unknown shader");
       }
     }
     return info;
   }
 
   // Creates a buffer info for the given buffer.
   void CreateBufferInfo(GLuint client_id, GLuint service_id) {
     return buffer_manager()->CreateBufferInfo(client_id, service_id);
   }
 
@@ skipping 352 matching lines @@
   // make sure there are no native GL errors before calling some GL function
   // so that on return we know any error generated was for that specific
   // command.
   void CopyRealGLErrorsToWrapper();
 
   // Clear all real GL errors. This is to prevent the client from seeing any
   // errors caused by GL calls that it was not responsible for issuing.
   void ClearRealGLErrors();
 
   // Checks if the current program and vertex attributes are valid for drawing.
-  bool IsDrawValid(GLuint max_vertex_accessed, GLsizei primcount);
+  bool IsDrawValid(
+      const char* function_name, GLuint max_vertex_accessed, GLsizei primcount);
 
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
-      GLuint max_vertex_accessed, bool* simulated);
+      const char* function_name, GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForAttrib(GLuint attrib);
 
   // Returns true if textures were set.
   bool SetBlackTextureForNonRenderableTextures();
   void RestoreStateForNonRenderableTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(
+      const char* function_name,
       GLuint max_vertex_accessed, bool* simulated, GLsizei primcount);
   void RestoreStateForSimulatedFixedAttribs();
 
   // Handle DrawArrays and DrawElements for both instanced and non-instanced
   // cases (primcount is 0 for non-instanced).
   error::Error DoDrawArrays(
+      const char* function_name,
       bool instanced, GLenum mode, GLint first, GLsizei count,
       GLsizei primcount);
   error::Error DoDrawElements(
+      const char* function_name,
       bool instanced, GLenum mode, GLsizei count, GLenum type,
       int32 offset, GLsizei primcount);
 
   // Gets the buffer id for a given target.
   BufferManager::BufferInfo* GetBufferInfoForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     BufferManager::BufferInfo* info = target == GL_ARRAY_BUFFER ?
         bound_array_buffer_ : bound_element_array_buffer_;
     return info;
   }
@@ skipping 99 matching lines @@
   void ReleaseIOSurfaceForTexture(GLuint texture_id);
 #endif
 
   // Validates the combination of texture parameters. For example validates that
   // for a given format the specific type, level and targets are valid.
   // Synthesizes the correct GL error if invalid. Returns true if valid.
   bool ValidateTextureParameters(
       const char* function_name,
       GLenum target, GLenum format, GLenum type, GLint level);
 
+  bool ValidateCompressedTexDimensions(
+      const char* function_name,
+      GLint level, GLsizei width, GLsizei height, GLenum format);
+  bool ValidateCompressedTexFuncData(
+      const char* function_name,
+      GLsizei width, GLsizei height, GLenum format, size_t size);
+  bool ValidateCompressedTexSubDimensions(
+    const char* function_name,
+    GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height, GLenum format,
+    TextureManager::TextureInfo* texture);
+
   void LogMessage(const std::string& msg);
   void RenderWarning(const std::string& msg);
   void PerformanceWarning(const std::string& msg);
 
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
@@ skipping 1235 matching lines @@
     return true;
   }
 
   if (framebuffer_manager()->IsComplete(framebuffer)) {
     return true;
   }
 
   GLenum completeness = framebuffer->IsPossiblyComplete();
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     SetGLError(
-        GL_INVALID_FRAMEBUFFER_OPERATION,
-        (std::string(func_name) + " framebuffer incomplete").c_str());
+        GL_INVALID_FRAMEBUFFER_OPERATION, func_name, "framebuffer incomplete");
     return false;
   }
 
   // Are all the attachments cleared?
   if (renderbuffer_manager()->HaveUnclearedRenderbuffers() ||
       texture_manager()->HaveUnclearedMips()) {
     if (!framebuffer->IsCleared()) {
       // Can we clear them?
       if (glCheckFramebufferStatusEXT(target) != GL_FRAMEBUFFER_COMPLETE) {
         SetGLError(
-            GL_INVALID_FRAMEBUFFER_OPERATION,
-            (std::string(func_name) +
-            " framebuffer incomplete (clear)").c_str());
+            GL_INVALID_FRAMEBUFFER_OPERATION, func_name,
+            "framebuffer incomplete (clear)");
         return false;
       }
       ClearUnclearedAttachments(target, framebuffer);
     }
   }
 
   if (!framebuffer_manager()->IsComplete(framebuffer)) {
     if (glCheckFramebufferStatusEXT(target) != GL_FRAMEBUFFER_COMPLETE) {
       SetGLError(
-          GL_INVALID_FRAMEBUFFER_OPERATION,
-          (std::string(func_name) +
-          " framebuffer incomplete (check)").c_str());
+          GL_INVALID_FRAMEBUFFER_OPERATION, func_name,
+          "framebuffer incomplete (check)");
       return false;
     }
     framebuffer_manager()->MarkAsComplete(framebuffer);
   }
 
   // NOTE: At this point we don't know if the framebuffer is complete but
   // we DO know that everything that needs to be cleared has been cleared.
   return true;
 }
 
@@ skipping 513 matching lines @@
 
         GLES2_COMMAND_LIST(GLES2_CMD_OP)
         #undef GLES2_CMD_OP
       }
       if (debug()) {
         GLenum error;
         while ((error = glGetError()) != GL_NO_ERROR) {
           LOG(ERROR) << "[" << this << "] "
                      << "GL ERROR: " << GLES2Util::GetStringEnum(error) << " : "
                      << GetCommandName(command);
-          SetGLError(error, "GL error from driver");
+          SetGLError(error, "DoCommand", "GL error from driver");
         }
       }
     } else {
       result = error::kInvalidArguments;
     }
   } else {
     result = DoCommonCommand(command, arg_count, cmd_data);
   }
   if (result == error::kNoError && current_decoder_error_ != error::kNoError) {
       result = current_decoder_error_;
@@ skipping 34 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.");
+    SetGLError(
+        GL_INVALID_ENUM, "glActiveTexture", "texture_unit out of range.");
     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 10 matching lines @@
       CreateBufferInfo(client_id, service_id);
       info = GetBufferInfo(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kBuffers);
       id_allocator->MarkAsUsed(client_id);
     }
   }
   if (info) {
     if (!buffer_manager()->SetTarget(info, target)) {
       SetGLError(GL_INVALID_OPERATION,
-                 "glBindBuffer: buffer bound to more than 1 target");
+                 "glBindBuffer", "buffer bound to more than 1 target");
       return;
     }
     service_id = info->service_id();
   }
   switch (target) {
     case GL_ARRAY_BUFFER:
       bound_array_buffer_ = info;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_ = info;
@@ skipping 164 matching lines @@
       id_allocator->MarkAsUsed(client_id);
     }
   } else {
     info = texture_manager()->GetDefaultTextureInfo(target);
   }
 
   // Check the texture exists
   // Check that we are not trying to bind it to a different target.
   if (info->target() != 0 && info->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
-               "glBindTexture: texture bound to more than 1 target.");
+               "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
   if (info->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
-               "glBindTexture: illegal target for stream texture.");
+               "glBindTexture", "illegal target for stream texture.");
     return;
   }
   if (info->target() == 0) {
     texture_manager()->SetInfoTarget(info, target);
   }
   glBindTexture(target, info->service_id());
   TextureUnit& unit = texture_units_[active_texture_unit_];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
@@ skipping 22 matching lines @@
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (vertex_attrib_manager_->Enable(index, false)) {
     if (index != 0 ||
         gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
       glDisableVertexAttribArray(index);
     }
   } else {
     SetGLError(GL_INVALID_VALUE,
-               "glDisableVertexAttribArray: index out of range");
+               "glDisableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
   if (vertex_attrib_manager_->Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE,
-               "glEnableVertexAttribArray: index out of range");
+               "glEnableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info ||
       !texture_manager()->CanGenerateMipmaps(info)) {
     SetGLError(GL_INVALID_OPERATION,
-               "glGenerateMipmaps: Can not generate mips");
+               "glGenerateMipmaps", "Can not generate mips");
     return;
   }
 
   if (!texture_manager()->ClearTextureLevel(this, info, target, 0)) {
-    SetGLError(GL_OUT_OF_MEMORY, "glGenerateMipmaps: dimensions too big");
+    SetGLError(GL_OUT_OF_MEMORY, "glGenerateMipmaps", "dimensions too big");
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   // Workaround for Mac driver bug. In the large scheme of things setting
   // glTexParamter twice for glGenerateMipmap is probably not a lage performance
   // hit so there's probably no need to make this conditional. The bug appears
   // to be that if the filtering mode is set to something that doesn't require
   // mipmaps for rendering, or is never set to something other than the default,
   // then glGenerateMipmap misbehaves.
   if (!disable_workarounds_) {
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
   }
   glGenerateMipmapEXT(target);
   if (!disable_workarounds_) {
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, info->min_filter());
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->MarkMipmapsGenerated(info);
   }
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (pname) {
-    case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
-      *num_written = 1;
-      if (params) {
-        *params = GL_RGBA;  // We don't support other formats.
+      case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
+        *num_written = 1;
+        if (params) {
+          *params = GL_RGBA;  // We don't support other formats.
+        }
+        return true;
+      case GL_IMPLEMENTATION_COLOR_READ_TYPE:
+        *num_written = 1;
+        if (params) {
+          *params = GL_UNSIGNED_BYTE;  // We don't support other types.
+        }
+        return true;
+      case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
+        *num_written = 1;
+        if (params) {
+          *params = group_->max_fragment_uniform_vectors();
+        }
+        return true;
+      case GL_MAX_VARYING_VECTORS:
+        *num_written = 1;
+        if (params) {
+          *params = group_->max_varying_vectors();
+        }
+        return true;
+      case GL_MAX_VERTEX_UNIFORM_VECTORS:
+        *num_written = 1;
+        if (params) {
+          *params = group_->max_vertex_uniform_vectors();
+        }
+        return true;
       }
-      return true;
-    case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-      *num_written = 1;
-      if (params) {
-        *params = GL_UNSIGNED_BYTE;  // We don't support other types.
-      }
-      return true;
-    case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
-      *num_written = 1;
-      if (params) {
-        *params = group_->max_fragment_uniform_vectors();
-      }
-      return true;
-    case GL_MAX_VARYING_VECTORS:
-      *num_written = 1;
-      if (params) {
-        *params = group_->max_varying_vectors();
-      }
-      return true;
-    case GL_MAX_VERTEX_UNIFORM_VECTORS:
-      *num_written = 1;
-      if (params) {
-        *params = group_->max_vertex_uniform_vectors();
-      }
-      return true;
-    }
   }
   switch (pname) {
     case GL_MAX_VIEWPORT_DIMS:
       if (offscreen_target_frame_buffer_.get()) {
         *num_written = 2;
         if (params) {
           params[0] = renderbuffer_manager()->max_renderbuffer_size();
           params[1] = renderbuffer_manager()->max_renderbuffer_size();
         }
         return true;
@@ skipping 315 matching lines @@
       program_id, "glGetProgramiv");
   if (!info) {
     return;
   }
   info->GetProgramiv(pname, params);
 }
 
 void GLES2DecoderImpl::DoBindAttribLocation(
     GLuint program, GLuint index, const char* name) {
   if (!StringIsValidForGLES(name)) {
-    SetGLError(GL_INVALID_VALUE, "glBindAttribLocation: Invalid character");
+    SetGLError(GL_INVALID_VALUE, "glBindAttribLocation", "Invalid character");
     return;
   }
   if (ProgramManager::IsInvalidPrefix(name, strlen(name))) {
-    SetGLError(GL_INVALID_OPERATION, "glBindAttribLocation: reserved prefix");
+    SetGLError(GL_INVALID_OPERATION, "glBindAttribLocation", "reserved prefix");
     return;
   }
   if (index >= group_->max_vertex_attribs()) {
-    SetGLError(GL_INVALID_VALUE, "glBindAttribLocation: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glBindAttribLocation", "index out of range");
     return;
   }
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program, "glBindAttribLocation");
   if (!info) {
     return;
   }
   info->SetAttribLocationBinding(name, static_cast<GLint>(index));
   glBindAttribLocation(info->service_id(), index, name);
 }
@@ skipping 48 matching lines @@
     uint32 immediate_data_size, const gles2::DeleteShader& c) {
   GLuint client_id = c.shader;
   if (client_id) {
     ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
     if (info) {
       if (!info->IsDeleted()) {
         glDeleteShader(info->service_id());
         shader_manager()->MarkAsDeleted(info);
       }
     } else {
-      SetGLError(GL_INVALID_VALUE, "glDeleteShader: unknown shader");
+      SetGLError(GL_INVALID_VALUE, "glDeleteShader", "unknown shader");
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteProgram(
     uint32 immediate_data_size, const gles2::DeleteProgram& c) {
   GLuint client_id = c.program;
   if (client_id) {
     ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
     if (info) {
       if (!info->IsDeleted()) {
         program_manager()->MarkAsDeleted(shader_manager(), info);
       }
     } else {
-      SetGLError(GL_INVALID_VALUE, "glDeleteProgram: unknown program");
+      SetGLError(GL_INVALID_VALUE, "glDeleteProgram", "unknown program");
     }
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoDeleteSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
   IdAllocatorInterface* id_allocator = group_->GetIdAllocator(namespace_id);
   for (GLsizei ii = 0; ii < n; ++ii) {
     id_allocator->FreeID(ids[ii]);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteSharedIdsCHROMIUM(
     uint32 immediate_data_size, const gles2::DeleteSharedIdsCHROMIUM& c) {
   GLuint namespace_id = static_cast<GLuint>(c.namespace_id);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* ids = GetSharedMemoryAs<const GLuint*>(
       c.ids_shm_id, c.ids_shm_offset, data_size);
   if (n < 0) {
-    SetGLError(GL_INVALID_VALUE, "DeleteSharedIdsCHROMIUM: n < 0");
+    SetGLError(GL_INVALID_VALUE, "DeleteSharedIdsCHROMIUM", "n < 0");
     return error::kNoError;
   }
   if (ids == NULL) {
     return error::kOutOfBounds;
   }
   DoDeleteSharedIdsCHROMIUM(namespace_id, n, ids);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoGenSharedIdsCHROMIUM(
@@ skipping 16 matching lines @@
   GLuint namespace_id = static_cast<GLuint>(c.namespace_id);
   GLuint id_offset = static_cast<GLuint>(c.id_offset);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* ids = GetSharedMemoryAs<GLuint*>(
       c.ids_shm_id, c.ids_shm_offset, data_size);
   if (n < 0) {
-    SetGLError(GL_INVALID_VALUE, "GenSharedIdsCHROMIUM: n < 0");
+    SetGLError(GL_INVALID_VALUE, "GenSharedIdsCHROMIUM", "n < 0");
     return error::kNoError;
   }
   if (ids == NULL) {
     return error::kOutOfBounds;
   }
   DoGenSharedIdsCHROMIUM(namespace_id, id_offset, n, ids);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoRegisterSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
   IdAllocatorInterface* id_allocator = group_->GetIdAllocator(namespace_id);
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (!id_allocator->MarkAsUsed(ids[ii])) {
       for (GLsizei jj = 0; jj < ii; ++jj) {
         id_allocator->FreeID(ids[jj]);
       }
       SetGLError(
-          GL_INVALID_VALUE,
-          "RegisterSharedIdsCHROMIUM: attempt to register "
-          "id that already exists");
+          GL_INVALID_VALUE, "RegisterSharedIdsCHROMIUM",
+          "attempt to register id that already exists");
       return;
     }
   }
 }
 
 error::Error GLES2DecoderImpl::HandleRegisterSharedIdsCHROMIUM(
     uint32 immediate_data_size, const gles2::RegisterSharedIdsCHROMIUM& c) {
   GLuint namespace_id = static_cast<GLuint>(c.namespace_id);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* ids = GetSharedMemoryAs<GLuint*>(
       c.ids_shm_id, c.ids_shm_offset, data_size);
   if (n < 0) {
-    SetGLError(GL_INVALID_VALUE, "RegisterSharedIdsCHROMIUM: n < 0");
+    SetGLError(GL_INVALID_VALUE, "RegisterSharedIdsCHROMIUM", "n < 0");
     return error::kNoError;
   }
   if (ids == NULL) {
     return error::kOutOfBounds;
   }
   DoRegisterSharedIdsCHROMIUM(namespace_id, n, ids);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoClear(GLbitfield mask) {
   if (CheckBoundFramebuffersValid("glClear")) {
     UNSHIPPED_TRACE_EVENT_INSTANT2("test_gpu", "DoClear", "red", clear_red_,
                                    "green", clear_green_);
     ApplyDirtyState();
     glClear(mask);
   }
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
     GLuint client_renderbuffer_id) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glFramebufferRenderbuffer: no framebuffer bound");
+               "glFramebufferRenderbuffer", "no framebuffer bound");
     return;
   }
   GLuint service_id = 0;
   RenderbufferManager::RenderbufferInfo* info = NULL;
   if (client_renderbuffer_id) {
     info = GetRenderbufferInfo(client_renderbuffer_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
-                 "glFramebufferRenderbuffer: unknown renderbuffer");
+                 "glFramebufferRenderbuffer", "unknown renderbuffer");
       return;
     }
     service_id = info->service_id();
   }
   CopyRealGLErrorsToWrapper();
   glFramebufferRenderbufferEXT(
       target, attachment, renderbuffertarget, service_id);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachRenderbuffer(attachment, info);
@@ skipping 186 matching lines @@
   return glCheckFramebufferStatusEXT(target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glFramebufferTexture2D: no framebuffer bound.");
+               "glFramebufferTexture2D", "no framebuffer bound.");
     return;
   }
   GLuint service_id = 0;
   TextureManager::TextureInfo* info = NULL;
   if (client_texture_id) {
     info = GetTextureInfo(client_texture_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
-                 "glFramebufferTexture2D: unknown texture");
+                 "glFramebufferTexture2D", "unknown texture");
       return;
     }
     service_id = info->service_id();
   }
 
   if (!texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     SetGLError(GL_INVALID_VALUE,
-               "glFramebufferTexture2D: level out of range");
+               "glFramebufferTexture2D", "level out of range");
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachTexture(attachment, info, textarget, level);
   }
   if (framebuffer_info == bound_draw_framebuffer_) {
     state_dirty_ = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glFramebufferAttachmentParameteriv: no framebuffer bound");
+               "glFramebufferAttachmentParameteriv", "no framebuffer bound");
     return;
   }
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
   if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
     GLint type = 0;
     GLuint client_id = 0;
     glGetFramebufferAttachmentParameterivEXT(
         target, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &type);
     switch (type) {
       case GL_RENDERBUFFER: {
@@ skipping 10 matching lines @@
     *params = client_id;
   }
 }
 
 void GLES2DecoderImpl::DoGetRenderbufferParameteriv(
     GLenum target, GLenum pname, GLint* params) {
   RenderbufferManager::RenderbufferInfo* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
-               "glGetRenderbufferParameteriv: no renderbuffer bound");
+               "glGetRenderbufferParameteriv", "no renderbuffer bound");
     return;
   }
   switch (pname) {
-  case GL_RENDERBUFFER_INTERNAL_FORMAT:
-    *params = renderbuffer->internal_format();
-    break;
-  case GL_RENDERBUFFER_WIDTH:
-    *params = renderbuffer->width();
-    break;
-  case GL_RENDERBUFFER_HEIGHT:
-    *params = renderbuffer->height();
-    break;
-  default:
-    glGetRenderbufferParameterivEXT(target, pname, params);
-    break;
+    case GL_RENDERBUFFER_INTERNAL_FORMAT:
+      *params = renderbuffer->internal_format();
+      break;
+    case GL_RENDERBUFFER_WIDTH:
+      *params = renderbuffer->width();
+      break;
+    case GL_RENDERBUFFER_HEIGHT:
+      *params = renderbuffer->height();
+      break;
+    default:
+      glGetRenderbufferParameterivEXT(target, pname, params);
+      break;
   }
 }
 
 void GLES2DecoderImpl::DoBlitFramebufferEXT(
     GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
     GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
     GLbitfield mask, GLenum filter) {
   if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
     SetGLError(GL_INVALID_OPERATION,
-               "glBlitFramebufferEXT: function not available");
+               "glBlitFramebufferEXT", "function not available");
   }
   if (IsAngle()) {
     glBlitFramebufferANGLE(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   } else {
     glBlitFramebufferEXT(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   }
   UNSHIPPED_TRACE_EVENT_INSTANT1("test_gpu", "DoBlit", "width", srcX1 - srcX0);
 }
 
 void GLES2DecoderImpl::DoRenderbufferStorageMultisample(
     GLenum target, GLsizei samples, GLenum internalformat,
     GLsizei width, GLsizei height) {
   if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
     SetGLError(GL_INVALID_OPERATION,
-               "glRenderbufferStorageMultisampleEXT: function not available");
+               "glRenderbufferStorageMultisampleEXT", "function not available");
     return;
   }
 
   RenderbufferManager::RenderbufferInfo* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
-               "glGetRenderbufferStorageMultisample: no renderbuffer bound");
+               "glGetRenderbufferStorageMultisample", "no renderbuffer bound");
     return;
   }
 
   if (samples > renderbuffer_manager()->max_samples()) {
     SetGLError(GL_INVALID_VALUE,
-               "glGetRenderbufferStorageMultisample: samples too large");
+               "glGetRenderbufferStorageMultisample", "samples too large");
     return;
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     SetGLError(GL_INVALID_VALUE,
-               "glGetRenderbufferStorageMultisample: size too large");
+               "glGetRenderbufferStorageMultisample", "size too large");
     return;
   }
 
   GLenum impl_format = internalformat;
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (impl_format) {
       case GL_DEPTH_COMPONENT16:
         impl_format = GL_DEPTH_COMPONENT;
         break;
       case GL_RGBA4:
@@ skipping 23 matching lines @@
         renderbuffer, samples, internalformat, width, height);
   }
 }
 
 void GLES2DecoderImpl::DoRenderbufferStorage(
   GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
   RenderbufferManager::RenderbufferInfo* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
-               "glGetRenderbufferStorage: no renderbuffer bound");
+               "glGetRenderbufferStorage", "no renderbuffer bound");
     return;
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     SetGLError(GL_INVALID_VALUE,
-               "glGetRenderbufferStorage: size too large");
+               "glGetRenderbufferStorage", "size too large");
     return;
   }
 
   GLenum impl_format = internalformat;
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (impl_format) {
       case GL_DEPTH_COMPONENT16:
         impl_format = GL_DEPTH_COMPONENT;
         break;
       case GL_RGBA4:
@@ skipping 30 matching lines @@
     if (info == current_program_.get()) {
       program_manager()->ClearUniforms(info);
     }
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glTexParameterf: unknown texture");
+    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");
+    SetGLError(GL_INVALID_ENUM, "glTexParameterf", "param GL_INVALID_ENUM");
     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");
+    SetGLError(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   if (!texture_manager()->SetParameter(info, pname, param)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteri: param GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glTexParameteri", "param GL_INVALID_ENUM");
     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");
+    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");
+    SetGLError(GL_INVALID_ENUM, "glTexParameterfv", "param GL_INVALID_ENUM");
     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");
+    SetGLError(GL_INVALID_VALUE, "glTexParameteriv", "unknown texture");
     return;
   }
 
   if (!texture_manager()->SetParameter(info, pname, *params)) {
-    SetGLError(GL_INVALID_ENUM, "glTexParameteriv: param GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glTexParameteriv", "param GL_INVALID_ENUM");
     return;
   }
   glTexParameteriv(target, pname, params);
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
   if (!current_program_) {
-      // The program does not exist.
-      SetGLError(GL_INVALID_OPERATION,
-                 (std::string(function_name) + ": no program in use").c_str());
-      return false;
+    // The program does not exist.
+    SetGLError(GL_INVALID_OPERATION, function_name, "no program in use");
+    return false;
   }
   if (!current_program_->InUse()) {
-    SetGLError(GL_INVALID_OPERATION,
-               (std::string(function_name) + ": program not linked").c_str());
+    SetGLError(GL_INVALID_OPERATION, function_name, "program not linked");
     return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgramForUniform(
     GLint location, const char* function_name) {
   if (!CheckCurrentProgram(function_name)) {
     return false;
   }
   return location != -1;
 }
 
 bool GLES2DecoderImpl::PrepForSetUniformByLocation(
     GLint fake_location, const char* function_name,
     GLint* real_location, GLenum* type, GLsizei* count) {
   DCHECK(type);
   DCHECK(count);
   DCHECK(real_location);
   if (!CheckCurrentProgramForUniform(fake_location, function_name)) {
     return false;
   }
   GLint array_index = -1;
   const ProgramManager::ProgramInfo::UniformInfo* info =
       current_program_->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!info) {
-    SetGLError(GL_INVALID_OPERATION,
-               (std::string(function_name) + ": unknown location").c_str());
+    SetGLError(GL_INVALID_OPERATION, function_name, "unknown location");
     return false;
   }
   if (*count > 1 && !info->is_array) {
     SetGLError(
-        GL_INVALID_OPERATION,
-        (std::string(function_name) + ": count > 1 for non-array").c_str());
+        GL_INVALID_OPERATION, function_name, "count > 1 for non-array");
     return false;
   }
   *count = std::min(info->size - array_index, *count);
   if (*count <= 0) {
     return false;
   }
   *type = info->type;
   return true;
 }
 
 void GLES2DecoderImpl::DoUniform1i(GLint fake_location, GLint v0) {
   GLenum type = 0;
   GLsizei count = 1;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(
       fake_location, "glUniform1iv", &real_location, &type, &count)) {
     return;
   }
   if (!current_program_->SetSamplers(
       group_->max_texture_units(), fake_location, 1, &v0)) {
-    SetGLError(GL_INVALID_VALUE, "glUniform1i: texture unit out of range");
+    SetGLError(GL_INVALID_VALUE, "glUniform1i", "texture unit out of range");
     return;
   }
   glUniform1i(real_location, v0);
 }
 
 void GLES2DecoderImpl::DoUniform1iv(
     GLint fake_location, GLsizei count, const GLint *value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(
       fake_location, "glUniform1iv", &real_location, &type, &count)) {
     return;
   }
   if (type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
       type == GL_SAMPLER_EXTERNAL_OES) {
     if (!current_program_->SetSamplers(
           group_->max_texture_units(), fake_location, count, value)) {
-      SetGLError(GL_INVALID_VALUE, "glUniform1iv: texture unit out of range");
+      SetGLError(GL_INVALID_VALUE, "glUniform1iv", "texture unit out of range");
       return;
     }
   }
   glUniform1iv(real_location, count, value);
 }
 
 void GLES2DecoderImpl::DoUniform1fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
@@ skipping 144 matching lines @@
 void GLES2DecoderImpl::DoUseProgram(GLuint program) {
   GLuint service_id = 0;
   ProgramManager::ProgramInfo* info = NULL;
   if (program) {
     info = GetProgramInfoNotShader(program, "glUseProgram");
     if (!info) {
       return;
     }
     if (!info->IsValid()) {
       // Program was not linked successfully. (ie, glLinkProgram)
-      SetGLError(GL_INVALID_OPERATION, "glUseProgram: program not linked");
+      SetGLError(GL_INVALID_OPERATION, "glUseProgram", "program not linked");
       return;
     }
     service_id = info->service_id();
   }
   if (current_program_) {
     program_manager()->UnuseProgram(shader_manager(), current_program_);
   }
   current_program_ = info;
   glUseProgram(service_id);
   if (current_program_) {
@@ skipping 16 matching lines @@
   if (error != GL_NO_ERROR) {
     // There was an error, clear the corresponding wrapped error.
     error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
   }
   return error;
 }
 
 GLenum GLES2DecoderImpl::PeekGLError() {
   GLenum error = glGetError();
   if (error != GL_NO_ERROR) {
-    SetGLError(error, "");
+    SetGLError(error, "", "");
   }
   return error;
 }
 
-void GLES2DecoderImpl::SetGLError(GLenum error, const char* msg) {
+void GLES2DecoderImpl::SetGLError(
+    GLenum error, const char* function_name, const char* msg) {
   if (msg) {
     last_error_ = msg;
     LogMessage(std::string("GL ERROR :") +
-               GLES2Util::GetStringEnum(error) + " : " + msg);
+               GLES2Util::GetStringEnum(error) + " : " +
+               function_name + ": " + msg);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
 void GLES2DecoderImpl::LogMessage(const std::string& msg) {
   if (log_message_count_ < kMaxLogMessages ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGLErrorLimit)) {
     ++log_message_count_;
     // LOG this unless logging is turned off as any chromium code that
@@ skipping 18 matching lines @@
   LogMessage(std::string("RENDER WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::PerformanceWarning(const std::string& msg) {
   LogMessage(std::string("PERFORMANCE WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::CopyRealGLErrorsToWrapper() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
-    SetGLError(error, NULL);
+    SetGLError(error, "", NULL);
   }
 }
 
 void GLES2DecoderImpl::ClearRealGLErrors() {
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
     if (error != GL_OUT_OF_MEMORY) {
       // GL_OUT_OF_MEMORY can legally happen on lost device.
       NOTREACHED() << "GL error " << error << " was unhandled.";
     }
@@ skipping 97 matching lines @@
             }
           }
         }
       }
     }
   }
   return true;
 }
 
 bool GLES2DecoderImpl::IsDrawValid(
-    GLuint max_vertex_accessed, GLsizei primcount) {
+    const char* function_name, GLuint max_vertex_accessed, GLsizei primcount) {
   // NOTE: We specifically do not check current_program->IsValid() because
   // it could never be invalid since glUseProgram would have failed. While
   // glLinkProgram could later mark the program as invalid the previous
   // valid program will still function if it is still the current program.
   if (!current_program_) {
     // The program does not exist.
     // But GL says no ERROR.
     RenderWarning("Drawing with no current shader program.");
     return false;
   }
@@ skipping 10 matching lines @@
        infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
         current_program_->GetAttribInfoByLocation(info->index());
     if (attrib_info) {
       divisor0 |= (info->divisor() == 0);
       GLuint count = info->MaxVertexAccessed(primcount, max_vertex_accessed);
       // This attrib is used in the current program.
       if (!info->CanAccess(count)) {
         SetGLError(
-            GL_INVALID_OPERATION,
+            GL_INVALID_OPERATION, function_name,
             (std::string(
-                 "glDrawXXX: attempt to access out of range vertices in "
-                 "attribute ") + base::IntToString(info->index())).c_str());
+                 "attempt to access out of range vertices in attribute ") +
+             base::IntToString(info->index())).c_str());
         return false;
       }
     } else {
       // This attrib is not used in the current program.
       if (!info->buffer()) {
         SetGLError(
-            GL_INVALID_OPERATION,
+            GL_INVALID_OPERATION, function_name,
             (std::string(
-                 "glDrawXXX: attempt to render with no buffer attached to "
+                 "attempt to render with no buffer attached to "
                  "enabled attribute ") +
                  base::IntToString(info->index())).c_str());
         return false;
       }
     }
   }
 
   if (primcount && !divisor0) {
     SetGLError(
-        GL_INVALID_OPERATION,
-        "glDrawXXX: attempt instanced render with all attributes having "
+        GL_INVALID_OPERATION, function_name,
+        "attempt instanced render with all attributes having "
         "non-zero divisors");
     return false;
   }
 
   return true;
 }
 
 bool GLES2DecoderImpl::SimulateAttrib0(
-    GLuint max_vertex_accessed, bool* simulated) {
+    const char* function_name, GLuint max_vertex_accessed, bool* simulated) {
   DCHECK(simulated);
   *simulated = false;
 
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
     return true;
 
   const VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(0);
   // If it's enabled or it's not used then we don't need to do anything.
   bool attrib_0_used = current_program_->GetAttribInfoByLocation(0) != NULL;
   if (info->enabled() && attrib_0_used) {
     return true;
   }
 
   // Make a buffer with a single repeated vec4 value enough to
   // simulate the constant value that is supposed to be here.
   // This is required to emulate GLES2 on GL.
   typedef VertexAttribManager::VertexAttribInfo::Vec4 Vec4;
 
   GLuint num_vertices = max_vertex_accessed + 1;
   GLuint size_needed = 0;
 
   if (num_vertices == 0 ||
       !SafeMultiply(num_vertices, static_cast<GLuint>(sizeof(Vec4)),
                     &size_needed) ||
       size_needed > 0x7FFFFFFFU) {
-    SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+    SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
     return false;
   }
 
   PerformanceWarning(
       "Attribute 0 is disabled. This has signficant performance penalty");
 
   CopyRealGLErrorsToWrapper();
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
 
   bool new_buffer = static_cast<GLsizei>(size_needed) > attrib_0_size_;
   if (new_buffer) {
     glBufferData(GL_ARRAY_BUFFER, size_needed, NULL, GL_DYNAMIC_DRAW);
     GLenum error = glGetError();
     if (error != GL_NO_ERROR) {
-      SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+      SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
   }
   if (new_buffer ||
       (attrib_0_used &&
        (!attrib_0_buffer_matches_value_ ||
         (info->value().v[0] != attrib_0_value_.v[0] ||
          info->value().v[1] != attrib_0_value_.v[1] ||
          info->value().v[2] != attrib_0_value_.v[2] ||
          info->value().v[3] != attrib_0_value_.v[3])))) {
@@ skipping 28 matching lines @@
                bound_array_buffer_ ? bound_array_buffer_->service_id() : 0);
 
   if (info->enabled()) {
     glEnableVertexAttribArray(attrib);
   } else {
     glDisableVertexAttribArray(attrib);
   }
 }
 
 bool GLES2DecoderImpl::SimulateFixedAttribs(
+    const char* function_name,
     GLuint max_vertex_accessed, bool* simulated, GLsizei primcount) {
   DCHECK(simulated);
   *simulated = false;
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
     return true;
 
   if (!vertex_attrib_manager_->HaveFixedAttribs()) {
     return true;
   }
 
@@ skipping 11 matching lines @@
       vertex_attrib_manager_->GetEnabledVertexAttribInfos();
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
        infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
         current_program_->GetAttribInfoByLocation(info->index());
     GLuint max_accessed = info->MaxVertexAccessed(primcount,
                                                   max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
-      SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+      SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         info->CanAccess(max_accessed) &&
         info->type() == GL_FIXED) {
       GLuint elements_used = 0;
       if (!SafeMultiply(num_vertices,
                         static_cast<GLuint>(info->size()), &elements_used) ||
           !SafeAdd(elements_needed, elements_used, &elements_needed)) {
-        SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: simulating GL_FIXED attribs");
+        SetGLError(
+            GL_OUT_OF_MEMORY, function_name, "simulating GL_FIXED attribs");
         return false;
       }
     }
   }
 
   const GLuint kSizeOfFloat = sizeof(float);  // NOLINT
   GLuint size_needed = 0;
   if (!SafeMultiply(elements_needed, kSizeOfFloat, &size_needed) ||
       size_needed > 0x7FFFFFFFU) {
-    SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: simulating GL_FIXED attribs");
+    SetGLError(GL_OUT_OF_MEMORY, function_name, "simulating GL_FIXED attribs");
     return false;
   }
 
   CopyRealGLErrorsToWrapper();
 
   glBindBuffer(GL_ARRAY_BUFFER, fixed_attrib_buffer_id_);
   if (static_cast<GLsizei>(size_needed) > fixed_attrib_buffer_size_) {
     glBufferData(GL_ARRAY_BUFFER, size_needed, NULL, GL_DYNAMIC_DRAW);
     GLenum error = glGetError();
     if (error != GL_NO_ERROR) {
-      SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: simulating GL_FIXED attribs");
+      SetGLError(
+          GL_OUT_OF_MEMORY, function_name, "simulating GL_FIXED attribs");
       return false;
     }
   }
 
   // Copy the elements and convert to float
   GLintptr offset = 0;
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
            infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
         current_program_->GetAttribInfoByLocation(info->index());
     GLuint max_accessed = info->MaxVertexAccessed(primcount,
                                                   max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
-      SetGLError(GL_OUT_OF_MEMORY, "glDrawXXX: Simulating attrib 0");
+      SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         info->CanAccess(max_accessed) &&
         info->type() == GL_FIXED) {
       int num_elements = info->size() * kSizeOfFloat;
       int size = num_elements * num_vertices;
       scoped_array<float> data(new float[size]);
       const int32* src = reinterpret_cast<const int32 *>(
           info->buffer()->GetRange(info->offset(), size));
@@ skipping 13 matching lines @@
   return true;
 }
 
 void GLES2DecoderImpl::RestoreStateForSimulatedFixedAttribs() {
   // There's no need to call glVertexAttribPointer because we shadow all the
   // settings and passing GL_FIXED to it will not work.
   glBindBuffer(GL_ARRAY_BUFFER,
                bound_array_buffer_ ? bound_array_buffer_->service_id() : 0);
 }
 
-error::Error GLES2DecoderImpl::DoDrawArrays(bool instanced,
-                                            GLenum mode,
-                                            GLint first,
-                                            GLsizei count,
-                                            GLsizei primcount) {
+error::Error GLES2DecoderImpl::DoDrawArrays(
+    const char* function_name,
+    bool instanced,
+    GLenum mode,
+    GLint first,
+    GLsizei count,
+    GLsizei primcount) {
   if (!validators_->draw_mode.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, "glDrawArrays: mode GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, function_name, "mode GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (count < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawArrays: count < 0");
+    SetGLError(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (primcount < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawArrays: primcount < 0");
+    SetGLError(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
-  if (!CheckBoundFramebuffersValid("glDrawArrays")) {
+  if (!CheckBoundFramebuffersValid(function_name)) {
     return error::kNoError;
   }
   // We have to check this here because the prototype for glDrawArrays
   // is GLint not GLsizei.
   if (first < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawArrays: first < 0");
+    SetGLError(GL_INVALID_VALUE, function_name, "first < 0");
     return error::kNoError;
   }
 
   if (count == 0 || (instanced && primcount == 0)) {
     RenderWarning("Render count or primcount is 0.");
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed = first + count - 1;
-  if (IsDrawValid(max_vertex_accessed, primcount)) {
+  if (IsDrawValid(function_name, max_vertex_accessed, primcount)) {
     if (!ClearUnclearedTextures()) {
-      SetGLError(GL_INVALID_VALUE, "glDrawArrays: out of memory");
+      SetGLError(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
     }
     bool simulated_attrib_0 = false;
-    if (!SimulateAttrib0(max_vertex_accessed, &simulated_attrib_0)) {
+    if (!SimulateAttrib0(
+        function_name, max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
     bool simulated_fixed_attribs = false;
-    if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs,
-                             primcount)) {
+    if (SimulateFixedAttribs(
+        function_name, max_vertex_accessed, &simulated_fixed_attribs,
+        primcount)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
       ApplyDirtyState();
       if (!instanced) {
         glDrawArrays(mode, first, count);
       } else {
         glDrawArraysInstancedANGLE(mode, first, count, primcount);
       }
       ProcessPendingQueries();
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
       RestoreStateForAttrib(0);
     }
     if (WasContextLost()) {
       LOG(ERROR) << "  GLES2DecoderImpl: Context lost during DrawArrays.";
       return error::kLostContext;
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArrays(
     uint32 immediate_data_size, const gles2::DrawArrays& c) {
-  return DoDrawArrays(false,
+  return DoDrawArrays("glDrawArrays",
+                      false,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       0);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArraysInstancedANGLE(
     uint32 immediate_data_size, const gles2::DrawArraysInstancedANGLE& c) {
   if (!feature_info_->feature_flags().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
-               "glDrawArraysInstancedANGLE: function not available");
+               "glDrawArraysInstancedANGLE", "function not available");
     return error::kNoError;
   }
-  return DoDrawArrays(true,
+  return DoDrawArrays("glDrawArraysIntancedANGLE",
+                      true,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       static_cast<GLsizei>(c.primcount));
 }
 
-error::Error GLES2DecoderImpl::DoDrawElements(bool instanced,
-                                              GLenum mode,
-                                              GLsizei count,
-                                              GLenum type,
-                                              int32 offset,
-                                              GLsizei primcount) {
+error::Error GLES2DecoderImpl::DoDrawElements(
+    const char* function_name,
+    bool instanced,
+    GLenum mode,
+    GLsizei count,
+    GLenum type,
+    int32 offset,
+    GLsizei primcount) {
   if (!bound_element_array_buffer_) {
     SetGLError(GL_INVALID_OPERATION,
-               "glDrawElements: No element array buffer bound");
+               function_name, "No element array buffer bound");
     return error::kNoError;
   }
 
   if (count < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawElements: count < 0");
+    SetGLError(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (offset < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawElements: offset < 0");
+    SetGLError(GL_INVALID_VALUE, function_name, "offset < 0");
     return error::kNoError;
   }
   if (!validators_->draw_mode.IsValid(mode)) {
-    SetGLError(GL_INVALID_ENUM, "glDrawElements: mode GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, function_name, "mode GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->index_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glDrawElements: type GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, function_name, "type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (primcount < 0) {
-    SetGLError(GL_INVALID_VALUE, "glDrawElements: primcount < 0");
+    SetGLError(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
 
-  if (!CheckBoundFramebuffersValid("glDrawElements")) {
+  if (!CheckBoundFramebuffersValid(function_name)) {
     return error::kNoError;
   }
 
   if (count == 0 || (instanced && primcount == 0)) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
   if (!bound_element_array_buffer_->GetMaxValueForRange(
       offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
-               "glDrawElements: range out of bounds for buffer");
+               function_name, "range out of bounds for buffer");
     return error::kNoError;
   }
 
-  if (IsDrawValid(max_vertex_accessed, primcount)) {
+  if (IsDrawValid(function_name, max_vertex_accessed, primcount)) {
     if (!ClearUnclearedTextures()) {
-      SetGLError(GL_INVALID_VALUE, "glDrawElements: out of memory");
+      SetGLError(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
     }
     bool simulated_attrib_0 = false;
-    if (!SimulateAttrib0(max_vertex_accessed, &simulated_attrib_0)) {
+    if (!SimulateAttrib0(
+        function_name, max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
     bool simulated_fixed_attribs = false;
-    if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs,
-                             primcount)) {
+    if (SimulateFixedAttribs(
+        function_name, max_vertex_accessed, &simulated_fixed_attribs,
+        primcount)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
       ApplyDirtyState();
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       if (!instanced) {
         glDrawElements(mode, count, type, indices);
       } else {
         glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
       }
       ProcessPendingQueries();
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
       RestoreStateForAttrib(0);
     }
     if (WasContextLost()) {
       LOG(ERROR) << "  GLES2DecoderImpl: Context lost during DrawElements.";
       return error::kLostContext;
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElements(
     uint32 immediate_data_size, const gles2::DrawElements& c) {
-  return DoDrawElements(false,
+  return DoDrawElements("glDrawElements",
+                        false,
                         static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
                         static_cast<int32>(c.index_offset),
                         0);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElementsInstancedANGLE(
     uint32 immediate_data_size, const gles2::DrawElementsInstancedANGLE& c) {
   if (!feature_info_->feature_flags().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
-               "glDrawElementsInstancedANGLE: function not available");
+               "glDrawElementsInstancedANGLE", "function not available");
     return error::kNoError;
   }
-  return DoDrawElements(true,
+  return DoDrawElements("glDrawElementsInstancedANGLE",
+                        true,
                         static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
                         static_cast<int32>(c.index_offset),
                         static_cast<GLsizei>(c.primcount));
 }
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GLuint max_vertex_accessed = 0;
   BufferManager::BufferInfo* info = GetBufferInfo(buffer_id);
   if (!info) {
     // TODO(gman): Should this be a GL error or a command buffer error?
     SetGLError(GL_INVALID_VALUE,
-               "GetMaxValueInBufferCHROMIUM: unknown buffer");
+               "GetMaxValueInBufferCHROMIUM", "unknown buffer");
   } else {
     if (!info->GetMaxValueForRange(offset, count, type, &max_vertex_accessed)) {
       // TODO(gman): Should this be a GL error or a command buffer error?
       SetGLError(
           GL_INVALID_OPERATION,
-          "GetMaxValueInBufferCHROMIUM: range out of bounds for buffer");
+          "GetMaxValueInBufferCHROMIUM", "range out of bounds for buffer");
     }
   }
   return max_vertex_accessed;
 }
 
 // Calls glShaderSource for the various versions of the ShaderSource command.
 // Assumes that data / data_size points to a piece of memory that is in range
 // of whatever context it came from (shared memory, immediate memory, bucket
 // memory.)
 error::Error GLES2DecoderImpl::ShaderSourceHelper(
@@ skipping 238 matching lines @@
   if (!program_info) {
     return;
   }
   ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
       shader_client_id, "glAttachShader");
   if (!shader_info) {
     return;
   }
   if (!program_info->AttachShader(shader_manager(), shader_info)) {
     SetGLError(GL_INVALID_OPERATION,
-               "glAttachShader: can not attach more than"
+               "glAttachShader", "can not attach more than"
                " one shader of the same type.");
     return;
   }
   glAttachShader(program_info->service_id(), shader_info->service_id());
 }
 
 void GLES2DecoderImpl::DoDetachShader(
     GLuint program_client_id, GLint shader_client_id) {
   ProgramManager::ProgramInfo* program_info = GetProgramInfoNotShader(
       program_client_id, "glDetachShader");
   if (!program_info) {
     return;
   }
   ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
       shader_client_id, "glDetachShader");
   if (!shader_info) {
     return;
   }
   if (!program_info->DetachShader(shader_manager(), shader_info)) {
     SetGLError(GL_INVALID_OPERATION,
-               "glDetachShader: shader not attached to program");
+               "glDetachShader", "shader not attached to program");
     return;
   }
   glDetachShader(program_info->service_id(), shader_info->service_id());
 }
 
 void GLES2DecoderImpl::DoValidateProgram(GLuint program_client_id) {
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program_client_id, "glValidateProgram");
   if (!info) {
     return;
   }
   info->Validate();
 }
 
 void GLES2DecoderImpl::DoGetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glGetVertexAttribfv: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glGetVertexAttribfv", "index out of range");
     return;
   }
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
         BufferManager::BufferInfo* buffer = info->buffer();
         if (buffer && !buffer->IsDeleted()) {
           GLuint client_id;
           buffer_manager()->GetClientId(buffer->service_id(), &client_id);
           *params = static_cast<GLfloat>(client_id);
         }
@@ skipping 27 matching lines @@
       NOTREACHED();
       break;
   }
 }
 
 void GLES2DecoderImpl::DoGetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glGetVertexAttribiv: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glGetVertexAttribiv", "index out of range");
     return;
   }
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
         BufferManager::BufferInfo* buffer = info->buffer();
         if (buffer && !buffer->IsDeleted()) {
           GLuint client_id;
           buffer_manager()->GetClientId(buffer->service_id(), &client_id);
           *params = client_id;
         }
@@ skipping 26 matching lines @@
     default:
       NOTREACHED();
       break;
   }
 }
 
 void GLES2DecoderImpl::DoVertexAttrib1f(GLuint index, GLfloat v0) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib1f: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib1f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = 0.0f;
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib1f(index, v0);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib2f: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib2f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = v1;
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib2f(index, v0, v1);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib3f(
     GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib3f: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib3f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = v1;
   value.v[2] = v2;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib3f(index, v0, v1, v2);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib4f(
     GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib4f: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib4f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = v1;
   value.v[2] = v2;
   value.v[3] = v3;
   info->set_value(value);
   glVertexAttrib4f(index, v0, v1, v2, v3);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib1fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib1fv: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib1fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = 0.0f;
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib1fv(index, v);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib2fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib2fv: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib2fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = v[1];
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib2fv(index, v);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib3fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib3fv: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib3fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = v[1];
   value.v[2] = v[2];
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib3fv(index, v);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib4fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
       vertex_attrib_manager_->GetVertexAttribInfo(index);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glVertexAttrib4fv: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttrib4fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = v[1];
   value.v[2] = v[2];
   value.v[3] = v[3];
   info->set_value(value);
   glVertexAttrib4fv(index, v);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
     uint32 immediate_data_size, const gles2::VertexAttribPointer& c) {
   if (!bound_array_buffer_ || bound_array_buffer_->IsDeleted()) {
     SetGLError(GL_INVALID_VALUE,
-               "glVertexAttribPointer: no array buffer bound");
+               "glVertexAttribPointer", "no array buffer bound");
     return error::kNoError;
   }
 
   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");
+               "glVertexAttribPointer", "type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->vertex_attrib_size.IsValid(size)) {
     SetGLError(GL_INVALID_VALUE,
-               "glVertexAttribPointer: size 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");
+    SetGLError(GL_INVALID_VALUE, "glVertexAttribPointer", "index out of range");
     return error::kNoError;
   }
   if (stride < 0) {
     SetGLError(GL_INVALID_VALUE,
-               "glVertexAttribPointer: stride < 0");
+               "glVertexAttribPointer", "stride < 0");
     return error::kNoError;
   }
   if (stride > 255) {
     SetGLError(GL_INVALID_VALUE,
-               "glVertexAttribPointer: stride > 255");
+               "glVertexAttribPointer", "stride > 255");
     return error::kNoError;
   }
   if (offset < 0) {
     SetGLError(GL_INVALID_VALUE,
-               "glVertexAttribPointer: offset < 0");
+               "glVertexAttribPointer", "offset < 0");
     return error::kNoError;
   }
   GLsizei component_size =
       GLES2Util::GetGLTypeSizeForTexturesAndBuffers(type);
   if (offset % component_size > 0) {
     SetGLError(GL_INVALID_OPERATION,
-               "glVertexAttribPointer: offset not valid for type");
+               "glVertexAttribPointer", "offset not valid for type");
     return error::kNoError;
   }
   if (stride % component_size > 0) {
     SetGLError(GL_INVALID_OPERATION,
-               "glVertexAttribPointer: stride not valid for type");
+               "glVertexAttribPointer", "stride not valid for type");
     return error::kNoError;
   }
   vertex_attrib_manager_->SetAttribInfo(
       indx,
       bound_array_buffer_,
       size,
       type,
       normalized,
       stride,
       stride != 0 ? stride : component_size * size,
@@ skipping 10 matching lines @@
   viewport_y_ = y;
   viewport_width_ = std::min(width, viewport_max_width_);
   viewport_height_ = std::min(height, viewport_max_height_);
   glViewport(x, y, width, height);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
     uint32 immediate_data_size, const gles2::VertexAttribDivisorANGLE& c) {
   if (!feature_info_->feature_flags().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
-               "glVertexAttribDivisorANGLE: function not available");
+               "glVertexAttribDivisorANGLE", "function not available");
   }
   GLuint index = c.index;
   GLuint divisor = c.divisor;
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
-               "glVertexAttribDivisorANGLE: index out of range");
+               "glVertexAttribDivisorANGLE", "index out of range");
     return error::kNoError;
   }
 
   vertex_attrib_manager_->SetDivisor(
       index,
       divisor);
   glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleReadPixels(
     uint32 immediate_data_size, const gles2::ReadPixels& c) {
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   if (width < 0 || height < 0) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions < 0");
+    SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return error::kNoError;
   }
   typedef gles2::ReadPixels::Result Result;
   uint32 pixels_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, pack_alignment_, &pixels_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   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");
+    SetGLError(GL_INVALID_ENUM, "glReadPixels", "format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glReadPixels: type GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glReadPixels", "type GL_INVALID_ENUM");
     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;
   GLint max_y;
   if (!SafeAdd(x, width, &max_x) || !SafeAdd(y, height, &max_y)) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
+    SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
     return error::kNoError;
   }
 
   if (!CheckBoundFramebuffersValid("glReadPixels")) {
     return error::kNoError;
   }
 
   CopyRealGLErrorsToWrapper();
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
 
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // The user requested an out of range area. Get the results 1 line
     // at a time.
     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: dimensions out of range");
+      SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
       return error::kNoError;
     }
 
     GLint dest_x_offset = std::max(-x, 0);
     uint32 dest_row_offset;
     if (!GLES2Util::ComputeImageDataSizes(
         dest_x_offset, 1, format, type, pack_alignment_, &dest_row_offset, NULL,
         NULL)) {
-      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
+      SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
       return error::kNoError;
     }
 
     // Copy each row into the larger dest rect.
     int8* dst = static_cast<int8*>(pixels);
     GLint read_x = std::max(0, x);
     GLint read_end_x = std::max(0, std::min(max_size.width(), max_x));
     GLint read_width = read_end_x - read_x;
     for (GLint yy = 0; yy < height; ++yy) {
       GLint ry = y + yy;
@@ skipping 19 matching lines @@
     uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
     if ((channels_exist & 0x0008) == 0 && !disable_workarounds_) {
       // Set the alpha to 255 because some drivers are buggy in this regard.
       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: dimensions out of range");
+        SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
         return error::kNoError;
       }
       // NOTE: Assumes the type is GL_UNSIGNED_BYTE which was true at the time
       // of this implementation.
       if (type != GL_UNSIGNED_BYTE) {
-        SetGLError(GL_INVALID_OPERATION, "unsupported readPixel format");
+        SetGLError(
+            GL_INVALID_OPERATION, "glReadPixels",
+            "unsupported readPixel format");
         return error::kNoError;
       }
       switch (format) {
         case GL_RGBA:
         case GL_BGRA_EXT:
         case GL_ALPHA: {
           int offset = (format == GL_ALPHA) ? 0 : 3;
           int step = (format == GL_ALPHA) ? 1 : 4;
           uint8* dst = static_cast<uint8*>(pixels) + offset;
           for (GLint yy = 0; yy < height; ++yy) {
@@ skipping 12 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");
+    SetGLError(GL_INVALID_ENUM, "glPixelStorei", "pname GL_INVALID_ENUM");
     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");
+                       "glPixelStore", "param GL_INVALID_VALUE");
             return error::kNoError;
         }
         break;
     case GL_UNPACK_FLIP_Y_CHROMIUM:
         unpack_flip_y_ = (param != 0);
         return error::kNoError;
     case GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM:
         unpack_premultiply_alpha_ = (param != 0);
         return error::kNoError;
     default:
         break;
   }
   glPixelStorei(pname, param);
   switch (pname) {
-  case GL_PACK_ALIGNMENT:
-      pack_alignment_ = param;
-      break;
-  case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
-      break;
-  case GL_UNPACK_ALIGNMENT:
-      unpack_alignment_ = param;
-      break;
-  default:
-      // Validation should have prevented us from getting here.
-      NOTREACHED();
-      break;
+    case GL_PACK_ALIGNMENT:
+        pack_alignment_ = param;
+        break;
+    case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
+        break;
+    case GL_UNPACK_ALIGNMENT:
+        unpack_alignment_ = param;
+        break;
+    default:
+        // Validation should have prevented us from getting here.
+        NOTREACHED();
+        break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
     uint32 immediate_data_size, const gles2::PostSubBufferCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandlePostSubBufferCHROMIUM");
   if (!context_->HasExtension("GL_CHROMIUM_post_sub_buffer")) {
     SetGLError(GL_INVALID_OPERATION,
-               "glPostSubBufferCHROMIUM: command not supported by surface");
+               "glPostSubBufferCHROMIUM", "command not supported by surface");
     return error::kNoError;
   }
   if (surface_->PostSubBuffer(c.x, c.y, c.width, c.height)) {
     return error::kNoError;
   } else {
     LOG(ERROR) << "Context lost because PostSubBuffer failed.";
     return error::kLostContext;
   }
 }
 
 error::Error GLES2DecoderImpl::GetAttribLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
   if (!StringIsValidForGLES(name_str.c_str())) {
-    SetGLError(GL_INVALID_VALUE, "glGetAttribLocation: Invalid character");
+    SetGLError(GL_INVALID_VALUE, "glGetAttribLocation", "Invalid character");
     return error::kNoError;
   }
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       client_id, "glGetAttribLocation");
   if (!info) {
     return error::kNoError;
   }
   if (!info->IsValid()) {
-    SetGLError(GL_INVALID_OPERATION, "glGetAttribLocation: program not linked");
+    SetGLError(
+        GL_INVALID_OPERATION, "glGetAttribLocation", "program not linked");
     return error::kNoError;
   }
   GLint* location = GetSharedMemoryAs<GLint*>(
       location_shm_id, location_shm_offset, sizeof(GLint));
   if (!location) {
     return error::kOutOfBounds;
   }
   // Require the client to init this incase the context is lost and we are no
   // longer executing commands.
   if (*location != -1) {
@@ skipping 40 matching lines @@
     return error::kInvalidArguments;
   }
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::GetUniformLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
   if (!StringIsValidForGLES(name_str.c_str())) {
-    SetGLError(GL_INVALID_VALUE, "glGetUniformLocation: Invalid character");
+    SetGLError(GL_INVALID_VALUE, "glGetUniformLocation", "Invalid character");
     return error::kNoError;
   }
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       client_id, "glUniformLocation");
   if (!info) {
     return error::kNoError;
   }
   if (!info->IsValid()) {
-    SetGLError(GL_INVALID_OPERATION,
-               "glGetUniformLocation: program not linked");
+    SetGLError(
+        GL_INVALID_OPERATION, "glGetUniformLocation", "program not linked");
     return error::kNoError;
   }
   GLint* location = GetSharedMemoryAs<GLint*>(
       location_shm_id, location_shm_offset, sizeof(GLint));
   if (!location) {
     return error::kOutOfBounds;
   }
   // Require the client to init this incase the context is lost an we are no
   // longer executing commands.
   if (*location != -1) {
@@ skipping 41 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");
+    SetGLError(GL_INVALID_ENUM, "glGetString", "name GL_INVALID_ENUM");
     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 29 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");
+    SetGLError(GL_INVALID_ENUM, "glBufferData", "target GL_INVALID_ENUM");
     return;
   }
   if (!validators_->buffer_usage.IsValid(usage)) {
-    SetGLError(GL_INVALID_ENUM, "glBufferData: usage GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glBufferData", "usage GL_INVALID_ENUM");
     return;
   }
   if (size < 0) {
-    SetGLError(GL_INVALID_VALUE, "glBufferData: size < 0");
+    SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0");
     return;
   }
   BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glBufferData: unknown buffer");
+    SetGLError(GL_INVALID_VALUE, "glBufferData", "unknown buffer");
     return;
   }
   // Clear the buffer to 0 if no initial data was passed in.
   scoped_array<int8> zero;
   if (!data) {
     zero.reset(new int8[size]);
     memset(zero.get(), 0, size);
     data = zero.get();
   }
 
@@ skipping 42 matching lines @@
   }
   GLenum usage = static_cast<GLenum>(c.usage);
   DoBufferData(target, size, data, usage);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferSubData(
   GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) {
   BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
   if (!info) {
-    SetGLError(GL_INVALID_VALUE, "glBufferSubData: unknown buffer");
+    SetGLError(GL_INVALID_VALUE, "glBufferSubData", "unknown buffer");
     return;
   }
   if (!info->SetRange(offset, size, data)) {
-    SetGLError(GL_INVALID_VALUE, "glBufferSubData: out of range");
+    SetGLError(GL_INVALID_VALUE, "glBufferSubData", "out of range");
     return;
   }
   if (bufferdata_faster_than_buffersubdata_ &&
       offset == 0 && size == info->size()) {
     glBufferData(target, size, data, info->usage());
     return;
   }
   glBufferSubData(target, offset, size, data);
 }
 
@@ skipping 89 matching lines @@
       WrappedTexImage2D(
           target, level, format, width, h, 0, format, type, zero.get());
     }
     y += tile_height;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(bind_target);
   glBindTexture(bind_target, info ? info->service_id() : 0);
   return true;
 }
 
+namespace {
+
+const int kS3TCBlockWidth = 4;
+const int kS3TCBlockHeight = 4;
+const int kS3TCDXT1BlockSize = 8;
+const int kS3TCDXT3AndDXT5BlockSize = 16;
+
+bool IsValidDXTSize(GLint level, GLsizei size) {
+  return (level && size == 1) ||
+         (level && size == 2) || !(size % kS3TCBlockWidth);
+}
+
+}  // anonymous namespace.
+
+bool GLES2DecoderImpl::ValidateCompressedTexFuncData(
+    const char* function_name,
+    GLsizei width, GLsizei height, GLenum format, size_t size) {
+  unsigned int bytes_required = 0;
+
+  switch (format) {
+    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT1_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 * kS3TCDXT1BlockSize;
+        break;
+      }
+    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+    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");
+      return false;
+  }
+
+  if (size != bytes_required) {
+    SetGLError(
+        GL_INVALID_VALUE, function_name, "size is not correct for dimensions");
+    return false;
+  }
+
+  return true;
+}
+
+bool GLES2DecoderImpl::ValidateCompressedTexDimensions(
+    const char* function_name,
+    GLint level, GLsizei width, GLsizei height, GLenum format) {
+  switch (format) {
+    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: {
+      if (!IsValidDXTSize(level, width) || !IsValidDXTSize(level, height)) {
+        SetGLError(
+            GL_INVALID_OPERATION, function_name,
+            "width or height invalid for level");
+        return false;
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+bool GLES2DecoderImpl::ValidateCompressedTexSubDimensions(
+    const char* function_name,
+    GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height, GLenum format,
+    TextureManager::TextureInfo* texture) {
+  if (xoffset < 0 || yoffset < 0) {
+    SetGLError(
+        GL_INVALID_VALUE, function_name, "xoffset or yoffset < 0");
+    return false;
+  }
+
+  switch (format) {
+    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: {
+      const int kBlockWidth = 4;
+      const int kBlockHeight = 4;
+      if ((xoffset % kBlockWidth) || (yoffset % kBlockHeight)) {
+        SetGLError(
+            GL_INVALID_OPERATION, function_name,
+            "xoffset or yoffset not multiple of 4");
+        return false;
+      }
+      GLsizei tex_width = 0;
+      GLsizei tex_height = 0;
+      if (!texture->GetLevelSize(target, level, &tex_width, &tex_height) ||
+          width - xoffset > tex_width ||
+          height - yoffset > tex_height) {
+        SetGLError(
+            GL_INVALID_OPERATION, function_name, "dimensions out of range");
+        return false;
+      }
+      return ValidateCompressedTexDimensions(
+          function_name, level, width, height, format);
+    }
+    default:
+      return false;
+  }
+}
+
 error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
   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");
+               "glCompressedTexImage2D", "target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->compressed_texture_format.IsValid(
       internal_format)) {
     SetGLError(GL_INVALID_ENUM,
-               "glCompressedTexImage2D: internal_format GL_INVALID_ENUM");
+               "glCompressedTexImage2D", "internal_format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE,
-               "glCompressedTexImage2D: dimensions out of range");
+               "glCompressedTexImage2D", "dimensions out of range");
     return error::kNoError;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE,
-               "glCompressedTexImage2D: unknown texture target");
+               "glCompressedTexImage2D", "unknown texture target");
     return error::kNoError;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCompressedTexImage2D: texture is immutable");
+               "glCompressedTexImage2D", "texture is immutable");
     return error::kNoError;
   }
 
+  if (!ValidateCompressedTexDimensions(
+      "glCompressedTexImage2D", level, width, height, internal_format) ||
+      !ValidateCompressedTexFuncData(
+      "glCompressedTexImage2D", width, height, internal_format, image_size)) {
+    return error::kNoError;
+  }
+
   if (info->IsAttachedToFramebuffer()) {
     state_dirty_ = true;
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   scoped_array<int8> zero;
   if (!data) {
     zero.reset(new int8[image_size]);
@@ skipping 91 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 GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->compressed_texture_format.IsValid(format)) {
     SetGLError(GL_INVALID_ENUM,
-               "glCompressedTexSubImage2D: format GL_INVALID_ENUM");
+               "glCompressedTexSubImage2D", "format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: width < 0");
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
-    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: height < 0");
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   if (imageSize < 0) {
-    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D: imageSize < 0");
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "imageSize < 0");
     return error::kNoError;
   }
   DoCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::ValidateTextureParameters(
     const char* function_name,
     GLenum target, GLenum format, GLenum type, GLint level) {
   if (!feature_info_->GetTextureFormatValidator(format).IsValid(type)) {
-      SetGLError(GL_INVALID_OPERATION,
-                 (std::string(function_name) + ": invalid type " +
+      SetGLError(GL_INVALID_OPERATION, function_name,
+                 (std::string("invalid type ") +
                   GLES2Util::GetStringEnum(type) + " for format " +
                   GLES2Util::GetStringEnum(format)).c_str());
       return false;
   }
 
   uint32 channels = GLES2Util::GetChannelsForFormat(format);
   if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
-    SetGLError(GL_INVALID_OPERATION,
-               (std::string(function_name) + ": invalid type " +
+    SetGLError(GL_INVALID_OPERATION, function_name,
+               (std::string("invalid type ") +
                 GLES2Util::GetStringEnum(type) + " for format " +
                 GLES2Util::GetStringEnum(format)).c_str());
     return false;
   }
   return true;
 }
 
 error::Error GLES2DecoderImpl::DoTexImage2D(
   GLenum target,
   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");
+    SetGLError(GL_INVALID_ENUM, "glTexImage2D", "target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(internal_format)) {
     SetGLError(GL_INVALID_ENUM,
-               "glTexImage2D: internal_format GL_INVALID_ENUM");
+               "glTexImage2D", "internal_format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
-    SetGLError(GL_INVALID_ENUM, "glTexImage2D: format GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glTexImage2D", "format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glTexImage2D: type GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glTexImage2D", "type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (format != internal_format) {
-    SetGLError(GL_INVALID_OPERATION, "glTexImage2D: format != internalFormat");
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImage2D", "format != internalFormat");
     return error::kNoError;
   }
   if (!ValidateTextureParameters("glTexImage2D", target, format, type, level)) {
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexImage2D: dimensions out of range");
+    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimensions out of range");
     return error::kNoError;
   }
   if ((GLES2Util::GetChannelsForFormat(format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && pixels) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glTexImage2D: can not supply data for depth or stencil textures");
+        "glTexImage2D", "can not supply data for depth or stencil textures");
     return error::kNoError;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexImage2D: unknown texture for target");
+               "glTexImage2D", "unknown texture for target");
     return error::kNoError;
   }
 
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexImage2D: texture is immutable");
+               "glTexImage2D", "texture is immutable");
     return error::kNoError;
   }
 
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   GLenum tex_type = 0;
   GLenum tex_format = 0;
   bool level_is_same =
       info->GetLevelSize(target, level, &tex_width, &tex_height) &&
       info->GetLevelType(target, level, &tex_type, &tex_format) &&
@@ skipping 104 matching lines @@
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
   GLenum format,
   GLsizei image_size,
   const void * data) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCompressedTexSubImage2D: unknown texture for target");
+               "glCompressedTexSubImage2D", "unknown texture for target");
     return;
   }
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!info->GetLevelType(target, level, &type, &internal_format)) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glCompressedTexSubImage2D: level does not exist.");
+        "glCompressedTexSubImage2D", "level does not exist.");
     return;
   }
   if (internal_format != format) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glCompressedTexSubImage2D: format does not match internal format.");
+        "glCompressedTexSubImage2D", "format does not match internal format.");
     return;
   }
   if (!info->ValidForTexture(
       target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
-               "glCompressedTexSubImage2D: bad dimensions.");
+               "glCompressedTexSubImage2D", "bad dimensions.");
     return;
   }
+
+  if (!ValidateCompressedTexFuncData(
+      "glCompressedTexSubImage2D", width, height, format, image_size) ||
+      !ValidateCompressedTexSubDimensions(
+      "glCompressedTexSubImage2D",
+      target, level, xoffset, yoffset, width, height, format, info)) {
+    return;
+  }
+
+
   // Note: There is no need to deal with texture cleared tracking here
   // because the validation above means you can only get here if the level
   // is already a matching compressed format and in that case
   // CompressedTexImage2D already cleared the texture.
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, image_size, data);
 }
 
 static void Clip(
     GLint start, GLint range, GLint sourceRange,
@@ skipping 17 matching lines @@
     GLint level,
     GLenum internal_format,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLint border) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCopyTexImage2D: unknown texture for target");
+               "glCopyTexImage2D", "unknown texture for target");
     return;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCopyTexImage2D: texture is immutable");
+               "glCopyTexImage2D", "texture is immutable");
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
-    SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D: dimensions out of range");
+    SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
     return;
   }
   if (!ValidateTextureParameters(
       "glCopyTexImage2D", target, internal_format, GL_UNSIGNED_BYTE, level)) {
     return;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
 
   if ((channels_needed & channels_exist) != channels_needed) {
-    SetGLError(GL_INVALID_OPERATION, "glCopyTexImage2D: incompatible format");
+    SetGLError(GL_INVALID_OPERATION, "glCopyTexImage2D", "incompatible format");
     return;
   }
 
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glCopyImage2D: can not be used with depth or stencil textures");
+        "glCopyImage2D", "can not be used with depth or stencil textures");
     return;
   }
 
   if (!CheckBoundFramebuffersValid("glCopyTexImage2D")) {
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
@@ skipping 15 matching lines @@
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the texture.
     if (!ClearLevel(
         info->service_id(), info->target(),
         target, level, internal_format, GL_UNSIGNED_BYTE, width, height,
         info->IsImmutable())) {
-      SetGLError(GL_OUT_OF_MEMORY, "glCopyTexImage2D: dimensions too big");
+      SetGLError(GL_OUT_OF_MEMORY, "glCopyTexImage2D", "dimensions too big");
       return;
     }
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
@@ skipping 15 matching lines @@
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCopyTexSubImage2D: unknown texture for target");
+               "glCopyTexSubImage2D", "unknown texture for target");
     return;
   }
   GLenum type = 0;
   GLenum format = 0;
   if (!info->GetLevelType(target, level, &type, &format) ||
       !info->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
-               "glCopyTexSubImage2D: bad dimensions.");
+               "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(format);
 
   if ((channels_needed & channels_exist) != channels_needed) {
     SetGLError(
-        GL_INVALID_OPERATION, "glCopyTexSubImage2D: incompatible format");
+        GL_INVALID_OPERATION, "glCopyTexSubImage2D", "incompatible format");
     return;
   }
 
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glCopySubImage2D: can not be used with depth or stencil textures");
+        "glCopySubImage2D", "can not be used with depth or stencil textures");
     return;
   }
 
   if (!CheckBoundFramebuffersValid("glCopyTexSubImage2D")) {
     return;
   }
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
-    SetGLError(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D: dimensions too big");
+    SetGLError(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D", "dimensions too big");
     return;
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
     uint32 pixels_size = 0;
     if (!GLES2Util::ComputeImageDataSizes(
         width, height, format, type, unpack_alignment_, &pixels_size, NULL,
         NULL)) {
-      SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D: dimensions too large");
+      SetGLError(
+          GL_INVALID_VALUE, "glCopyTexSubImage2D", "dimensions too large");
       return;
     }
     scoped_array<char> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
 
   if (copyHeight > 0 && copyWidth > 0) {
@@ skipping 13 matching lines @@
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
   GLenum format,
   GLenum type,
   const void * data) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexSubImage2D: unknown texture for target");
+               "glTexSubImage2D", "unknown texture for target");
     return;
   }
   GLenum current_type = 0;
   GLenum internal_format = 0;
   if (!info->GetLevelType(target, level, &current_type, &internal_format)) {
     SetGLError(
-        GL_INVALID_OPERATION,
-        "glTexSubImage2D: level does not exist.");
+        GL_INVALID_OPERATION, "glTexSubImage2D", "level does not exist.");
     return;
   }
   if (format != internal_format) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexSubImage2D: format does not match internal format.");
+               "glTexSubImage2D", "format does not match internal format.");
     return;
   }
   if (type != current_type) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexSubImage2D: type does not match type of texture.");
+               "glTexSubImage2D", "type does not match type of texture.");
     return;
   }
 
   if (!info->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
-    SetGLError(GL_INVALID_VALUE,
-               "glTexSubImage2D: bad dimensions.");
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "bad dimensions.");
     return;
   }
 
   if ((GLES2Util::GetChannelsForFormat(format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glTexSubImage2D: can not supply data for depth or stencil textures");
+        "glTexSubImage2D", "can not supply data for depth or stencil textures");
     return;
   }
 
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
   DCHECK(ok);
   if (xoffset != 0 || yoffset != 0 ||
       width != tex_width || height != tex_height) {
     if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
-      SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D: dimensions too big");
+      SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");
       return;
     }
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
     return;
   }
 
   if (teximage2d_faster_than_texsubimage2d_ && !info->IsImmutable()) {
     // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
     // same as internal_foramt. If that changes we'll need to look them up.
@@ skipping 22 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");
+    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: 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");
+    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: type GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "type GL_INVALID_ENUM");
     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");
+    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: 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");
+    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "format GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
-    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: type GL_INVALID_ENUM");
+    SetGLError(GL_INVALID_ENUM, "glTexSubImage2D", "type GL_INVALID_ENUM");
     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");
+               "glGetVertexAttribPointerv", "pname GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
-               "glGetVertexAttribPointerv: index out of range.");
+               "glGetVertexAttribPointerv", "index out of range.");
     return error::kNoError;
   }
   result->SetNumResults(1);
   *result->GetData() =
       vertex_attrib_manager_->GetVertexAttribInfo(index)->offset();
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::GetUniformSetup(
     GLuint program, GLint fake_location,
@@ skipping 17 matching lines @@
   *result_pointer = result;
   // Set the result size to 0 so the client does not have to check for success.
   result->SetNumResults(0);
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program, "glGetUniform");
   if (!info) {
     return false;
   }
   if (!info->IsValid()) {
     // Program was not linked successfully. (ie, glLinkProgram)
-    SetGLError(GL_INVALID_OPERATION, "glGetUniform: program not linked");
+    SetGLError(GL_INVALID_OPERATION, "glGetUniform", "program not linked");
     return false;
   }
   *service_id = info->service_id();
   GLint array_index = -1;
   const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
       info->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!uniform_info) {
     // No such location.
-    SetGLError(GL_INVALID_OPERATION, "glGetUniform: unknown location");
+    SetGLError(GL_INVALID_OPERATION, "glGetUniform", "unknown location");
     return false;
   }
   GLenum type = uniform_info->type;
   GLsizei size = GLES2Util::GetGLDataTypeSizeForUniforms(type);
   if (size == 0) {
-    SetGLError(GL_INVALID_OPERATION, "glGetUniform: unknown type");
+    SetGLError(GL_INVALID_OPERATION, "glGetUniform", "unknown type");
     return false;
   }
   result = GetSharedMemoryAs<SizedResult<GLint>*>(
       shm_id, shm_offset, SizedResult<GLint>::ComputeSizeFromBytes(size));
   if (!result) {
     *error = error::kOutOfBounds;
     return false;
   }
   result->size = size;
   *result_type = type;
@@ skipping 58 matching lines @@
       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");
+               "glGetShaderPrecisionFormat", "shader_type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (!validators_->shader_precision.IsValid(precision_type)) {
     SetGLError(GL_INVALID_ENUM,
-               "glGetShaderPrecisionFormat: precision_type GL_INVALID_ENUM");
+               "glGetShaderPrecisionFormat", "precision_type GL_INVALID_ENUM");
     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 65 matching lines @@
     return error::kInvalidArguments;
   }
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program, "glGetActiveUniform");
   if (!info) {
     return error::kNoError;
   }
   const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
       info->GetUniformInfo(index);
   if (!uniform_info) {
-    SetGLError(GL_INVALID_VALUE, "glGetActiveUniform: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glGetActiveUniform", "index out of range");
     return error::kNoError;
   }
   result->success = 1;  // true.
   result->size = uniform_info->size;
   result->type = uniform_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(uniform_info->name.c_str());
   return error::kNoError;
 }
 
@@ skipping 13 matching lines @@
     return error::kInvalidArguments;
   }
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program, "glGetActiveAttrib");
   if (!info) {
     return error::kNoError;
   }
   const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
       info->GetAttribInfo(index);
   if (!attrib_info) {
-    SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib: index out of range");
+    SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib", "index out of range");
     return error::kNoError;
   }
   result->success = 1;  // true.
   result->size = attrib_info->size;
   result->type = attrib_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(attrib_info->name.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleShaderBinary(
     uint32 immediate_data_size, const gles2::ShaderBinary& c) {
 #if 1  // No binary shader support.
-  SetGLError(GL_INVALID_OPERATION, "glShaderBinary: not supported");
+  SetGLError(GL_INVALID_OPERATION, "glShaderBinary", "not supported");
   return error::kNoError;
 #else
   GLsizei n = static_cast<GLsizei>(c.n);
   if (n < 0) {
-    SetGLError(GL_INVALID_VALUE, "glShaderBinary: n < 0");
+    SetGLError(GL_INVALID_VALUE, "glShaderBinary", "n < 0");
     return error::kNoError;
   }
   GLsizei length = static_cast<GLsizei>(c.length);
   if (length < 0) {
-    SetGLError(GL_INVALID_VALUE, "glShaderBinary: length < 0");
+    SetGLError(GL_INVALID_VALUE, "glShaderBinary", "length < 0");
     return error::kNoError;
   }
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* shaders = GetSharedMemoryAs<const GLuint*>(
       c.shaders_shm_id, c.shaders_shm_offset, data_size);
   GLenum binaryformat = static_cast<GLenum>(c.binaryformat);
   const void* binary = GetSharedMemoryAs<const void*>(
       c.binary_shm_id, c.binary_shm_offset, length);
   if (shaders == NULL || binary == NULL) {
     return error::kOutOfBounds;
   }
   scoped_array<GLuint> service_ids(new GLuint[n]);
   for (GLsizei ii = 0; ii < n; ++ii) {
     ShaderManager::ShaderInfo* info = GetShaderInfo(shaders[ii]);
     if (!info) {
-      SetGLError(GL_INVALID_VALUE, "glShaderBinary: unknown shader");
+      SetGLError(GL_INVALID_VALUE, "glShaderBinary", "unknown shader");
       return error::kNoError;
     }
     service_ids[ii] = info->service_id();
   }
   // TODO(gman): call glShaderBinary
   return error::kNoError;
 #endif
 }
 
 error::Error GLES2DecoderImpl::HandleSwapBuffers(
@@ skipping 211 matching lines @@
   // 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");
+                 "glGetMulitpleCHROMIUM", "pname GL_INVALID_ENUM");
       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;
   if (!SafeMultiplyUint32(num_results, sizeof(GLint), &result_size)) {
     return error::kOutOfBounds;
   }
 
   if (result_size != static_cast<uint32>(c.size)) {
     SetGLError(GL_INVALID_VALUE,
-               "glGetMulitpleCHROMIUM: bad size GL_INVALID_VALUE");
+               "glGetMulitpleCHROMIUM", "bad size GL_INVALID_VALUE");
     return error::kNoError;
   }
 
   GLint* results = GetSharedMemoryAs<GLint*>(
       c.results_shm_id, c.results_shm_offset, result_size);
   if (results == NULL) {
     return error::kOutOfBounds;
   }
 
   // Check the results have been cleared in case the context was lost.
@@ skipping 31 matching lines @@
   info = GetProgramInfo(program);
   if (!info || !info->IsValid()) {
     return error::kNoError;
   }
   info->GetProgramInfo(program_manager(), bucket);
   return error::kNoError;
 }
 
 error::ContextLostReason GLES2DecoderImpl::GetContextLostReason() {
   switch (reset_status_) {
-  case GL_NO_ERROR:
-    // TODO(kbr): improve the precision of the error code in this case.
-    // Consider delegating to context for error code if MakeCurrent fails.
-    return error::kUnknown;
-  case GL_GUILTY_CONTEXT_RESET_ARB:
-    return error::kGuilty;
-  case GL_INNOCENT_CONTEXT_RESET_ARB:
-    return error::kInnocent;
-  case GL_UNKNOWN_CONTEXT_RESET_ARB:
-    return error::kUnknown;
+    case GL_NO_ERROR:
+      // TODO(kbr): improve the precision of the error code in this case.
+      // Consider delegating to context for error code if MakeCurrent fails.
+      return error::kUnknown;
+    case GL_GUILTY_CONTEXT_RESET_ARB:
+      return error::kGuilty;
+    case GL_INNOCENT_CONTEXT_RESET_ARB:
+      return error::kInnocent;
+    case GL_UNKNOWN_CONTEXT_RESET_ARB:
+      return error::kUnknown;
   }
 
   NOTREACHED();
   return error::kUnknown;
 }
 
 bool GLES2DecoderImpl::WasContextLost() {
   if (context_->WasAllocatedUsingARBRobustness() && has_arb_robustness_) {
     GLenum status = glGetGraphicsResetStatusARB();
     if (status != GL_NO_ERROR) {
@@ skipping 48 matching lines @@
   GLenum target = static_cast<GLenum>(c.target);
   GLuint client_id = static_cast<GLuint>(c.id);
   int32 sync_shm_id = static_cast<int32>(c.sync_data_shm_id);
   uint32 sync_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
 
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
       break;
     default:
       if (!feature_info_->feature_flags().occlusion_query_boolean) {
-        SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: not enabled");
+        SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "not enabled");
         return error::kNoError;
       }
       break;
   }
 
   if (current_query_) {
     SetGLError(
-        GL_INVALID_OPERATION, "glBeginQueryEXT: query already in progress");
+        GL_INVALID_OPERATION, "glBeginQueryEXT", "query already in progress");
     return error::kNoError;
   }
 
   if (client_id == 0) {
-    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: id is 0");
+    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "id is 0");
     return error::kNoError;
   }
 
   QueryManager::Query* query = query_manager_->GetQuery(client_id);
   if (!query) {
     // TODO(gman): Decide if we need this check.
     //
     // Checks id was made by glGenQueries
     //
     // From the POV of OpenGL ES 2.0 you need to call glGenQueriesEXT
     // for all Query ids but from the POV of the command buffer service maybe
     // you don't.
     //
     // The client can enforce this. I don't think the service cares.
     //
     // IdAllocatorInterface* id_allocator =
     //     group_->GetIdAllocator(id_namespaces::kQueries);
     // if (!id_allocator->InUse(client_id)) {
     //   SetGLError(GL_INVALID_OPERATION,
-    //              "glBeginQueryEXT: id not made by glGenQueriesEXT");
+    //              "glBeginQueryEXT", "id not made by glGenQueriesEXT");
     //   return error::kNoError;
     // }
     query = query_manager_->CreateQuery(
         target, client_id, sync_shm_id, sync_shm_offset);
   }
 
   if (query->target() != target) {
-    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: target does not match");
+    SetGLError(
+        GL_INVALID_OPERATION, "glBeginQueryEXT", "target does not match");
     return error::kNoError;
   } else if (query->shm_id() != sync_shm_id ||
              query->shm_offset() != sync_shm_offset) {
     DLOG(ERROR) << "Shared memory used by query not the same as before";
     return error::kInvalidArguments;
   }
 
   if (!query_manager_->BeginQuery(query)) {
     return error::kOutOfBounds;
   }
 
   current_query_ = query;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEndQueryEXT(
     uint32 immediate_data_size, const gles2::EndQueryEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 submit_count = static_cast<GLuint>(c.submit_count);
 
   if (!current_query_) {
-    SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT: No active query");
+    SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT", "No active query");
     return error::kNoError;
   }
   if (current_query_->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
-               "glEndQueryEXT: target does not match active query");
+               "glEndQueryEXT", "target does not match active query");
     return error::kNoError;
   }
 
   if (!query_manager_->EndQuery(current_query_, submit_count)) {
     return error::kOutOfBounds;
   }
 
   current_query_ = NULL;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const gles2::CreateStreamTextureCHROMIUM& c) {
   if (!feature_info_->feature_flags().chromium_stream_texture) {
     SetGLError(GL_INVALID_OPERATION,
-               "glOpenStreamTextureCHROMIUM: "
+               "glOpenStreamTextureCHROMIUM", ""
                "not supported.");
     return error::kNoError;
   }
 
   uint32 client_id = c.client_id;
   typedef gles2::CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
 
   if (!result)
     return error::kOutOfBounds;
   *result = GL_ZERO;
   TextureManager::TextureInfo* info =
       texture_manager()->GetTextureInfo(client_id);
   if (!info) {
     SetGLError(GL_INVALID_VALUE,
-               "glCreateStreamTextureCHROMIUM: "
+               "glCreateStreamTextureCHROMIUM", ""
                "bad texture id.");
     return error::kNoError;
   }
 
   if (info->IsStreamTexture()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCreateStreamTextureCHROMIUM: "
+               "glCreateStreamTextureCHROMIUM", ""
                "is already a stream texture.");
     return error::kNoError;
   }
 
   if (info->target() && info->target() != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
-               "glCreateStreamTextureCHROMIUM: "
+               "glCreateStreamTextureCHROMIUM", ""
                "is already bound to incompatible target.");
     return error::kNoError;
   }
 
   if (!stream_texture_manager_)
     return error::kInvalidArguments;
 
   GLuint object_id = stream_texture_manager_->CreateStreamTexture(
       info->service_id(), client_id);
 
   if (object_id) {
     info->SetStreamTexture(true);
   } else {
     SetGLError(GL_OUT_OF_MEMORY,
-               "glCreateStreamTextureCHROMIUM: "
+               "glCreateStreamTextureCHROMIUM", ""
                "failed to create platform texture.");
   }
 
   *result = object_id;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDestroyStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const gles2::DestroyStreamTextureCHROMIUM& c) {
   GLuint client_id = c.texture;
   TextureManager::TextureInfo* info =
       texture_manager()->GetTextureInfo(client_id);
   if (info && info->IsStreamTexture()) {
     if (!stream_texture_manager_)
       return error::kInvalidArguments;
 
     stream_texture_manager_->DestroyStreamTexture(info->service_id());
     info->SetStreamTexture(false);
     texture_manager()->SetInfoTarget(info, 0);
   } else {
     SetGLError(GL_INVALID_VALUE,
-               "glDestroyStreamTextureCHROMIUM: bad texture id.");
+               "glDestroyStreamTextureCHROMIUM", "bad texture id.");
   }
 
   return error::kNoError;
 }
 
 #if defined(OS_MACOSX)
 void GLES2DecoderImpl::ReleaseIOSurfaceForTexture(GLuint texture_id) {
   TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.find(
       texture_id);
   if (it != texture_to_io_surface_map_.end()) {
     // Found a previous IOSurface bound to this texture; release it.
     CFTypeRef surface = it->second;
     CFRelease(surface);
     texture_to_io_surface_map_.erase(it);
   }
 }
 #endif
 
 void GLES2DecoderImpl::DoTexImageIOSurface2DCHROMIUM(
     GLenum target, GLsizei width, GLsizei height,
     GLuint io_surface_id, GLuint plane) {
 #if defined(OS_MACOSX)
   if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
-    SetGLError(GL_INVALID_OPERATION,
-               "glTexImageIOSurface2DCHROMIUM: only supported on desktop GL.");
+    SetGLError(
+        GL_INVALID_OPERATION,
+        "glTexImageIOSurface2DCHROMIUM", "only supported on desktop GL.");
     return;
   }
 
   IOSurfaceSupport* surface_support = IOSurfaceSupport::Initialize();
   if (!surface_support) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexImageIOSurface2DCHROMIUM: only supported on 10.6.");
+               "glTexImageIOSurface2DCHROMIUM", "only supported on 10.6.");
     return;
   }
 
   if (target != GL_TEXTURE_RECTANGLE_ARB) {
     // This might be supported in the future, and if we could require
     // support for binding an IOSurface to a NPOT TEXTURE_2D texture, we
     // could delete a lot of code. For now, perform strict validation so we
     // know what's going on.
     SetGLError(
         GL_INVALID_OPERATION,
-        "glTexImageIOSurface2DCHROMIUM: requires TEXTURE_RECTANGLE_ARB target");
+        "glTexImageIOSurface2DCHROMIUM",
+        "requires TEXTURE_RECTANGLE_ARB target");
     return;
   }
 
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexImageIOSurface2DCHROMIUM: no rectangle texture bound");
+               "glTexImageIOSurface2DCHROMIUM", "no rectangle texture bound");
     return;
   }
   if (info == texture_manager()->GetDefaultTextureInfo(target)) {
     // Maybe this is conceptually valid, but disallow it to avoid accidents.
     SetGLError(GL_INVALID_OPERATION,
-               "glTexImageIOSurface2DCHROMIUM: can't bind default texture");
+               "glTexImageIOSurface2DCHROMIUM", "can't bind default texture");
     return;
   }
 
   // Look up the new IOSurface. Note that because of asynchrony
   // between processes this might fail; during live resizing the
   // plugin process might allocate and release an IOSurface before
   // this process gets a chance to look it up. Hold on to any old
   // IOSurface in this case.
   CFTypeRef surface = surface_support->IOSurfaceLookup(io_surface_id);
   if (!surface) {
-    SetGLError(GL_INVALID_OPERATION,
-               "glTexImageIOSurface2DCHROMIUM: no IOSurface with the given ID");
+    SetGLError(
+        GL_INVALID_OPERATION,
+        "glTexImageIOSurface2DCHROMIUM", "no IOSurface with the given ID");
     return;
   }
 
   // Release any IOSurface previously bound to this texture.
   ReleaseIOSurfaceForTexture(info->service_id());
 
   // Make sure we release the IOSurface even if CGLTexImageIOSurface2D fails.
   texture_to_io_surface_map_.insert(
       std::make_pair(info->service_id(), surface));
 
   CGLContextObj context =
       static_cast<CGLContextObj>(context_->GetHandle());
 
   CGLError err = surface_support->CGLTexImageIOSurface2D(
       context,
       target,
       GL_RGBA,
       width,
       height,
       GL_BGRA,
       GL_UNSIGNED_INT_8_8_8_8_REV,
       surface,
       plane);
 
   if (err != kCGLNoError) {
     SetGLError(
         GL_INVALID_OPERATION,
-        "glTexImageIOSurface2DCHROMIUM: error in CGLTexImageIOSurface2D");
+        "glTexImageIOSurface2DCHROMIUM", "error in CGLTexImageIOSurface2D");
     return;
   }
 
   texture_manager()->SetLevelInfo(
       info, target, 0, GL_RGBA, width, height, 1, 0,
       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, true);
 
 #else
   SetGLError(GL_INVALID_OPERATION,
-             "glTexImageIOSurface2DCHROMIUM: not supported.");
+             "glTexImageIOSurface2DCHROMIUM", "not supported.");
 #endif
 }
 
 static GLenum ExtractFormatFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
     case GL_RGB565:
       return GL_RGB;
     case GL_RGBA4:
       return GL_RGBA;
     case GL_RGB5_A1:
@@ skipping 35 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
     GLenum target, GLuint source_id, GLuint dest_id, GLint level,
     GLenum internal_format) {
   TextureManager::TextureInfo* dest_info = GetTextureInfo(dest_id);
   TextureManager::TextureInfo* source_info = GetTextureInfo(source_id);
 
   if (!source_info || !dest_info) {
-    SetGLError(GL_INVALID_VALUE, "glCopyTextureCHROMIUM: unknown texture id");
+    SetGLError(GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "unknown texture id");
     return;
   }
 
   if (GL_TEXTURE_2D != target) {
     SetGLError(GL_INVALID_VALUE,
-               "glCopyTextureCHROMIUM: invalid texture target");
+               "glCopyTextureCHROMIUM", "invalid texture target");
     return;
   }
 
   if (dest_info->target() != GL_TEXTURE_2D ||
       source_info->target() != GL_TEXTURE_2D) {
     SetGLError(GL_INVALID_VALUE,
-               "glCopyTextureCHROMIUM: invalid texture target binding");
+               "glCopyTextureCHROMIUM", "invalid texture target binding");
     return;
   }
 
   int source_width, source_height, dest_width, dest_height;
   if (!source_info->GetLevelSize(GL_TEXTURE_2D, 0, &source_width,
                                  &source_height)) {
     SetGLError(GL_INVALID_VALUE,
-               "glCopyTextureChromium: source texture has no level 0");
+               "glCopyTextureChromium", "source texture has no level 0");
     return;
   }
 
   // Check that this type of texture is allowed.
   if (!texture_manager()->ValidForTarget(GL_TEXTURE_2D, level, source_width,
                                          source_height, 1)) {
     SetGLError(GL_INVALID_VALUE,
-             "glCopyTextureCHROMIUM: Bad dimensions");
+             "glCopyTextureCHROMIUM", "Bad dimensions");
     return;
   }
 
   // Defer initializing the CopyTextureCHROMIUMResourceManager until it is
   // needed because it takes 10s of milliseconds to initialize.
   if (!copy_texture_CHROMIUM_.get()) {
     CopyRealGLErrorsToWrapper();
     copy_texture_CHROMIUM_.reset(new CopyTextureCHROMIUMResourceManager());
     copy_texture_CHROMIUM_->Initialize();
     RestoreCurrentFramebufferBindings();
@@ skipping 110 matching lines @@
 
 void GLES2DecoderImpl::DoTexStorage2DEXT(
     GLenum target,
     GLint levels,
     GLenum internal_format,
     GLsizei width,
     GLsizei height) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoTexStorage2DEXT");
   if (!texture_manager()->ValidForTarget(target, 0, width, height, 1) ||
       TextureManager::ComputeMipMapCount(width, height, 1) < levels) {
-    SetGLError(GL_INVALID_VALUE, "glTexStorage2DEXT: dimensions out of range");
+    SetGLError(
+        GL_INVALID_VALUE, "glTexStorage2DEXT", "dimensions out of range");
     return;
   }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexStorage2DEXT: unknown texture for target");
+               "glTexStorage2DEXT", "unknown texture for target");
     return;
   }
   if (info->IsAttachedToFramebuffer()) {
     state_dirty_ = true;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glTexStorage2DEXT: texture is immutable");
+               "glTexStorage2DEXT", "texture is immutable");
     return;
   }
   CopyRealGLErrorsToWrapper();
   glTexStorage2DEXT(target, levels, GetTexInternalFormat(internal_format),
                     width, height);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     GLenum format = ExtractFormatFromStorageFormat(internal_format);
     GLenum type = ExtractTypeFromStorageFormat(internal_format);
     GLsizei level_width = width;
@@ skipping 20 matching lines @@
   bucket->SetData(&name, 0, GL_MAILBOX_SIZE_CHROMIUM);
 
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoProduceTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glProduceTextureCHROMIUM: unknown texture for target");
+               "glProduceTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
   TextureDefinition* definition = texture_manager()->Save(info);
   if (!definition) {
     SetGLError(GL_INVALID_OPERATION,
-               "glProduceTextureCHROMIUM: invalid texture");
+               "glProduceTextureCHROMIUM", "invalid texture");
     return;
   }
 
   if (!group_->mailbox_manager()->ProduceTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox),
       definition,
       texture_manager())) {
     bool success = texture_manager()->Restore(info, definition);
     DCHECK(success);
     SetGLError(GL_INVALID_OPERATION,
-               "glProduceTextureCHROMIUM: invalid mailbox name");
+               "glProduceTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
   BindAndApplyTextureParameters(info);
 }
 
 void GLES2DecoderImpl::DoConsumeTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
-               "glConsumeTextureCHROMIUM: unknown texture for target");
+               "glConsumeTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
   scoped_ptr<TextureDefinition> definition(
       group_->mailbox_manager()->ConsumeTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox)));
   if (!definition.get()) {
     SetGLError(GL_INVALID_OPERATION,
-               "glConsumeTextureCHROMIUM: invalid mailbox name");
+               "glConsumeTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
   if (!texture_manager()->Restore(info, definition.release())) {
     SetGLError(GL_INVALID_OPERATION,
-               "glConsumeTextureCHROMIUM: invalid texture");
+               "glConsumeTextureCHROMIUM", "invalid texture");
     return;
   }
 
   BindAndApplyTextureParameters(info);
 }
 
 // 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