Adds validation for GLsizei and GLsizeiptr types.

TEST=none
BUG=none

Review URL: http://codereview.chromium.org/660105

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@40048 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 631 insertions, 12 deletions

diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 77bfc3c..2b04de6 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -332,10 +332,7 @@ class GLES2DecoderImpl : public GLES2Decoder {
   // Template to help call glGenXXX functions.
   template <void gl_gen_function(GLES2DecoderImpl*, GLsizei, GLuint*)>
   bool GenGLObjects(GLsizei n, const GLuint* client_ids) {
-    if (n < 0) {
-      SetGLError(GL_INVALID_VALUE);
-      return true;
-    }
+    DCHECK_GE(n, 0);
     if (!ValidateIdsAreUnused(n, client_ids)) {
       return false;
     }
@@ -347,6 +344,7 @@ class GLES2DecoderImpl : public GLES2Decoder {
   // Template to help call glDeleteXXX functions.
   template <void gl_delete_function(GLES2DecoderImpl*, GLsizei, GLuint*)>
   bool DeleteGLObjects(GLsizei n, const GLuint* client_ids) {
+    DCHECK_GE(n, 0);
     scoped_array<GLuint>temp(new GLuint[n]);
     UnregisterObjects(n, client_ids, temp.get());
     gl_delete_function(this, n, temp.get());
@@ -1951,8 +1949,10 @@ error::Error GLES2DecoderImpl::HandleDrawElements(
     GLsizei count = c.count;
     GLenum type = c.type;
     int32 offset = c.index_offset;
-    if (!ValidateGLenumDrawMode(mode) ||
-        !ValidateGLenumIndexType(type)) {
+    if (count < 0) {
+      SetGLError(GL_INVALID_VALUE);
+    } else if (!ValidateGLenumDrawMode(mode) ||
+               !ValidateGLenumIndexType(type)) {
       SetGLError(GL_INVALID_ENUM);
     } else {
       GLsizeiptr buffer_size = bound_element_array_buffer_->size();
@@ -2075,9 +2075,13 @@ error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
     GLsizei offset = c.offset;
     const void* ptr = reinterpret_cast<const void*>(offset);
     if (!ValidateGLenumVertexAttribType(type) ||
-        !ValidateGLintVertexAttribSize(size) ||
-        indx >= group_->max_vertex_attribs() ||
-        stride < 0) {
+        !ValidateGLintVertexAttribSize(size)) {
+      SetGLError(GL_INVALID_ENUM);
+      return error::kNoError;
+    }
+    if (indx >= group_->max_vertex_attribs() ||
+        stride < 0 ||
+        offset < 0) {
       SetGLError(GL_INVALID_VALUE);
       return error::kNoError;
     }
@@ -2123,6 +2127,10 @@ error::Error GLES2DecoderImpl::HandleReadPixels(
 
   if (!ValidateGLenumReadPixelFormat(format) ||
       !ValidateGLenumPixelType(type)) {
+    SetGLError(GL_INVALID_ENUM);
+    return error::kNoError;
+  }
+  if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
@@ -2141,8 +2149,11 @@ error::Error GLES2DecoderImpl::HandlePixelStorei(
     uint32 immediate_data_size, const gles2::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
-  if (!ValidateGLenumPixelStore(pname) ||
-      !ValidateGLintPixelStoreAlignment(param)) {
+  if (!ValidateGLenumPixelStore(pname)) {
+    SetGLError(GL_INVALID_ENUM);
+    return error::kNoError;
+  }
+  if (!ValidateGLintPixelStoreAlignment(param)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
@@ -2282,6 +2293,10 @@ error::Error GLES2DecoderImpl::HandleBufferData(
   }
   if (!ValidateGLenumBufferTarget(target) ||
       !ValidateGLenumBufferUsage(usage)) {
+    SetGLError(GL_INVALID_ENUM);
+    return error::kNoError;
+  }
+  if (size < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
@@ -2320,6 +2335,10 @@ error::Error GLES2DecoderImpl::HandleBufferDataImmediate(
   GLenum usage = static_cast<GLenum>(c.usage);
   if (!ValidateGLenumBufferTarget(target) ||
       !ValidateGLenumBufferUsage(usage)) {
+    SetGLError(GL_INVALID_ENUM);
+    return error::kNoError;
+  }
+  if (size < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index 12d387f..d22a900 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -11,7 +11,7 @@
 error::Error GLES2DecoderImpl::HandleActiveTexture(
     uint32 immediate_data_size, const gles2::ActiveTexture& c) {
   GLenum texture = static_cast<GLenum>(c.texture);
-  glActiveTexture(texture);
+  DoActiveTexture(texture);
   return error::kNoError;
 }
 
@@ -224,6 +224,10 @@ error::Error GLES2DecoderImpl::HandleBufferSubData(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (size < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
@@ -243,6 +247,10 @@ error::Error GLES2DecoderImpl::HandleBufferSubDataImmediate(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (size < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
@@ -330,6 +338,18 @@ error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2D(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (imageSize < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
@@ -356,6 +376,18 @@ error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2DImmediate(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (imageSize < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (data == NULL) {
     return error::kOutOfBounds;
   }
@@ -378,6 +410,14 @@ error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
   return error::kNoError;
 }
@@ -396,6 +436,14 @@ error::Error GLES2DecoderImpl::HandleCopyTexSubImage2D(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
   return error::kNoError;
 }
@@ -436,6 +484,10 @@ error::Error GLES2DecoderImpl::HandleDeleteBuffers(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* buffers = GetSharedMemoryAs<const GLuint*>(
       c.buffers_shm_id, c.buffers_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -449,6 +501,10 @@ error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* buffers = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -462,6 +518,10 @@ error::Error GLES2DecoderImpl::HandleDeleteFramebuffers(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>(
       c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -475,6 +535,10 @@ error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* framebuffers = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -488,6 +552,10 @@ error::Error GLES2DecoderImpl::HandleDeleteRenderbuffers(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>(
       c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -501,6 +569,10 @@ error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* renderbuffers = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -514,6 +586,10 @@ error::Error GLES2DecoderImpl::HandleDeleteTextures(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* textures = GetSharedMemoryAs<const GLuint*>(
       c.textures_shm_id, c.textures_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
@@ -527,6 +603,10 @@ error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
   uint32 data_size = n * sizeof(GLuint);
   const GLuint* textures = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
@@ -603,6 +683,10 @@ error::Error GLES2DecoderImpl::HandleDrawArrays(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   DoDrawArrays(mode, first, count);
   return error::kNoError;
 }
@@ -708,6 +792,10 @@ error::Error GLES2DecoderImpl::HandleGenBuffers(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* buffers = GetSharedMemoryAs<GLuint*>(
       c.buffers_shm_id, c.buffers_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -723,6 +811,10 @@ error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* buffers = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -749,6 +841,10 @@ error::Error GLES2DecoderImpl::HandleGenFramebuffers(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* framebuffers = GetSharedMemoryAs<GLuint*>(
       c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -764,6 +860,10 @@ error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* framebuffers = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -779,6 +879,10 @@ error::Error GLES2DecoderImpl::HandleGenRenderbuffers(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>(
       c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -794,6 +898,10 @@ error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* renderbuffers = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
@@ -809,6 +917,10 @@ error::Error GLES2DecoderImpl::HandleGenTextures(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* textures = GetSharedMemoryAs<GLuint*>(
       c.textures_shm_id, c.textures_shm_offset, data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
@@ -824,6 +936,10 @@ error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
   uint32 data_size = n * sizeof(GLuint);
   GLuint* textures = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
+  if (n < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
@@ -984,6 +1100,10 @@ error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
   }
   char* infolog = GetSharedMemoryAs<char*>(
       c.infolog_shm_id, c.infolog_shm_offset, bufsize);
+  if (bufsize < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (infolog == NULL) {
     return error::kOutOfBounds;
   }
@@ -1059,6 +1179,10 @@ error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
   }
   char* infolog = GetSharedMemoryAs<char*>(
       c.infolog_shm_id, c.infolog_shm_offset, bufsize);
+  if (bufsize < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (infolog == NULL) {
     return error::kOutOfBounds;
   }
@@ -1086,6 +1210,10 @@ error::Error GLES2DecoderImpl::HandleGetShaderSource(
   }
   char* source = GetSharedMemoryAs<char*>(
       c.source_shm_id, c.source_shm_offset, bufsize);
+  if (bufsize < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (source == NULL) {
     return error::kOutOfBounds;
   }
@@ -1339,6 +1467,14 @@ error::Error GLES2DecoderImpl::HandleRenderbufferStorage(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   glRenderbufferStorageEXT(target, internalformat, width, height);
   return error::kNoError;
 }
@@ -1357,6 +1493,14 @@ error::Error GLES2DecoderImpl::HandleScissor(
   GLint y = static_cast<GLint>(c.y);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   glScissor(x, y, width, height);
   return error::kNoError;
 }
@@ -1602,6 +1746,14 @@ error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLenumTextureFormat(format)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
@@ -1636,6 +1788,14 @@ error::Error GLES2DecoderImpl::HandleTexSubImage2DImmediate(
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLenumTextureFormat(format)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
@@ -1668,6 +1828,10 @@ error::Error GLES2DecoderImpl::HandleUniform1fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 1);
   const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1683,6 +1847,10 @@ error::Error GLES2DecoderImpl::HandleUniform1fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 1);
   const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1706,6 +1874,10 @@ error::Error GLES2DecoderImpl::HandleUniform1iv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 1);
   const GLint* v = GetSharedMemoryAs<const GLint*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1721,6 +1893,10 @@ error::Error GLES2DecoderImpl::HandleUniform1ivImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 1);
   const GLint* v = GetImmediateDataAs<const GLint*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1745,6 +1921,10 @@ error::Error GLES2DecoderImpl::HandleUniform2fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 2);
   const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1760,6 +1940,10 @@ error::Error GLES2DecoderImpl::HandleUniform2fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 2);
   const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1784,6 +1968,10 @@ error::Error GLES2DecoderImpl::HandleUniform2iv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 2);
   const GLint* v = GetSharedMemoryAs<const GLint*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1799,6 +1987,10 @@ error::Error GLES2DecoderImpl::HandleUniform2ivImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 2);
   const GLint* v = GetImmediateDataAs<const GLint*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1824,6 +2016,10 @@ error::Error GLES2DecoderImpl::HandleUniform3fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 3);
   const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1839,6 +2035,10 @@ error::Error GLES2DecoderImpl::HandleUniform3fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 3);
   const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1864,6 +2064,10 @@ error::Error GLES2DecoderImpl::HandleUniform3iv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 3);
   const GLint* v = GetSharedMemoryAs<const GLint*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1879,6 +2083,10 @@ error::Error GLES2DecoderImpl::HandleUniform3ivImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 3);
   const GLint* v = GetImmediateDataAs<const GLint*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1905,6 +2113,10 @@ error::Error GLES2DecoderImpl::HandleUniform4fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 4);
   const GLfloat* v = GetSharedMemoryAs<const GLfloat*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1920,6 +2132,10 @@ error::Error GLES2DecoderImpl::HandleUniform4fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 4);
   const GLfloat* v = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1946,6 +2162,10 @@ error::Error GLES2DecoderImpl::HandleUniform4iv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 4);
   const GLint* v = GetSharedMemoryAs<const GLint*>(
       c.v_shm_id, c.v_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1961,6 +2181,10 @@ error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLint), 4);
   const GLint* v = GetImmediateDataAs<const GLint*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (v == NULL) {
     return error::kOutOfBounds;
   }
@@ -1977,6 +2201,10 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix2fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 4);
   const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
       c.value_shm_id, c.value_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLbooleanFalse(transpose)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
@@ -1997,6 +2225,10 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 4);
   const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLbooleanFalse(transpose)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
@@ -2017,6 +2249,10 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix3fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 9);
   const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
       c.value_shm_id, c.value_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLbooleanFalse(transpose)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
@@ -2037,6 +2273,10 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 9);
   const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLbooleanFalse(transpose)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
@@ -2057,6 +2297,10 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix4fv(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 16);
   const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
       c.value_shm_id, c.value_shm_offset, data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLbooleanFalse(transpose)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
@@ -2077,6 +2321,10 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
       ComputeImmediateDataSize(immediate_data_size, 1, sizeof(GLfloat), 16);
   const GLfloat* value = GetImmediateDataAs<const GLfloat*>(
       c, data_size, immediate_data_size);
+  if (count < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   if (!ValidateGLbooleanFalse(transpose)) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
@@ -2266,6 +2514,14 @@ error::Error GLES2DecoderImpl::HandleViewport(
   GLint y = static_cast<GLint>(c.y);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
   glViewport(x, y, width, height);
   return error::kNoError;
 }
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
index bfbbd25..5b422bf 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
@@ -43,6 +43,7 @@ TEST_F(GLES2DecoderTest1, BindBufferInvalidArgs0_0) {
   BindBuffer cmd;
   cmd.Init(GL_RENDERBUFFER, client_buffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BindFramebufferValidArgs) {
@@ -76,6 +77,7 @@ TEST_F(GLES2DecoderTest1, BindTextureInvalidArgs0_0) {
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_1D, client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BindTextureInvalidArgs0_1) {
@@ -84,6 +86,7 @@ TEST_F(GLES2DecoderTest1, BindTextureInvalidArgs0_1) {
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_3D, client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendColorValidArgs) {
@@ -108,6 +111,7 @@ TEST_F(GLES2DecoderTest1, BlendEquationInvalidArgs0_0) {
   BlendEquation cmd;
   cmd.Init(GL_MIN);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendEquationInvalidArgs0_1) {
@@ -116,6 +120,7 @@ TEST_F(GLES2DecoderTest1, BlendEquationInvalidArgs0_1) {
   BlendEquation cmd;
   cmd.Init(GL_MAX);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendEquationSeparateValidArgs) {
@@ -132,6 +137,7 @@ TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_0) {
   BlendEquationSeparate cmd;
   cmd.Init(GL_MIN, GL_FUNC_ADD);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_1) {
@@ -140,6 +146,7 @@ TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_1) {
   BlendEquationSeparate cmd;
   cmd.Init(GL_MAX, GL_FUNC_ADD);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_0) {
@@ -148,6 +155,7 @@ TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_0) {
   BlendEquationSeparate cmd;
   cmd.Init(GL_FUNC_ADD, GL_MIN);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_1) {
@@ -156,6 +164,7 @@ TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_1) {
   BlendEquationSeparate cmd;
   cmd.Init(GL_FUNC_ADD, GL_MAX);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, BlendFuncValidArgs) {
@@ -253,6 +262,25 @@ TEST_F(GLES2DecoderTest1, CopyTexImage2DInvalidArgs0_0) {
   CopyTexImage2D cmd;
   cmd.Init(GL_PROXY_TEXTURE_CUBE_MAP, 2, 3, 4, 5, 6, 7, 8);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest1, CopyTexImage2DInvalidArgs5_0) {
+  EXPECT_CALL(*gl_, CopyTexImage2D(_, _, _, _, _, _, _, _)).Times(0);
+  SpecializedSetup<CopyTexImage2D, 0>();
+  CopyTexImage2D cmd;
+  cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, -1, 7, 8);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest1, CopyTexImage2DInvalidArgs6_0) {
+  EXPECT_CALL(*gl_, CopyTexImage2D(_, _, _, _, _, _, _, _)).Times(0);
+  SpecializedSetup<CopyTexImage2D, 0>();
+  CopyTexImage2D cmd;
+  cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, 6, -1, 8);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, CopyTexSubImage2DValidArgs) {
@@ -269,6 +297,25 @@ TEST_F(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs0_0) {
   CopyTexSubImage2D cmd;
   cmd.Init(GL_PROXY_TEXTURE_CUBE_MAP, 2, 3, 4, 5, 6, 7, 8);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs6_0) {
+  EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
+  SpecializedSetup<CopyTexSubImage2D, 0>();
+  CopyTexSubImage2D cmd;
+  cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, 6, -1, 8);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs7_0) {
+  EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
+  SpecializedSetup<CopyTexSubImage2D, 0>();
+  CopyTexSubImage2D cmd;
+  cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, 6, 7, -1);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, CreateProgramValidArgs) {
@@ -541,6 +588,7 @@ TEST_F(GLES2DecoderTest1, DisableInvalidArgs0_0) {
   Disable cmd;
   cmd.Init(GL_CLIP_PLANE0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, DisableInvalidArgs0_1) {
@@ -549,6 +597,7 @@ TEST_F(GLES2DecoderTest1, DisableInvalidArgs0_1) {
   Disable cmd;
   cmd.Init(GL_POINT_SPRITE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, DisableVertexAttribArrayValidArgs) {
@@ -576,6 +625,7 @@ TEST_F(GLES2DecoderTest1, EnableInvalidArgs0_0) {
   Enable cmd;
   cmd.Init(GL_CLIP_PLANE0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, EnableInvalidArgs0_1) {
@@ -584,6 +634,7 @@ TEST_F(GLES2DecoderTest1, EnableInvalidArgs0_1) {
   Enable cmd;
   cmd.Init(GL_POINT_SPRITE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, EnableVertexAttribArrayValidArgs) {
@@ -644,6 +695,7 @@ TEST_F(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs2_0) {
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_PROXY_TEXTURE_CUBE_MAP,
       client_texture_id_, 5);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, FrontFaceValidArgs) {
@@ -709,6 +761,7 @@ TEST_F(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_0) {
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_1D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
@@ -717,6 +770,7 @@ TEST_F(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_3D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GenFramebuffersValidArgs) {
@@ -901,6 +955,7 @@ TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs0_0) {
       GL_RENDERBUFFER, GL_BUFFER_SIZE, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs1_0) {
@@ -911,6 +966,7 @@ TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs1_0) {
       GL_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_0) {
@@ -1157,6 +1213,7 @@ TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs0_0) {
       GL_PROXY_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs1_0) {
@@ -1167,6 +1224,7 @@ TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs1_0) {
       GL_TEXTURE_2D, GL_GENERATE_MIPMAP, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_0) {
@@ -1208,6 +1266,7 @@ TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs0_0) {
       GL_PROXY_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs1_0) {
@@ -1218,6 +1277,7 @@ TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs1_0) {
       GL_TEXTURE_2D, GL_GENERATE_MIPMAP, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_0) {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index e9215e7..c0b52fa 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
@@ -97,6 +97,7 @@ TEST_F(GLES2DecoderTest2, HintInvalidArgs0_0) {
   Hint cmd;
   cmd.Init(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, IsBufferValidArgs) {
@@ -121,6 +122,7 @@ TEST_F(GLES2DecoderTest2, IsEnabledInvalidArgs0_0) {
   IsEnabled cmd;
   cmd.Init(GL_CLIP_PLANE0, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, IsEnabledInvalidArgs0_1) {
@@ -129,6 +131,7 @@ TEST_F(GLES2DecoderTest2, IsEnabledInvalidArgs0_1) {
   IsEnabled cmd;
   cmd.Init(GL_POINT_SPRITE, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, IsFramebufferValidArgs) {
@@ -207,6 +210,24 @@ TEST_F(GLES2DecoderTest2, RenderbufferStorageValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs2_0) {
+  EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
+  SpecializedSetup<RenderbufferStorage, 0>();
+  RenderbufferStorage cmd;
+  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, -1, 4);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs3_0) {
+  EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
+  SpecializedSetup<RenderbufferStorage, 0>();
+  RenderbufferStorage cmd;
+  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, -1);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, SampleCoverageValidArgs) {
   EXPECT_CALL(*gl_, SampleCoverage(1, 2));
   SpecializedSetup<SampleCoverage, 0>();
@@ -222,6 +243,24 @@ TEST_F(GLES2DecoderTest2, ScissorValidArgs) {
   cmd.Init(1, 2, 3, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
+
+TEST_F(GLES2DecoderTest2, ScissorInvalidArgs2_0) {
+  EXPECT_CALL(*gl_, Scissor(_, _, _, _)).Times(0);
+  SpecializedSetup<Scissor, 0>();
+  Scissor cmd;
+  cmd.Init(1, 2, -1, 4);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest2, ScissorInvalidArgs3_0) {
+  EXPECT_CALL(*gl_, Scissor(_, _, _, _)).Times(0);
+  SpecializedSetup<Scissor, 0>();
+  Scissor cmd;
+  cmd.Init(1, 2, 3, -1);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
 // TODO(gman): ShaderSource
 
 // TODO(gman): ShaderSourceImmediate
@@ -293,6 +332,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
   TexParameterf cmd;
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
@@ -301,6 +341,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
   TexParameterf cmd;
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
@@ -309,6 +350,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
   TexParameterf cmd;
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvValidArgs) {
@@ -332,6 +374,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
       GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
@@ -342,6 +385,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
       GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
@@ -352,6 +396,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
       GL_TEXTURE_2D, GL_GENERATE_MIPMAP, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
@@ -393,6 +438,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
@@ -403,6 +449,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
@@ -413,6 +460,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameteriValidArgs) {
@@ -429,6 +477,7 @@ TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_0) {
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_1) {
@@ -437,6 +486,7 @@ TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_1) {
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
@@ -445,6 +495,7 @@ TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivValidArgs) {
@@ -468,6 +519,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
       GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
@@ -478,6 +530,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
       GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
@@ -488,6 +541,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
       GL_TEXTURE_2D, GL_GENERATE_MIPMAP, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
@@ -529,6 +583,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
@@ -539,6 +594,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
@@ -549,6 +605,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 // TODO(gman): TexSubImage2D
 
@@ -573,6 +630,15 @@ TEST_F(GLES2DecoderTest2, Uniform1fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform1fv, 0>();
+  Uniform1fv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform1fv, 0>();
@@ -601,6 +667,17 @@ TEST_F(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
+
+TEST_F(GLES2DecoderTest2, Uniform1fvImmediateInvalidArgs1_0) {
+  Uniform1fvImmediate& cmd = *GetImmediateAs<Uniform1fvImmediate>();
+  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform1fvImmediate, 0>();
+  GLfloat temp[1 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
 // TODO(gman): Uniform1i
 // TODO(gman): Uniform1iv
 // TODO(gman): Uniform1ivImmediate
@@ -623,6 +700,15 @@ TEST_F(GLES2DecoderTest2, Uniform2fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform2fv, 0>();
+  Uniform2fv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2fv, 0>();
@@ -652,6 +738,17 @@ TEST_F(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform2fvImmediateInvalidArgs1_0) {
+  Uniform2fvImmediate& cmd = *GetImmediateAs<Uniform2fvImmediate>();
+  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform2fvImmediate, 0>();
+  GLfloat temp[2 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform2iValidArgs) {
   EXPECT_CALL(*gl_, Uniform2i(1, 2, 3));
   SpecializedSetup<Uniform2i, 0>();
@@ -670,6 +767,15 @@ TEST_F(GLES2DecoderTest2, Uniform2ivValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform2iv, 0>();
+  Uniform2iv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2iv, 0>();
@@ -699,6 +805,17 @@ TEST_F(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform2ivImmediateInvalidArgs1_0) {
+  Uniform2ivImmediate& cmd = *GetImmediateAs<Uniform2ivImmediate>();
+  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform2ivImmediate, 0>();
+  GLint temp[2 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform3fValidArgs) {
   EXPECT_CALL(*gl_, Uniform3f(1, 2, 3, 4));
   SpecializedSetup<Uniform3f, 0>();
@@ -717,6 +834,15 @@ TEST_F(GLES2DecoderTest2, Uniform3fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform3fv, 0>();
+  Uniform3fv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3fv, 0>();
@@ -746,6 +872,17 @@ TEST_F(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform3fvImmediateInvalidArgs1_0) {
+  Uniform3fvImmediate& cmd = *GetImmediateAs<Uniform3fvImmediate>();
+  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform3fvImmediate, 0>();
+  GLfloat temp[3 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform3iValidArgs) {
   EXPECT_CALL(*gl_, Uniform3i(1, 2, 3, 4));
   SpecializedSetup<Uniform3i, 0>();
@@ -764,6 +901,15 @@ TEST_F(GLES2DecoderTest2, Uniform3ivValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform3iv, 0>();
+  Uniform3iv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3iv, 0>();
@@ -793,6 +939,17 @@ TEST_F(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform3ivImmediateInvalidArgs1_0) {
+  Uniform3ivImmediate& cmd = *GetImmediateAs<Uniform3ivImmediate>();
+  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform3ivImmediate, 0>();
+  GLint temp[3 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform4fValidArgs) {
   EXPECT_CALL(*gl_, Uniform4f(1, 2, 3, 4, 5));
   SpecializedSetup<Uniform4f, 0>();
@@ -811,6 +968,15 @@ TEST_F(GLES2DecoderTest2, Uniform4fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform4fv, 0>();
+  Uniform4fv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4fv, 0>();
@@ -840,6 +1006,17 @@ TEST_F(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform4fvImmediateInvalidArgs1_0) {
+  Uniform4fvImmediate& cmd = *GetImmediateAs<Uniform4fvImmediate>();
+  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform4fvImmediate, 0>();
+  GLfloat temp[4 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform4iValidArgs) {
   EXPECT_CALL(*gl_, Uniform4i(1, 2, 3, 4, 5));
   SpecializedSetup<Uniform4i, 0>();
@@ -858,6 +1035,15 @@ TEST_F(GLES2DecoderTest2, Uniform4ivValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform4iv, 0>();
+  Uniform4iv cmd;
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4iv, 0>();
@@ -887,6 +1073,17 @@ TEST_F(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, Uniform4ivImmediateInvalidArgs1_0) {
+  Uniform4ivImmediate& cmd = *GetImmediateAs<Uniform4ivImmediate>();
+  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
+  SpecializedSetup<Uniform4ivImmediate, 0>();
+  GLint temp[4 * 2] = { 0, };
+  cmd.Init(1, -1, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
   EXPECT_CALL(
       *gl_, UniformMatrix2fv(
@@ -898,12 +1095,22 @@ TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
+  SpecializedSetup<UniformMatrix2fv, 0>();
+  UniformMatrix2fv cmd;
+  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix2fv, 0>();
   UniformMatrix2fv cmd;
   cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
@@ -936,6 +1143,18 @@ TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs1_0) {
+  UniformMatrix2fvImmediate& cmd =
+      *GetImmediateAs<UniformMatrix2fvImmediate>();
+  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
+  SpecializedSetup<UniformMatrix2fvImmediate, 0>();
+  GLfloat temp[4 * 2] = { 0, };
+  cmd.Init(1, -1, false, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
   UniformMatrix2fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix2fvImmediate>();
@@ -945,6 +1164,7 @@ TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
   cmd.Init(1, 2, true, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
@@ -958,12 +1178,22 @@ TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
+  SpecializedSetup<UniformMatrix3fv, 0>();
+  UniformMatrix3fv cmd;
+  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix3fv, 0>();
   UniformMatrix3fv cmd;
   cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
@@ -996,6 +1226,18 @@ TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs1_0) {
+  UniformMatrix3fvImmediate& cmd =
+      *GetImmediateAs<UniformMatrix3fvImmediate>();
+  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
+  SpecializedSetup<UniformMatrix3fvImmediate, 0>();
+  GLfloat temp[9 * 2] = { 0, };
+  cmd.Init(1, -1, false, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
   UniformMatrix3fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix3fvImmediate>();
@@ -1005,6 +1247,7 @@ TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
   cmd.Init(1, 2, true, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
@@ -1018,12 +1261,22 @@ TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
+  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
+  SpecializedSetup<UniformMatrix4fv, 0>();
+  UniformMatrix4fv cmd;
+  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix4fv, 0>();
   UniformMatrix4fv cmd;
   cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
@@ -1056,6 +1309,18 @@ TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs1_0) {
+  UniformMatrix4fvImmediate& cmd =
+      *GetImmediateAs<UniformMatrix4fvImmediate>();
+  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
+  SpecializedSetup<UniformMatrix4fvImmediate, 0>();
+  GLfloat temp[16 * 2] = { 0, };
+  cmd.Init(1, -1, false, &temp[0]);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
   UniformMatrix4fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix4fvImmediate>();
@@ -1065,6 +1330,7 @@ TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
   cmd.Init(1, 2, true, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
+  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 // TODO(gman): UseProgram
 
@@ -1273,6 +1539,24 @@ TEST_F(GLES2DecoderTest2, ViewportValidArgs) {
   cmd.Init(1, 2, 3, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
+
+TEST_F(GLES2DecoderTest2, ViewportInvalidArgs2_0) {
+  EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
+  SpecializedSetup<Viewport, 0>();
+  Viewport cmd;
+  cmd.Init(1, 2, -1, 4);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
+TEST_F(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
+  EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
+  SpecializedSetup<Viewport, 0>();
+  Viewport cmd;
+  cmd.Init(1, 2, 3, -1);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
 // TODO(gman): SwapBuffers
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_