Remove shm versions of immediate commands from command buffer

The actual code uses only immediate commands. The shm versions are
either unused or used only by the unit tests.

Make the unit tests use the immediate commands.

Solves the problem of not having to implement one useless function for
the a new command when using immediate commands.

BUG=373763

Review URL: https://codereview.chromium.org/289993002

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

15 files changed, 423 insertions, 4685 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index d918b73..23a9b2b 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -2712,6 +2712,7 @@ class TypeHandler(object):
     if immediate == True or immediate == None:
       if func.num_pointer_args == 1 or immediate:
         generator.AddFunction(ImmediateFunction(func))
+        return True
 
   def AddBucketFunction(self, generator, func):
     """Adds a bucket version of a function."""
@@ -7312,8 +7313,8 @@ class GLGenerator(object):
 
         gen_cmd = f.GetInfo('gen_cmd')
         if gen_cmd == True or gen_cmd == None:
-          self.AddFunction(f)
-          f.type_handler.AddImmediateFunction(self, f)
+          if not f.type_handler.AddImmediateFunction(self, f):
+            self.AddFunction(f)
           f.type_handler.AddBucketFunction(self, f)
 
     self.Log("Auto Generated Functions    : %d" %
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index 360983a..4491f9b 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -318,15 +318,6 @@ void CullFace(GLenum mode) {
   }
 }
 
-void DeleteBuffers(GLsizei n,
-                   uint32_t buffers_shm_id,
-                   uint32_t buffers_shm_offset) {
-  gles2::cmds::DeleteBuffers* c = GetCmdSpace<gles2::cmds::DeleteBuffers>();
-  if (c) {
-    c->Init(n, buffers_shm_id, buffers_shm_offset);
-  }
-}
-
 void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) {
   const uint32_t size = gles2::cmds::DeleteBuffersImmediate::ComputeSize(n);
   gles2::cmds::DeleteBuffersImmediate* c =
@@ -336,16 +327,6 @@ void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) {
   }
 }
 
-void DeleteFramebuffers(GLsizei n,
-                        uint32_t framebuffers_shm_id,
-                        uint32_t framebuffers_shm_offset) {
-  gles2::cmds::DeleteFramebuffers* c =
-      GetCmdSpace<gles2::cmds::DeleteFramebuffers>();
-  if (c) {
-    c->Init(n, framebuffers_shm_id, framebuffers_shm_offset);
-  }
-}
-
 void DeleteFramebuffersImmediate(GLsizei n, const GLuint* framebuffers) {
   const uint32_t size =
       gles2::cmds::DeleteFramebuffersImmediate::ComputeSize(n);
@@ -364,16 +345,6 @@ void DeleteProgram(GLuint program) {
   }
 }
 
-void DeleteRenderbuffers(GLsizei n,
-                         uint32_t renderbuffers_shm_id,
-                         uint32_t renderbuffers_shm_offset) {
-  gles2::cmds::DeleteRenderbuffers* c =
-      GetCmdSpace<gles2::cmds::DeleteRenderbuffers>();
-  if (c) {
-    c->Init(n, renderbuffers_shm_id, renderbuffers_shm_offset);
-  }
-}
-
 void DeleteRenderbuffersImmediate(GLsizei n, const GLuint* renderbuffers) {
   const uint32_t size =
       gles2::cmds::DeleteRenderbuffersImmediate::ComputeSize(n);
@@ -392,15 +363,6 @@ void DeleteShader(GLuint shader) {
   }
 }
 
-void DeleteTextures(GLsizei n,
-                    uint32_t textures_shm_id,
-                    uint32_t textures_shm_offset) {
-  gles2::cmds::DeleteTextures* c = GetCmdSpace<gles2::cmds::DeleteTextures>();
-  if (c) {
-    c->Init(n, textures_shm_id, textures_shm_offset);
-  }
-}
-
 void DeleteTexturesImmediate(GLsizei n, const GLuint* textures) {
   const uint32_t size = gles2::cmds::DeleteTexturesImmediate::ComputeSize(n);
   gles2::cmds::DeleteTexturesImmediate* c =
@@ -528,15 +490,6 @@ void FrontFace(GLenum mode) {
   }
 }
 
-void GenBuffers(GLsizei n,
-                uint32_t buffers_shm_id,
-                uint32_t buffers_shm_offset) {
-  gles2::cmds::GenBuffers* c = GetCmdSpace<gles2::cmds::GenBuffers>();
-  if (c) {
-    c->Init(n, buffers_shm_id, buffers_shm_offset);
-  }
-}
-
 void GenBuffersImmediate(GLsizei n, GLuint* buffers) {
   const uint32_t size = gles2::cmds::GenBuffersImmediate::ComputeSize(n);
   gles2::cmds::GenBuffersImmediate* c =
@@ -553,15 +506,6 @@ void GenerateMipmap(GLenum target) {
   }
 }
 
-void GenFramebuffers(GLsizei n,
-                     uint32_t framebuffers_shm_id,
-                     uint32_t framebuffers_shm_offset) {
-  gles2::cmds::GenFramebuffers* c = GetCmdSpace<gles2::cmds::GenFramebuffers>();
-  if (c) {
-    c->Init(n, framebuffers_shm_id, framebuffers_shm_offset);
-  }
-}
-
 void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) {
   const uint32_t size = gles2::cmds::GenFramebuffersImmediate::ComputeSize(n);
   gles2::cmds::GenFramebuffersImmediate* c =
@@ -572,16 +516,6 @@ void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) {
   }
 }
 
-void GenRenderbuffers(GLsizei n,
-                      uint32_t renderbuffers_shm_id,
-                      uint32_t renderbuffers_shm_offset) {
-  gles2::cmds::GenRenderbuffers* c =
-      GetCmdSpace<gles2::cmds::GenRenderbuffers>();
-  if (c) {
-    c->Init(n, renderbuffers_shm_id, renderbuffers_shm_offset);
-  }
-}
-
 void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) {
   const uint32_t size = gles2::cmds::GenRenderbuffersImmediate::ComputeSize(n);
   gles2::cmds::GenRenderbuffersImmediate* c =
@@ -592,15 +526,6 @@ void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) {
   }
 }
 
-void GenTextures(GLsizei n,
-                 uint32_t textures_shm_id,
-                 uint32_t textures_shm_offset) {
-  gles2::cmds::GenTextures* c = GetCmdSpace<gles2::cmds::GenTextures>();
-  if (c) {
-    c->Init(n, textures_shm_id, textures_shm_offset);
-  }
-}
-
 void GenTexturesImmediate(GLsizei n, GLuint* textures) {
   const uint32_t size = gles2::cmds::GenTexturesImmediate::ComputeSize(n);
   gles2::cmds::GenTexturesImmediate* c =
@@ -1116,16 +1041,6 @@ void TexParameterf(GLenum target, GLenum pname, GLfloat param) {
   }
 }
 
-void TexParameterfv(GLenum target,
-                    GLenum pname,
-                    uint32_t params_shm_id,
-                    uint32_t params_shm_offset) {
-  gles2::cmds::TexParameterfv* c = GetCmdSpace<gles2::cmds::TexParameterfv>();
-  if (c) {
-    c->Init(target, pname, params_shm_id, params_shm_offset);
-  }
-}
-
 void TexParameterfvImmediate(GLenum target,
                              GLenum pname,
                              const GLfloat* params) {
@@ -1144,16 +1059,6 @@ void TexParameteri(GLenum target, GLenum pname, GLint param) {
   }
 }
 
-void TexParameteriv(GLenum target,
-                    GLenum pname,
-                    uint32_t params_shm_id,
-                    uint32_t params_shm_offset) {
-  gles2::cmds::TexParameteriv* c = GetCmdSpace<gles2::cmds::TexParameteriv>();
-  if (c) {
-    c->Init(target, pname, params_shm_id, params_shm_offset);
-  }
-}
-
 void TexParameterivImmediate(GLenum target, GLenum pname, const GLint* params) {
   const uint32_t size = gles2::cmds::TexParameterivImmediate::ComputeSize();
   gles2::cmds::TexParameterivImmediate* c =
@@ -1197,16 +1102,6 @@ void Uniform1f(GLint location, GLfloat x) {
   }
 }
 
-void Uniform1fv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform1fv* c = GetCmdSpace<gles2::cmds::Uniform1fv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform1fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
   const uint32_t size = gles2::cmds::Uniform1fvImmediate::ComputeSize(count);
   gles2::cmds::Uniform1fvImmediate* c =
@@ -1223,16 +1118,6 @@ void Uniform1i(GLint location, GLint x) {
   }
 }
 
-void Uniform1iv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform1iv* c = GetCmdSpace<gles2::cmds::Uniform1iv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform1ivImmediate(GLint location, GLsizei count, const GLint* v) {
   const uint32_t size = gles2::cmds::Uniform1ivImmediate::ComputeSize(count);
   gles2::cmds::Uniform1ivImmediate* c =
@@ -1249,16 +1134,6 @@ void Uniform2f(GLint location, GLfloat x, GLfloat y) {
   }
 }
 
-void Uniform2fv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform2fv* c = GetCmdSpace<gles2::cmds::Uniform2fv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform2fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
   const uint32_t size = gles2::cmds::Uniform2fvImmediate::ComputeSize(count);
   gles2::cmds::Uniform2fvImmediate* c =
@@ -1275,16 +1150,6 @@ void Uniform2i(GLint location, GLint x, GLint y) {
   }
 }
 
-void Uniform2iv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform2iv* c = GetCmdSpace<gles2::cmds::Uniform2iv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform2ivImmediate(GLint location, GLsizei count, const GLint* v) {
   const uint32_t size = gles2::cmds::Uniform2ivImmediate::ComputeSize(count);
   gles2::cmds::Uniform2ivImmediate* c =
@@ -1301,16 +1166,6 @@ void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
   }
 }
 
-void Uniform3fv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform3fv* c = GetCmdSpace<gles2::cmds::Uniform3fv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform3fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
   const uint32_t size = gles2::cmds::Uniform3fvImmediate::ComputeSize(count);
   gles2::cmds::Uniform3fvImmediate* c =
@@ -1327,16 +1182,6 @@ void Uniform3i(GLint location, GLint x, GLint y, GLint z) {
   }
 }
 
-void Uniform3iv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform3iv* c = GetCmdSpace<gles2::cmds::Uniform3iv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform3ivImmediate(GLint location, GLsizei count, const GLint* v) {
   const uint32_t size = gles2::cmds::Uniform3ivImmediate::ComputeSize(count);
   gles2::cmds::Uniform3ivImmediate* c =
@@ -1353,16 +1198,6 @@ void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   }
 }
 
-void Uniform4fv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform4fv* c = GetCmdSpace<gles2::cmds::Uniform4fv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform4fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
   const uint32_t size = gles2::cmds::Uniform4fvImmediate::ComputeSize(count);
   gles2::cmds::Uniform4fvImmediate* c =
@@ -1379,16 +1214,6 @@ void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
   }
 }
 
-void Uniform4iv(GLint location,
-                GLsizei count,
-                uint32_t v_shm_id,
-                uint32_t v_shm_offset) {
-  gles2::cmds::Uniform4iv* c = GetCmdSpace<gles2::cmds::Uniform4iv>();
-  if (c) {
-    c->Init(location, count, v_shm_id, v_shm_offset);
-  }
-}
-
 void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) {
   const uint32_t size = gles2::cmds::Uniform4ivImmediate::ComputeSize(count);
   gles2::cmds::Uniform4ivImmediate* c =
@@ -1398,17 +1223,6 @@ void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) {
   }
 }
 
-void UniformMatrix2fv(GLint location,
-                      GLsizei count,
-                      uint32_t value_shm_id,
-                      uint32_t value_shm_offset) {
-  gles2::cmds::UniformMatrix2fv* c =
-      GetCmdSpace<gles2::cmds::UniformMatrix2fv>();
-  if (c) {
-    c->Init(location, count, value_shm_id, value_shm_offset);
-  }
-}
-
 void UniformMatrix2fvImmediate(GLint location,
                                GLsizei count,
                                const GLfloat* value) {
@@ -1422,17 +1236,6 @@ void UniformMatrix2fvImmediate(GLint location,
   }
 }
 
-void UniformMatrix3fv(GLint location,
-                      GLsizei count,
-                      uint32_t value_shm_id,
-                      uint32_t value_shm_offset) {
-  gles2::cmds::UniformMatrix3fv* c =
-      GetCmdSpace<gles2::cmds::UniformMatrix3fv>();
-  if (c) {
-    c->Init(location, count, value_shm_id, value_shm_offset);
-  }
-}
-
 void UniformMatrix3fvImmediate(GLint location,
                                GLsizei count,
                                const GLfloat* value) {
@@ -1446,17 +1249,6 @@ void UniformMatrix3fvImmediate(GLint location,
   }
 }
 
-void UniformMatrix4fv(GLint location,
-                      GLsizei count,
-                      uint32_t value_shm_id,
-                      uint32_t value_shm_offset) {
-  gles2::cmds::UniformMatrix4fv* c =
-      GetCmdSpace<gles2::cmds::UniformMatrix4fv>();
-  if (c) {
-    c->Init(location, count, value_shm_id, value_shm_offset);
-  }
-}
-
 void UniformMatrix4fvImmediate(GLint location,
                                GLsizei count,
                                const GLfloat* value) {
@@ -1491,15 +1283,6 @@ void VertexAttrib1f(GLuint indx, GLfloat x) {
   }
 }
 
-void VertexAttrib1fv(GLuint indx,
-                     uint32_t values_shm_id,
-                     uint32_t values_shm_offset) {
-  gles2::cmds::VertexAttrib1fv* c = GetCmdSpace<gles2::cmds::VertexAttrib1fv>();
-  if (c) {
-    c->Init(indx, values_shm_id, values_shm_offset);
-  }
-}
-
 void VertexAttrib1fvImmediate(GLuint indx, const GLfloat* values) {
   const uint32_t size = gles2::cmds::VertexAttrib1fvImmediate::ComputeSize();
   gles2::cmds::VertexAttrib1fvImmediate* c =
@@ -1517,15 +1300,6 @@ void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
   }
 }
 
-void VertexAttrib2fv(GLuint indx,
-                     uint32_t values_shm_id,
-                     uint32_t values_shm_offset) {
-  gles2::cmds::VertexAttrib2fv* c = GetCmdSpace<gles2::cmds::VertexAttrib2fv>();
-  if (c) {
-    c->Init(indx, values_shm_id, values_shm_offset);
-  }
-}
-
 void VertexAttrib2fvImmediate(GLuint indx, const GLfloat* values) {
   const uint32_t size = gles2::cmds::VertexAttrib2fvImmediate::ComputeSize();
   gles2::cmds::VertexAttrib2fvImmediate* c =
@@ -1543,15 +1317,6 @@ void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
   }
 }
 
-void VertexAttrib3fv(GLuint indx,
-                     uint32_t values_shm_id,
-                     uint32_t values_shm_offset) {
-  gles2::cmds::VertexAttrib3fv* c = GetCmdSpace<gles2::cmds::VertexAttrib3fv>();
-  if (c) {
-    c->Init(indx, values_shm_id, values_shm_offset);
-  }
-}
-
 void VertexAttrib3fvImmediate(GLuint indx, const GLfloat* values) {
   const uint32_t size = gles2::cmds::VertexAttrib3fvImmediate::ComputeSize();
   gles2::cmds::VertexAttrib3fvImmediate* c =
@@ -1569,15 +1334,6 @@ void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   }
 }
 
-void VertexAttrib4fv(GLuint indx,
-                     uint32_t values_shm_id,
-                     uint32_t values_shm_offset) {
-  gles2::cmds::VertexAttrib4fv* c = GetCmdSpace<gles2::cmds::VertexAttrib4fv>();
-  if (c) {
-    c->Init(indx, values_shm_id, values_shm_offset);
-  }
-}
-
 void VertexAttrib4fvImmediate(GLuint indx, const GLfloat* values) {
   const uint32_t size = gles2::cmds::VertexAttrib4fvImmediate::ComputeSize();
   gles2::cmds::VertexAttrib4fvImmediate* c =
@@ -1673,15 +1429,6 @@ void TexStorage2DEXT(GLenum target,
   }
 }
 
-void GenQueriesEXT(GLsizei n,
-                   uint32_t queries_shm_id,
-                   uint32_t queries_shm_offset) {
-  gles2::cmds::GenQueriesEXT* c = GetCmdSpace<gles2::cmds::GenQueriesEXT>();
-  if (c) {
-    c->Init(n, queries_shm_id, queries_shm_offset);
-  }
-}
-
 void GenQueriesEXTImmediate(GLsizei n, GLuint* queries) {
   const uint32_t size = gles2::cmds::GenQueriesEXTImmediate::ComputeSize(n);
   gles2::cmds::GenQueriesEXTImmediate* c =
@@ -1691,16 +1438,6 @@ void GenQueriesEXTImmediate(GLsizei n, GLuint* queries) {
   }
 }
 
-void DeleteQueriesEXT(GLsizei n,
-                      uint32_t queries_shm_id,
-                      uint32_t queries_shm_offset) {
-  gles2::cmds::DeleteQueriesEXT* c =
-      GetCmdSpace<gles2::cmds::DeleteQueriesEXT>();
-  if (c) {
-    c->Init(n, queries_shm_id, queries_shm_offset);
-  }
-}
-
 void DeleteQueriesEXTImmediate(GLsizei n, const GLuint* queries) {
   const uint32_t size = gles2::cmds::DeleteQueriesEXTImmediate::ComputeSize(n);
   gles2::cmds::DeleteQueriesEXTImmediate* c =
@@ -1752,16 +1489,6 @@ void PopGroupMarkerEXT() {
   }
 }
 
-void GenVertexArraysOES(GLsizei n,
-                        uint32_t arrays_shm_id,
-                        uint32_t arrays_shm_offset) {
-  gles2::cmds::GenVertexArraysOES* c =
-      GetCmdSpace<gles2::cmds::GenVertexArraysOES>();
-  if (c) {
-    c->Init(n, arrays_shm_id, arrays_shm_offset);
-  }
-}
-
 void GenVertexArraysOESImmediate(GLsizei n, GLuint* arrays) {
   const uint32_t size =
       gles2::cmds::GenVertexArraysOESImmediate::ComputeSize(n);
@@ -1773,16 +1500,6 @@ void GenVertexArraysOESImmediate(GLsizei n, GLuint* arrays) {
   }
 }
 
-void DeleteVertexArraysOES(GLsizei n,
-                           uint32_t arrays_shm_id,
-                           uint32_t arrays_shm_offset) {
-  gles2::cmds::DeleteVertexArraysOES* c =
-      GetCmdSpace<gles2::cmds::DeleteVertexArraysOES>();
-  if (c) {
-    c->Init(n, arrays_shm_id, arrays_shm_offset);
-  }
-}
-
 void DeleteVertexArraysOESImmediate(GLsizei n, const GLuint* arrays) {
   const uint32_t size =
       gles2::cmds::DeleteVertexArraysOESImmediate::ComputeSize(n);
@@ -1997,16 +1714,6 @@ void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
   }
 }
 
-void ProduceTextureCHROMIUM(GLenum target,
-                            uint32_t mailbox_shm_id,
-                            uint32_t mailbox_shm_offset) {
-  gles2::cmds::ProduceTextureCHROMIUM* c =
-      GetCmdSpace<gles2::cmds::ProduceTextureCHROMIUM>();
-  if (c) {
-    c->Init(target, mailbox_shm_id, mailbox_shm_offset);
-  }
-}
-
 void ProduceTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
   const uint32_t size =
       gles2::cmds::ProduceTextureCHROMIUMImmediate::ComputeSize();
@@ -2018,16 +1725,6 @@ void ProduceTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
   }
 }
 
-void ConsumeTextureCHROMIUM(GLenum target,
-                            uint32_t mailbox_shm_id,
-                            uint32_t mailbox_shm_offset) {
-  gles2::cmds::ConsumeTextureCHROMIUM* c =
-      GetCmdSpace<gles2::cmds::ConsumeTextureCHROMIUM>();
-  if (c) {
-    c->Init(target, mailbox_shm_id, mailbox_shm_offset);
-  }
-}
-
 void ConsumeTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
   const uint32_t size =
       gles2::cmds::ConsumeTextureCHROMIUMImmediate::ComputeSize();
@@ -2171,17 +1868,6 @@ void WaitAllAsyncTexImage2DCHROMIUM() {
   }
 }
 
-void DiscardFramebufferEXT(GLenum target,
-                           GLsizei count,
-                           uint32_t attachments_shm_id,
-                           uint32_t attachments_shm_offset) {
-  gles2::cmds::DiscardFramebufferEXT* c =
-      GetCmdSpace<gles2::cmds::DiscardFramebufferEXT>();
-  if (c) {
-    c->Init(target, count, attachments_shm_id, attachments_shm_offset);
-  }
-}
-
 void DiscardFramebufferEXTImmediate(GLenum target,
                                     GLsizei count,
                                     const GLenum* attachments) {
@@ -2211,15 +1897,6 @@ void WaitSyncPointCHROMIUM(GLuint sync_point) {
   }
 }
 
-void DrawBuffersEXT(GLsizei count,
-                    uint32_t bufs_shm_id,
-                    uint32_t bufs_shm_offset) {
-  gles2::cmds::DrawBuffersEXT* c = GetCmdSpace<gles2::cmds::DrawBuffersEXT>();
-  if (c) {
-    c->Init(count, bufs_shm_id, bufs_shm_offset);
-  }
-}
-
 void DrawBuffersEXTImmediate(GLsizei count, const GLenum* bufs) {
   const uint32_t size =
       gles2::cmds::DrawBuffersEXTImmediate::ComputeSize(count);
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index be63e8f..c3b62dc 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -1491,51 +1491,6 @@ COMPILE_ASSERT(sizeof(CullFace) == 8, Sizeof_CullFace_is_not_8);
 COMPILE_ASSERT(offsetof(CullFace, header) == 0, OffsetOf_CullFace_header_not_0);
 COMPILE_ASSERT(offsetof(CullFace, mode) == 4, OffsetOf_CullFace_mode_not_4);
 
-struct DeleteBuffers {
-  typedef DeleteBuffers ValueType;
-  static const CommandId kCmdId = kDeleteBuffers;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _buffers_shm_id,
-            uint32_t _buffers_shm_offset) {
-    SetHeader();
-    n = _n;
-    buffers_shm_id = _buffers_shm_id;
-    buffers_shm_offset = _buffers_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _buffers_shm_id,
-            uint32_t _buffers_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _buffers_shm_id, _buffers_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t buffers_shm_id;
-  uint32_t buffers_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DeleteBuffers) == 16, Sizeof_DeleteBuffers_is_not_16);
-COMPILE_ASSERT(offsetof(DeleteBuffers, header) == 0,
-               OffsetOf_DeleteBuffers_header_not_0);
-COMPILE_ASSERT(offsetof(DeleteBuffers, n) == 4, OffsetOf_DeleteBuffers_n_not_4);
-COMPILE_ASSERT(offsetof(DeleteBuffers, buffers_shm_id) == 8,
-               OffsetOf_DeleteBuffers_buffers_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DeleteBuffers, buffers_shm_offset) == 12,
-               OffsetOf_DeleteBuffers_buffers_shm_offset_not_12);
-
 struct DeleteBuffersImmediate {
   typedef DeleteBuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteBuffersImmediate;
@@ -1578,53 +1533,6 @@ COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4,
                OffsetOf_DeleteBuffersImmediate_n_not_4);
 
-struct DeleteFramebuffers {
-  typedef DeleteFramebuffers ValueType;
-  static const CommandId kCmdId = kDeleteFramebuffers;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _framebuffers_shm_id,
-            uint32_t _framebuffers_shm_offset) {
-    SetHeader();
-    n = _n;
-    framebuffers_shm_id = _framebuffers_shm_id;
-    framebuffers_shm_offset = _framebuffers_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _framebuffers_shm_id,
-            uint32_t _framebuffers_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t framebuffers_shm_id;
-  uint32_t framebuffers_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DeleteFramebuffers) == 16,
-               Sizeof_DeleteFramebuffers_is_not_16);
-COMPILE_ASSERT(offsetof(DeleteFramebuffers, header) == 0,
-               OffsetOf_DeleteFramebuffers_header_not_0);
-COMPILE_ASSERT(offsetof(DeleteFramebuffers, n) == 4,
-               OffsetOf_DeleteFramebuffers_n_not_4);
-COMPILE_ASSERT(offsetof(DeleteFramebuffers, framebuffers_shm_id) == 8,
-               OffsetOf_DeleteFramebuffers_framebuffers_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DeleteFramebuffers, framebuffers_shm_offset) == 12,
-               OffsetOf_DeleteFramebuffers_framebuffers_shm_offset_not_12);
-
 struct DeleteFramebuffersImmediate {
   typedef DeleteFramebuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteFramebuffersImmediate;
@@ -1699,53 +1607,6 @@ COMPILE_ASSERT(offsetof(DeleteProgram, header) == 0,
 COMPILE_ASSERT(offsetof(DeleteProgram, program) == 4,
                OffsetOf_DeleteProgram_program_not_4);
 
-struct DeleteRenderbuffers {
-  typedef DeleteRenderbuffers ValueType;
-  static const CommandId kCmdId = kDeleteRenderbuffers;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _renderbuffers_shm_id,
-            uint32_t _renderbuffers_shm_offset) {
-    SetHeader();
-    n = _n;
-    renderbuffers_shm_id = _renderbuffers_shm_id;
-    renderbuffers_shm_offset = _renderbuffers_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _renderbuffers_shm_id,
-            uint32_t _renderbuffers_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t renderbuffers_shm_id;
-  uint32_t renderbuffers_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DeleteRenderbuffers) == 16,
-               Sizeof_DeleteRenderbuffers_is_not_16);
-COMPILE_ASSERT(offsetof(DeleteRenderbuffers, header) == 0,
-               OffsetOf_DeleteRenderbuffers_header_not_0);
-COMPILE_ASSERT(offsetof(DeleteRenderbuffers, n) == 4,
-               OffsetOf_DeleteRenderbuffers_n_not_4);
-COMPILE_ASSERT(offsetof(DeleteRenderbuffers, renderbuffers_shm_id) == 8,
-               OffsetOf_DeleteRenderbuffers_renderbuffers_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DeleteRenderbuffers, renderbuffers_shm_offset) == 12,
-               OffsetOf_DeleteRenderbuffers_renderbuffers_shm_offset_not_12);
-
 struct DeleteRenderbuffersImmediate {
   typedef DeleteRenderbuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteRenderbuffersImmediate;
@@ -1820,52 +1681,6 @@ COMPILE_ASSERT(offsetof(DeleteShader, header) == 0,
 COMPILE_ASSERT(offsetof(DeleteShader, shader) == 4,
                OffsetOf_DeleteShader_shader_not_4);
 
-struct DeleteTextures {
-  typedef DeleteTextures ValueType;
-  static const CommandId kCmdId = kDeleteTextures;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _textures_shm_id,
-            uint32_t _textures_shm_offset) {
-    SetHeader();
-    n = _n;
-    textures_shm_id = _textures_shm_id;
-    textures_shm_offset = _textures_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _textures_shm_id,
-            uint32_t _textures_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _textures_shm_id, _textures_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t textures_shm_id;
-  uint32_t textures_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DeleteTextures) == 16, Sizeof_DeleteTextures_is_not_16);
-COMPILE_ASSERT(offsetof(DeleteTextures, header) == 0,
-               OffsetOf_DeleteTextures_header_not_0);
-COMPILE_ASSERT(offsetof(DeleteTextures, n) == 4,
-               OffsetOf_DeleteTextures_n_not_4);
-COMPILE_ASSERT(offsetof(DeleteTextures, textures_shm_id) == 8,
-               OffsetOf_DeleteTextures_textures_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DeleteTextures, textures_shm_offset) == 12,
-               OffsetOf_DeleteTextures_textures_shm_offset_not_12);
-
 struct DeleteTexturesImmediate {
   typedef DeleteTexturesImmediate ValueType;
   static const CommandId kCmdId = kDeleteTexturesImmediate;
@@ -2443,51 +2258,6 @@ COMPILE_ASSERT(offsetof(FrontFace, header) == 0,
                OffsetOf_FrontFace_header_not_0);
 COMPILE_ASSERT(offsetof(FrontFace, mode) == 4, OffsetOf_FrontFace_mode_not_4);
 
-struct GenBuffers {
-  typedef GenBuffers ValueType;
-  static const CommandId kCmdId = kGenBuffers;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _buffers_shm_id,
-            uint32_t _buffers_shm_offset) {
-    SetHeader();
-    n = _n;
-    buffers_shm_id = _buffers_shm_id;
-    buffers_shm_offset = _buffers_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _buffers_shm_id,
-            uint32_t _buffers_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _buffers_shm_id, _buffers_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t buffers_shm_id;
-  uint32_t buffers_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(GenBuffers) == 16, Sizeof_GenBuffers_is_not_16);
-COMPILE_ASSERT(offsetof(GenBuffers, header) == 0,
-               OffsetOf_GenBuffers_header_not_0);
-COMPILE_ASSERT(offsetof(GenBuffers, n) == 4, OffsetOf_GenBuffers_n_not_4);
-COMPILE_ASSERT(offsetof(GenBuffers, buffers_shm_id) == 8,
-               OffsetOf_GenBuffers_buffers_shm_id_not_8);
-COMPILE_ASSERT(offsetof(GenBuffers, buffers_shm_offset) == 12,
-               OffsetOf_GenBuffers_buffers_shm_offset_not_12);
-
 struct GenBuffersImmediate {
   typedef GenBuffersImmediate ValueType;
   static const CommandId kCmdId = kGenBuffersImmediate;
@@ -2562,52 +2332,6 @@ COMPILE_ASSERT(offsetof(GenerateMipmap, header) == 0,
 COMPILE_ASSERT(offsetof(GenerateMipmap, target) == 4,
                OffsetOf_GenerateMipmap_target_not_4);
 
-struct GenFramebuffers {
-  typedef GenFramebuffers ValueType;
-  static const CommandId kCmdId = kGenFramebuffers;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _framebuffers_shm_id,
-            uint32_t _framebuffers_shm_offset) {
-    SetHeader();
-    n = _n;
-    framebuffers_shm_id = _framebuffers_shm_id;
-    framebuffers_shm_offset = _framebuffers_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _framebuffers_shm_id,
-            uint32_t _framebuffers_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t framebuffers_shm_id;
-  uint32_t framebuffers_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(GenFramebuffers) == 16, Sizeof_GenFramebuffers_is_not_16);
-COMPILE_ASSERT(offsetof(GenFramebuffers, header) == 0,
-               OffsetOf_GenFramebuffers_header_not_0);
-COMPILE_ASSERT(offsetof(GenFramebuffers, n) == 4,
-               OffsetOf_GenFramebuffers_n_not_4);
-COMPILE_ASSERT(offsetof(GenFramebuffers, framebuffers_shm_id) == 8,
-               OffsetOf_GenFramebuffers_framebuffers_shm_id_not_8);
-COMPILE_ASSERT(offsetof(GenFramebuffers, framebuffers_shm_offset) == 12,
-               OffsetOf_GenFramebuffers_framebuffers_shm_offset_not_12);
-
 struct GenFramebuffersImmediate {
   typedef GenFramebuffersImmediate ValueType;
   static const CommandId kCmdId = kGenFramebuffersImmediate;
@@ -2650,53 +2374,6 @@ COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4,
                OffsetOf_GenFramebuffersImmediate_n_not_4);
 
-struct GenRenderbuffers {
-  typedef GenRenderbuffers ValueType;
-  static const CommandId kCmdId = kGenRenderbuffers;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _renderbuffers_shm_id,
-            uint32_t _renderbuffers_shm_offset) {
-    SetHeader();
-    n = _n;
-    renderbuffers_shm_id = _renderbuffers_shm_id;
-    renderbuffers_shm_offset = _renderbuffers_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _renderbuffers_shm_id,
-            uint32_t _renderbuffers_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t renderbuffers_shm_id;
-  uint32_t renderbuffers_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(GenRenderbuffers) == 16,
-               Sizeof_GenRenderbuffers_is_not_16);
-COMPILE_ASSERT(offsetof(GenRenderbuffers, header) == 0,
-               OffsetOf_GenRenderbuffers_header_not_0);
-COMPILE_ASSERT(offsetof(GenRenderbuffers, n) == 4,
-               OffsetOf_GenRenderbuffers_n_not_4);
-COMPILE_ASSERT(offsetof(GenRenderbuffers, renderbuffers_shm_id) == 8,
-               OffsetOf_GenRenderbuffers_renderbuffers_shm_id_not_8);
-COMPILE_ASSERT(offsetof(GenRenderbuffers, renderbuffers_shm_offset) == 12,
-               OffsetOf_GenRenderbuffers_renderbuffers_shm_offset_not_12);
-
 struct GenRenderbuffersImmediate {
   typedef GenRenderbuffersImmediate ValueType;
   static const CommandId kCmdId = kGenRenderbuffersImmediate;
@@ -2739,51 +2416,6 @@ COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4,
                OffsetOf_GenRenderbuffersImmediate_n_not_4);
 
-struct GenTextures {
-  typedef GenTextures ValueType;
-  static const CommandId kCmdId = kGenTextures;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _textures_shm_id,
-            uint32_t _textures_shm_offset) {
-    SetHeader();
-    n = _n;
-    textures_shm_id = _textures_shm_id;
-    textures_shm_offset = _textures_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _textures_shm_id,
-            uint32_t _textures_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _textures_shm_id, _textures_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t textures_shm_id;
-  uint32_t textures_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(GenTextures) == 16, Sizeof_GenTextures_is_not_16);
-COMPILE_ASSERT(offsetof(GenTextures, header) == 0,
-               OffsetOf_GenTextures_header_not_0);
-COMPILE_ASSERT(offsetof(GenTextures, n) == 4, OffsetOf_GenTextures_n_not_4);
-COMPILE_ASSERT(offsetof(GenTextures, textures_shm_id) == 8,
-               OffsetOf_GenTextures_textures_shm_id_not_8);
-COMPILE_ASSERT(offsetof(GenTextures, textures_shm_offset) == 12,
-               OffsetOf_GenTextures_textures_shm_offset_not_12);
-
 struct GenTexturesImmediate {
   typedef GenTexturesImmediate ValueType;
   static const CommandId kCmdId = kGenTexturesImmediate;
@@ -5370,58 +5002,6 @@ COMPILE_ASSERT(offsetof(TexParameterf, pname) == 8,
 COMPILE_ASSERT(offsetof(TexParameterf, param) == 12,
                OffsetOf_TexParameterf_param_not_12);
 
-struct TexParameterfv {
-  typedef TexParameterfv ValueType;
-  static const CommandId kCmdId = kTexParameterfv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            GLenum _pname,
-            uint32_t _params_shm_id,
-            uint32_t _params_shm_offset) {
-    SetHeader();
-    target = _target;
-    pname = _pname;
-    params_shm_id = _params_shm_id;
-    params_shm_offset = _params_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            GLenum _pname,
-            uint32_t _params_shm_id,
-            uint32_t _params_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  uint32_t pname;
-  uint32_t params_shm_id;
-  uint32_t params_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(TexParameterfv) == 20, Sizeof_TexParameterfv_is_not_20);
-COMPILE_ASSERT(offsetof(TexParameterfv, header) == 0,
-               OffsetOf_TexParameterfv_header_not_0);
-COMPILE_ASSERT(offsetof(TexParameterfv, target) == 4,
-               OffsetOf_TexParameterfv_target_not_4);
-COMPILE_ASSERT(offsetof(TexParameterfv, pname) == 8,
-               OffsetOf_TexParameterfv_pname_not_8);
-COMPILE_ASSERT(offsetof(TexParameterfv, params_shm_id) == 12,
-               OffsetOf_TexParameterfv_params_shm_id_not_12);
-COMPILE_ASSERT(offsetof(TexParameterfv, params_shm_offset) == 16,
-               OffsetOf_TexParameterfv_params_shm_offset_not_16);
-
 struct TexParameterfvImmediate {
   typedef TexParameterfvImmediate ValueType;
   static const CommandId kCmdId = kTexParameterfvImmediate;
@@ -5506,58 +5086,6 @@ COMPILE_ASSERT(offsetof(TexParameteri, pname) == 8,
 COMPILE_ASSERT(offsetof(TexParameteri, param) == 12,
                OffsetOf_TexParameteri_param_not_12);
 
-struct TexParameteriv {
-  typedef TexParameteriv ValueType;
-  static const CommandId kCmdId = kTexParameteriv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            GLenum _pname,
-            uint32_t _params_shm_id,
-            uint32_t _params_shm_offset) {
-    SetHeader();
-    target = _target;
-    pname = _pname;
-    params_shm_id = _params_shm_id;
-    params_shm_offset = _params_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            GLenum _pname,
-            uint32_t _params_shm_id,
-            uint32_t _params_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  uint32_t pname;
-  uint32_t params_shm_id;
-  uint32_t params_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(TexParameteriv) == 20, Sizeof_TexParameteriv_is_not_20);
-COMPILE_ASSERT(offsetof(TexParameteriv, header) == 0,
-               OffsetOf_TexParameteriv_header_not_0);
-COMPILE_ASSERT(offsetof(TexParameteriv, target) == 4,
-               OffsetOf_TexParameteriv_target_not_4);
-COMPILE_ASSERT(offsetof(TexParameteriv, pname) == 8,
-               OffsetOf_TexParameteriv_pname_not_8);
-COMPILE_ASSERT(offsetof(TexParameteriv, params_shm_id) == 12,
-               OffsetOf_TexParameteriv_params_shm_id_not_12);
-COMPILE_ASSERT(offsetof(TexParameteriv, params_shm_offset) == 16,
-               OffsetOf_TexParameteriv_params_shm_offset_not_16);
-
 struct TexParameterivImmediate {
   typedef TexParameterivImmediate ValueType;
   static const CommandId kCmdId = kTexParameterivImmediate;
@@ -5740,58 +5268,6 @@ COMPILE_ASSERT(offsetof(Uniform1f, location) == 4,
                OffsetOf_Uniform1f_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform1f, x) == 8, OffsetOf_Uniform1f_x_not_8);
 
-struct Uniform1fv {
-  typedef Uniform1fv ValueType;
-  static const CommandId kCmdId = kUniform1fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform1fv) == 20, Sizeof_Uniform1fv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform1fv, header) == 0,
-               OffsetOf_Uniform1fv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform1fv, location) == 4,
-               OffsetOf_Uniform1fv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform1fv, count) == 8,
-               OffsetOf_Uniform1fv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform1fv, v_shm_id) == 12,
-               OffsetOf_Uniform1fv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform1fv, v_shm_offset) == 16,
-               OffsetOf_Uniform1fv_v_shm_offset_not_16);
-
 struct Uniform1fvImmediate {
   typedef Uniform1fvImmediate ValueType;
   static const CommandId kCmdId = kUniform1fvImmediate;
@@ -5873,58 +5349,6 @@ COMPILE_ASSERT(offsetof(Uniform1i, location) == 4,
                OffsetOf_Uniform1i_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform1i, x) == 8, OffsetOf_Uniform1i_x_not_8);
 
-struct Uniform1iv {
-  typedef Uniform1iv ValueType;
-  static const CommandId kCmdId = kUniform1iv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform1iv) == 20, Sizeof_Uniform1iv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform1iv, header) == 0,
-               OffsetOf_Uniform1iv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform1iv, location) == 4,
-               OffsetOf_Uniform1iv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform1iv, count) == 8,
-               OffsetOf_Uniform1iv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform1iv, v_shm_id) == 12,
-               OffsetOf_Uniform1iv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform1iv, v_shm_offset) == 16,
-               OffsetOf_Uniform1iv_v_shm_offset_not_16);
-
 struct Uniform1ivImmediate {
   typedef Uniform1ivImmediate ValueType;
   static const CommandId kCmdId = kUniform1ivImmediate;
@@ -6009,58 +5433,6 @@ COMPILE_ASSERT(offsetof(Uniform2f, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform2f, x) == 8, OffsetOf_Uniform2f_x_not_8);
 COMPILE_ASSERT(offsetof(Uniform2f, y) == 12, OffsetOf_Uniform2f_y_not_12);
 
-struct Uniform2fv {
-  typedef Uniform2fv ValueType;
-  static const CommandId kCmdId = kUniform2fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform2fv) == 20, Sizeof_Uniform2fv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform2fv, header) == 0,
-               OffsetOf_Uniform2fv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform2fv, location) == 4,
-               OffsetOf_Uniform2fv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform2fv, count) == 8,
-               OffsetOf_Uniform2fv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform2fv, v_shm_id) == 12,
-               OffsetOf_Uniform2fv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform2fv, v_shm_offset) == 16,
-               OffsetOf_Uniform2fv_v_shm_offset_not_16);
-
 struct Uniform2fvImmediate {
   typedef Uniform2fvImmediate ValueType;
   static const CommandId kCmdId = kUniform2fvImmediate;
@@ -6145,58 +5517,6 @@ COMPILE_ASSERT(offsetof(Uniform2i, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform2i, x) == 8, OffsetOf_Uniform2i_x_not_8);
 COMPILE_ASSERT(offsetof(Uniform2i, y) == 12, OffsetOf_Uniform2i_y_not_12);
 
-struct Uniform2iv {
-  typedef Uniform2iv ValueType;
-  static const CommandId kCmdId = kUniform2iv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform2iv) == 20, Sizeof_Uniform2iv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform2iv, header) == 0,
-               OffsetOf_Uniform2iv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform2iv, location) == 4,
-               OffsetOf_Uniform2iv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform2iv, count) == 8,
-               OffsetOf_Uniform2iv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform2iv, v_shm_id) == 12,
-               OffsetOf_Uniform2iv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform2iv, v_shm_offset) == 16,
-               OffsetOf_Uniform2iv_v_shm_offset_not_16);
-
 struct Uniform2ivImmediate {
   typedef Uniform2ivImmediate ValueType;
   static const CommandId kCmdId = kUniform2ivImmediate;
@@ -6284,58 +5604,6 @@ COMPILE_ASSERT(offsetof(Uniform3f, x) == 8, OffsetOf_Uniform3f_x_not_8);
 COMPILE_ASSERT(offsetof(Uniform3f, y) == 12, OffsetOf_Uniform3f_y_not_12);
 COMPILE_ASSERT(offsetof(Uniform3f, z) == 16, OffsetOf_Uniform3f_z_not_16);
 
-struct Uniform3fv {
-  typedef Uniform3fv ValueType;
-  static const CommandId kCmdId = kUniform3fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform3fv) == 20, Sizeof_Uniform3fv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform3fv, header) == 0,
-               OffsetOf_Uniform3fv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform3fv, location) == 4,
-               OffsetOf_Uniform3fv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform3fv, count) == 8,
-               OffsetOf_Uniform3fv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform3fv, v_shm_id) == 12,
-               OffsetOf_Uniform3fv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform3fv, v_shm_offset) == 16,
-               OffsetOf_Uniform3fv_v_shm_offset_not_16);
-
 struct Uniform3fvImmediate {
   typedef Uniform3fvImmediate ValueType;
   static const CommandId kCmdId = kUniform3fvImmediate;
@@ -6423,58 +5691,6 @@ COMPILE_ASSERT(offsetof(Uniform3i, x) == 8, OffsetOf_Uniform3i_x_not_8);
 COMPILE_ASSERT(offsetof(Uniform3i, y) == 12, OffsetOf_Uniform3i_y_not_12);
 COMPILE_ASSERT(offsetof(Uniform3i, z) == 16, OffsetOf_Uniform3i_z_not_16);
 
-struct Uniform3iv {
-  typedef Uniform3iv ValueType;
-  static const CommandId kCmdId = kUniform3iv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform3iv) == 20, Sizeof_Uniform3iv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform3iv, header) == 0,
-               OffsetOf_Uniform3iv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform3iv, location) == 4,
-               OffsetOf_Uniform3iv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform3iv, count) == 8,
-               OffsetOf_Uniform3iv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform3iv, v_shm_id) == 12,
-               OffsetOf_Uniform3iv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform3iv, v_shm_offset) == 16,
-               OffsetOf_Uniform3iv_v_shm_offset_not_16);
-
 struct Uniform3ivImmediate {
   typedef Uniform3ivImmediate ValueType;
   static const CommandId kCmdId = kUniform3ivImmediate;
@@ -6570,58 +5786,6 @@ COMPILE_ASSERT(offsetof(Uniform4f, y) == 12, OffsetOf_Uniform4f_y_not_12);
 COMPILE_ASSERT(offsetof(Uniform4f, z) == 16, OffsetOf_Uniform4f_z_not_16);
 COMPILE_ASSERT(offsetof(Uniform4f, w) == 20, OffsetOf_Uniform4f_w_not_20);
 
-struct Uniform4fv {
-  typedef Uniform4fv ValueType;
-  static const CommandId kCmdId = kUniform4fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform4fv) == 20, Sizeof_Uniform4fv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform4fv, header) == 0,
-               OffsetOf_Uniform4fv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform4fv, location) == 4,
-               OffsetOf_Uniform4fv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform4fv, count) == 8,
-               OffsetOf_Uniform4fv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform4fv, v_shm_id) == 12,
-               OffsetOf_Uniform4fv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform4fv, v_shm_offset) == 16,
-               OffsetOf_Uniform4fv_v_shm_offset_not_16);
-
 struct Uniform4fvImmediate {
   typedef Uniform4fvImmediate ValueType;
   static const CommandId kCmdId = kUniform4fvImmediate;
@@ -6717,58 +5881,6 @@ COMPILE_ASSERT(offsetof(Uniform4i, y) == 12, OffsetOf_Uniform4i_y_not_12);
 COMPILE_ASSERT(offsetof(Uniform4i, z) == 16, OffsetOf_Uniform4i_z_not_16);
 COMPILE_ASSERT(offsetof(Uniform4i, w) == 20, OffsetOf_Uniform4i_w_not_20);
 
-struct Uniform4iv {
-  typedef Uniform4iv ValueType;
-  static const CommandId kCmdId = kUniform4iv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    v_shm_id = _v_shm_id;
-    v_shm_offset = _v_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _v_shm_id,
-            uint32_t _v_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _v_shm_id, _v_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t v_shm_id;
-  uint32_t v_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(Uniform4iv) == 20, Sizeof_Uniform4iv_is_not_20);
-COMPILE_ASSERT(offsetof(Uniform4iv, header) == 0,
-               OffsetOf_Uniform4iv_header_not_0);
-COMPILE_ASSERT(offsetof(Uniform4iv, location) == 4,
-               OffsetOf_Uniform4iv_location_not_4);
-COMPILE_ASSERT(offsetof(Uniform4iv, count) == 8,
-               OffsetOf_Uniform4iv_count_not_8);
-COMPILE_ASSERT(offsetof(Uniform4iv, v_shm_id) == 12,
-               OffsetOf_Uniform4iv_v_shm_id_not_12);
-COMPILE_ASSERT(offsetof(Uniform4iv, v_shm_offset) == 16,
-               OffsetOf_Uniform4iv_v_shm_offset_not_16);
-
 struct Uniform4ivImmediate {
   typedef Uniform4ivImmediate ValueType;
   static const CommandId kCmdId = kUniform4ivImmediate;
@@ -6815,60 +5927,6 @@ COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8,
                OffsetOf_Uniform4ivImmediate_count_not_8);
 
-struct UniformMatrix2fv {
-  typedef UniformMatrix2fv ValueType;
-  static const CommandId kCmdId = kUniformMatrix2fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _value_shm_id,
-            uint32_t _value_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    value_shm_id = _value_shm_id;
-    value_shm_offset = _value_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _value_shm_id,
-            uint32_t _value_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _value_shm_id, _value_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t value_shm_id;
-  uint32_t value_shm_offset;
-  static const uint32_t transpose = false;
-};
-
-COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 20,
-               Sizeof_UniformMatrix2fv_is_not_20);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, header) == 0,
-               OffsetOf_UniformMatrix2fv_header_not_0);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, location) == 4,
-               OffsetOf_UniformMatrix2fv_location_not_4);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, count) == 8,
-               OffsetOf_UniformMatrix2fv_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_id) == 12,
-               OffsetOf_UniformMatrix2fv_value_shm_id_not_12);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_offset) == 16,
-               OffsetOf_UniformMatrix2fv_value_shm_offset_not_16);
-
 struct UniformMatrix2fvImmediate {
   typedef UniformMatrix2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2fvImmediate;
@@ -6916,60 +5974,6 @@ COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8,
                OffsetOf_UniformMatrix2fvImmediate_count_not_8);
 
-struct UniformMatrix3fv {
-  typedef UniformMatrix3fv ValueType;
-  static const CommandId kCmdId = kUniformMatrix3fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _value_shm_id,
-            uint32_t _value_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    value_shm_id = _value_shm_id;
-    value_shm_offset = _value_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _value_shm_id,
-            uint32_t _value_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _value_shm_id, _value_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t value_shm_id;
-  uint32_t value_shm_offset;
-  static const uint32_t transpose = false;
-};
-
-COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 20,
-               Sizeof_UniformMatrix3fv_is_not_20);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, header) == 0,
-               OffsetOf_UniformMatrix3fv_header_not_0);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, location) == 4,
-               OffsetOf_UniformMatrix3fv_location_not_4);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, count) == 8,
-               OffsetOf_UniformMatrix3fv_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_id) == 12,
-               OffsetOf_UniformMatrix3fv_value_shm_id_not_12);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_offset) == 16,
-               OffsetOf_UniformMatrix3fv_value_shm_offset_not_16);
-
 struct UniformMatrix3fvImmediate {
   typedef UniformMatrix3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3fvImmediate;
@@ -7017,60 +6021,6 @@ COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8,
                OffsetOf_UniformMatrix3fvImmediate_count_not_8);
 
-struct UniformMatrix4fv {
-  typedef UniformMatrix4fv ValueType;
-  static const CommandId kCmdId = kUniformMatrix4fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLint _location,
-            GLsizei _count,
-            uint32_t _value_shm_id,
-            uint32_t _value_shm_offset) {
-    SetHeader();
-    location = _location;
-    count = _count;
-    value_shm_id = _value_shm_id;
-    value_shm_offset = _value_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            uint32_t _value_shm_id,
-            uint32_t _value_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _value_shm_id, _value_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t location;
-  int32_t count;
-  uint32_t value_shm_id;
-  uint32_t value_shm_offset;
-  static const uint32_t transpose = false;
-};
-
-COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 20,
-               Sizeof_UniformMatrix4fv_is_not_20);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, header) == 0,
-               OffsetOf_UniformMatrix4fv_header_not_0);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, location) == 4,
-               OffsetOf_UniformMatrix4fv_location_not_4);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, count) == 8,
-               OffsetOf_UniformMatrix4fv_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_id) == 12,
-               OffsetOf_UniformMatrix4fv_value_shm_id_not_12);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_offset) == 16,
-               OffsetOf_UniformMatrix4fv_value_shm_offset_not_16);
-
 struct UniformMatrix4fvImmediate {
   typedef UniformMatrix4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4fvImmediate;
@@ -7218,52 +6168,6 @@ COMPILE_ASSERT(offsetof(VertexAttrib1f, indx) == 4,
 COMPILE_ASSERT(offsetof(VertexAttrib1f, x) == 8,
                OffsetOf_VertexAttrib1f_x_not_8);
 
-struct VertexAttrib1fv {
-  typedef VertexAttrib1fv ValueType;
-  static const CommandId kCmdId = kVertexAttrib1fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    SetHeader();
-    indx = _indx;
-    values_shm_id = _values_shm_id;
-    values_shm_offset = _values_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_indx, _values_shm_id, _values_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t indx;
-  uint32_t values_shm_id;
-  uint32_t values_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(VertexAttrib1fv) == 16, Sizeof_VertexAttrib1fv_is_not_16);
-COMPILE_ASSERT(offsetof(VertexAttrib1fv, header) == 0,
-               OffsetOf_VertexAttrib1fv_header_not_0);
-COMPILE_ASSERT(offsetof(VertexAttrib1fv, indx) == 4,
-               OffsetOf_VertexAttrib1fv_indx_not_4);
-COMPILE_ASSERT(offsetof(VertexAttrib1fv, values_shm_id) == 8,
-               OffsetOf_VertexAttrib1fv_values_shm_id_not_8);
-COMPILE_ASSERT(offsetof(VertexAttrib1fv, values_shm_offset) == 12,
-               OffsetOf_VertexAttrib1fv_values_shm_offset_not_12);
-
 struct VertexAttrib1fvImmediate {
   typedef VertexAttrib1fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib1fvImmediate;
@@ -7344,52 +6248,6 @@ COMPILE_ASSERT(offsetof(VertexAttrib2f, x) == 8,
 COMPILE_ASSERT(offsetof(VertexAttrib2f, y) == 12,
                OffsetOf_VertexAttrib2f_y_not_12);
 
-struct VertexAttrib2fv {
-  typedef VertexAttrib2fv ValueType;
-  static const CommandId kCmdId = kVertexAttrib2fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    SetHeader();
-    indx = _indx;
-    values_shm_id = _values_shm_id;
-    values_shm_offset = _values_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_indx, _values_shm_id, _values_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t indx;
-  uint32_t values_shm_id;
-  uint32_t values_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(VertexAttrib2fv) == 16, Sizeof_VertexAttrib2fv_is_not_16);
-COMPILE_ASSERT(offsetof(VertexAttrib2fv, header) == 0,
-               OffsetOf_VertexAttrib2fv_header_not_0);
-COMPILE_ASSERT(offsetof(VertexAttrib2fv, indx) == 4,
-               OffsetOf_VertexAttrib2fv_indx_not_4);
-COMPILE_ASSERT(offsetof(VertexAttrib2fv, values_shm_id) == 8,
-               OffsetOf_VertexAttrib2fv_values_shm_id_not_8);
-COMPILE_ASSERT(offsetof(VertexAttrib2fv, values_shm_offset) == 12,
-               OffsetOf_VertexAttrib2fv_values_shm_offset_not_12);
-
 struct VertexAttrib2fvImmediate {
   typedef VertexAttrib2fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib2fvImmediate;
@@ -7474,52 +6332,6 @@ COMPILE_ASSERT(offsetof(VertexAttrib3f, y) == 12,
 COMPILE_ASSERT(offsetof(VertexAttrib3f, z) == 16,
                OffsetOf_VertexAttrib3f_z_not_16);
 
-struct VertexAttrib3fv {
-  typedef VertexAttrib3fv ValueType;
-  static const CommandId kCmdId = kVertexAttrib3fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    SetHeader();
-    indx = _indx;
-    values_shm_id = _values_shm_id;
-    values_shm_offset = _values_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_indx, _values_shm_id, _values_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t indx;
-  uint32_t values_shm_id;
-  uint32_t values_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(VertexAttrib3fv) == 16, Sizeof_VertexAttrib3fv_is_not_16);
-COMPILE_ASSERT(offsetof(VertexAttrib3fv, header) == 0,
-               OffsetOf_VertexAttrib3fv_header_not_0);
-COMPILE_ASSERT(offsetof(VertexAttrib3fv, indx) == 4,
-               OffsetOf_VertexAttrib3fv_indx_not_4);
-COMPILE_ASSERT(offsetof(VertexAttrib3fv, values_shm_id) == 8,
-               OffsetOf_VertexAttrib3fv_values_shm_id_not_8);
-COMPILE_ASSERT(offsetof(VertexAttrib3fv, values_shm_offset) == 12,
-               OffsetOf_VertexAttrib3fv_values_shm_offset_not_12);
-
 struct VertexAttrib3fvImmediate {
   typedef VertexAttrib3fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib3fvImmediate;
@@ -7613,52 +6425,6 @@ COMPILE_ASSERT(offsetof(VertexAttrib4f, z) == 16,
 COMPILE_ASSERT(offsetof(VertexAttrib4f, w) == 20,
                OffsetOf_VertexAttrib4f_w_not_20);
 
-struct VertexAttrib4fv {
-  typedef VertexAttrib4fv ValueType;
-  static const CommandId kCmdId = kVertexAttrib4fv;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    SetHeader();
-    indx = _indx;
-    values_shm_id = _values_shm_id;
-    values_shm_offset = _values_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLuint _indx,
-            uint32_t _values_shm_id,
-            uint32_t _values_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_indx, _values_shm_id, _values_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t indx;
-  uint32_t values_shm_id;
-  uint32_t values_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(VertexAttrib4fv) == 16, Sizeof_VertexAttrib4fv_is_not_16);
-COMPILE_ASSERT(offsetof(VertexAttrib4fv, header) == 0,
-               OffsetOf_VertexAttrib4fv_header_not_0);
-COMPILE_ASSERT(offsetof(VertexAttrib4fv, indx) == 4,
-               OffsetOf_VertexAttrib4fv_indx_not_4);
-COMPILE_ASSERT(offsetof(VertexAttrib4fv, values_shm_id) == 8,
-               OffsetOf_VertexAttrib4fv_values_shm_id_not_8);
-COMPILE_ASSERT(offsetof(VertexAttrib4fv, values_shm_offset) == 12,
-               OffsetOf_VertexAttrib4fv_values_shm_offset_not_12);
-
 struct VertexAttrib4fvImmediate {
   typedef VertexAttrib4fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib4fvImmediate;
@@ -8141,51 +6907,6 @@ COMPILE_ASSERT(offsetof(TexStorage2DEXT, width) == 16,
 COMPILE_ASSERT(offsetof(TexStorage2DEXT, height) == 20,
                OffsetOf_TexStorage2DEXT_height_not_20);
 
-struct GenQueriesEXT {
-  typedef GenQueriesEXT ValueType;
-  static const CommandId kCmdId = kGenQueriesEXT;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _queries_shm_id,
-            uint32_t _queries_shm_offset) {
-    SetHeader();
-    n = _n;
-    queries_shm_id = _queries_shm_id;
-    queries_shm_offset = _queries_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _queries_shm_id,
-            uint32_t _queries_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _queries_shm_id, _queries_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t queries_shm_id;
-  uint32_t queries_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(GenQueriesEXT) == 16, Sizeof_GenQueriesEXT_is_not_16);
-COMPILE_ASSERT(offsetof(GenQueriesEXT, header) == 0,
-               OffsetOf_GenQueriesEXT_header_not_0);
-COMPILE_ASSERT(offsetof(GenQueriesEXT, n) == 4, OffsetOf_GenQueriesEXT_n_not_4);
-COMPILE_ASSERT(offsetof(GenQueriesEXT, queries_shm_id) == 8,
-               OffsetOf_GenQueriesEXT_queries_shm_id_not_8);
-COMPILE_ASSERT(offsetof(GenQueriesEXT, queries_shm_offset) == 12,
-               OffsetOf_GenQueriesEXT_queries_shm_offset_not_12);
-
 struct GenQueriesEXTImmediate {
   typedef GenQueriesEXTImmediate ValueType;
   static const CommandId kCmdId = kGenQueriesEXTImmediate;
@@ -8228,53 +6949,6 @@ COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, n) == 4,
                OffsetOf_GenQueriesEXTImmediate_n_not_4);
 
-struct DeleteQueriesEXT {
-  typedef DeleteQueriesEXT ValueType;
-  static const CommandId kCmdId = kDeleteQueriesEXT;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n,
-            uint32_t _queries_shm_id,
-            uint32_t _queries_shm_offset) {
-    SetHeader();
-    n = _n;
-    queries_shm_id = _queries_shm_id;
-    queries_shm_offset = _queries_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _queries_shm_id,
-            uint32_t _queries_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_n, _queries_shm_id, _queries_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t queries_shm_id;
-  uint32_t queries_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DeleteQueriesEXT) == 16,
-               Sizeof_DeleteQueriesEXT_is_not_16);
-COMPILE_ASSERT(offsetof(DeleteQueriesEXT, header) == 0,
-               OffsetOf_DeleteQueriesEXT_header_not_0);
-COMPILE_ASSERT(offsetof(DeleteQueriesEXT, n) == 4,
-               OffsetOf_DeleteQueriesEXT_n_not_4);
-COMPILE_ASSERT(offsetof(DeleteQueriesEXT, queries_shm_id) == 8,
-               OffsetOf_DeleteQueriesEXT_queries_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DeleteQueriesEXT, queries_shm_offset) == 12,
-               OffsetOf_DeleteQueriesEXT_queries_shm_offset_not_12);
-
 struct DeleteQueriesEXTImmediate {
   typedef DeleteQueriesEXTImmediate ValueType;
   static const CommandId kCmdId = kDeleteQueriesEXTImmediate;
@@ -8498,50 +7172,6 @@ COMPILE_ASSERT(sizeof(PopGroupMarkerEXT) == 4,
 COMPILE_ASSERT(offsetof(PopGroupMarkerEXT, header) == 0,
                OffsetOf_PopGroupMarkerEXT_header_not_0);
 
-struct GenVertexArraysOES {
-  typedef GenVertexArraysOES ValueType;
-  static const CommandId kCmdId = kGenVertexArraysOES;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n, uint32_t _arrays_shm_id, uint32_t _arrays_shm_offset) {
-    SetHeader();
-    n = _n;
-    arrays_shm_id = _arrays_shm_id;
-    arrays_shm_offset = _arrays_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _arrays_shm_id,
-            uint32_t _arrays_shm_offset) {
-    static_cast<ValueType*>(cmd)->Init(_n, _arrays_shm_id, _arrays_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t arrays_shm_id;
-  uint32_t arrays_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(GenVertexArraysOES) == 16,
-               Sizeof_GenVertexArraysOES_is_not_16);
-COMPILE_ASSERT(offsetof(GenVertexArraysOES, header) == 0,
-               OffsetOf_GenVertexArraysOES_header_not_0);
-COMPILE_ASSERT(offsetof(GenVertexArraysOES, n) == 4,
-               OffsetOf_GenVertexArraysOES_n_not_4);
-COMPILE_ASSERT(offsetof(GenVertexArraysOES, arrays_shm_id) == 8,
-               OffsetOf_GenVertexArraysOES_arrays_shm_id_not_8);
-COMPILE_ASSERT(offsetof(GenVertexArraysOES, arrays_shm_offset) == 12,
-               OffsetOf_GenVertexArraysOES_arrays_shm_offset_not_12);
-
 struct GenVertexArraysOESImmediate {
   typedef GenVertexArraysOESImmediate ValueType;
   static const CommandId kCmdId = kGenVertexArraysOESImmediate;
@@ -8584,50 +7214,6 @@ COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, n) == 4,
                OffsetOf_GenVertexArraysOESImmediate_n_not_4);
 
-struct DeleteVertexArraysOES {
-  typedef DeleteVertexArraysOES ValueType;
-  static const CommandId kCmdId = kDeleteVertexArraysOES;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _n, uint32_t _arrays_shm_id, uint32_t _arrays_shm_offset) {
-    SetHeader();
-    n = _n;
-    arrays_shm_id = _arrays_shm_id;
-    arrays_shm_offset = _arrays_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _n,
-            uint32_t _arrays_shm_id,
-            uint32_t _arrays_shm_offset) {
-    static_cast<ValueType*>(cmd)->Init(_n, _arrays_shm_id, _arrays_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t n;
-  uint32_t arrays_shm_id;
-  uint32_t arrays_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DeleteVertexArraysOES) == 16,
-               Sizeof_DeleteVertexArraysOES_is_not_16);
-COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, header) == 0,
-               OffsetOf_DeleteVertexArraysOES_header_not_0);
-COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, n) == 4,
-               OffsetOf_DeleteVertexArraysOES_n_not_4);
-COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, arrays_shm_id) == 8,
-               OffsetOf_DeleteVertexArraysOES_arrays_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DeleteVertexArraysOES, arrays_shm_offset) == 12,
-               OffsetOf_DeleteVertexArraysOES_arrays_shm_offset_not_12);
-
 struct DeleteVertexArraysOESImmediate {
   typedef DeleteVertexArraysOESImmediate ValueType;
   static const CommandId kCmdId = kDeleteVertexArraysOESImmediate;
@@ -9634,53 +8220,6 @@ COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, index) == 4,
 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, divisor) == 8,
                OffsetOf_VertexAttribDivisorANGLE_divisor_not_8);
 
-struct ProduceTextureCHROMIUM {
-  typedef ProduceTextureCHROMIUM ValueType;
-  static const CommandId kCmdId = kProduceTextureCHROMIUM;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            uint32_t _mailbox_shm_id,
-            uint32_t _mailbox_shm_offset) {
-    SetHeader();
-    target = _target;
-    mailbox_shm_id = _mailbox_shm_id;
-    mailbox_shm_offset = _mailbox_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            uint32_t _mailbox_shm_id,
-            uint32_t _mailbox_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _mailbox_shm_id, _mailbox_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  uint32_t mailbox_shm_id;
-  uint32_t mailbox_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(ProduceTextureCHROMIUM) == 16,
-               Sizeof_ProduceTextureCHROMIUM_is_not_16);
-COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, header) == 0,
-               OffsetOf_ProduceTextureCHROMIUM_header_not_0);
-COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, target) == 4,
-               OffsetOf_ProduceTextureCHROMIUM_target_not_4);
-COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, mailbox_shm_id) == 8,
-               OffsetOf_ProduceTextureCHROMIUM_mailbox_shm_id_not_8);
-COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUM, mailbox_shm_offset) == 12,
-               OffsetOf_ProduceTextureCHROMIUM_mailbox_shm_offset_not_12);
-
 struct ProduceTextureCHROMIUMImmediate {
   typedef ProduceTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kProduceTextureCHROMIUMImmediate;
@@ -9721,53 +8260,6 @@ COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, target) == 4,
                OffsetOf_ProduceTextureCHROMIUMImmediate_target_not_4);
 
-struct ConsumeTextureCHROMIUM {
-  typedef ConsumeTextureCHROMIUM ValueType;
-  static const CommandId kCmdId = kConsumeTextureCHROMIUM;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            uint32_t _mailbox_shm_id,
-            uint32_t _mailbox_shm_offset) {
-    SetHeader();
-    target = _target;
-    mailbox_shm_id = _mailbox_shm_id;
-    mailbox_shm_offset = _mailbox_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            uint32_t _mailbox_shm_id,
-            uint32_t _mailbox_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _mailbox_shm_id, _mailbox_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  uint32_t mailbox_shm_id;
-  uint32_t mailbox_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(ConsumeTextureCHROMIUM) == 16,
-               Sizeof_ConsumeTextureCHROMIUM_is_not_16);
-COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, header) == 0,
-               OffsetOf_ConsumeTextureCHROMIUM_header_not_0);
-COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, target) == 4,
-               OffsetOf_ConsumeTextureCHROMIUM_target_not_4);
-COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, mailbox_shm_id) == 8,
-               OffsetOf_ConsumeTextureCHROMIUM_mailbox_shm_id_not_8);
-COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUM, mailbox_shm_offset) == 12,
-               OffsetOf_ConsumeTextureCHROMIUM_mailbox_shm_offset_not_12);
-
 struct ConsumeTextureCHROMIUMImmediate {
   typedef ConsumeTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kConsumeTextureCHROMIUMImmediate;
@@ -10335,59 +8827,6 @@ COMPILE_ASSERT(sizeof(WaitAllAsyncTexImage2DCHROMIUM) == 4,
 COMPILE_ASSERT(offsetof(WaitAllAsyncTexImage2DCHROMIUM, header) == 0,
                OffsetOf_WaitAllAsyncTexImage2DCHROMIUM_header_not_0);
 
-struct DiscardFramebufferEXT {
-  typedef DiscardFramebufferEXT ValueType;
-  static const CommandId kCmdId = kDiscardFramebufferEXT;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLenum _target,
-            GLsizei _count,
-            uint32_t _attachments_shm_id,
-            uint32_t _attachments_shm_offset) {
-    SetHeader();
-    target = _target;
-    count = _count;
-    attachments_shm_id = _attachments_shm_id;
-    attachments_shm_offset = _attachments_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLenum _target,
-            GLsizei _count,
-            uint32_t _attachments_shm_id,
-            uint32_t _attachments_shm_offset) {
-    static_cast<ValueType*>(cmd)
-        ->Init(_target, _count, _attachments_shm_id, _attachments_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  uint32_t target;
-  int32_t count;
-  uint32_t attachments_shm_id;
-  uint32_t attachments_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DiscardFramebufferEXT) == 20,
-               Sizeof_DiscardFramebufferEXT_is_not_20);
-COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, header) == 0,
-               OffsetOf_DiscardFramebufferEXT_header_not_0);
-COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, target) == 4,
-               OffsetOf_DiscardFramebufferEXT_target_not_4);
-COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, count) == 8,
-               OffsetOf_DiscardFramebufferEXT_count_not_8);
-COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, attachments_shm_id) == 12,
-               OffsetOf_DiscardFramebufferEXT_attachments_shm_id_not_12);
-COMPILE_ASSERT(offsetof(DiscardFramebufferEXT, attachments_shm_offset) == 16,
-               OffsetOf_DiscardFramebufferEXT_attachments_shm_offset_not_16);
-
 struct DiscardFramebufferEXTImmediate {
   typedef DiscardFramebufferEXTImmediate ValueType;
   static const CommandId kCmdId = kDiscardFramebufferEXTImmediate;
@@ -10507,49 +8946,6 @@ COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, header) == 0,
 COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, sync_point) == 4,
                OffsetOf_WaitSyncPointCHROMIUM_sync_point_not_4);
 
-struct DrawBuffersEXT {
-  typedef DrawBuffersEXT ValueType;
-  static const CommandId kCmdId = kDrawBuffersEXT;
-  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
-
-  static uint32_t ComputeSize() {
-    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
-  }
-
-  void SetHeader() { header.SetCmd<ValueType>(); }
-
-  void Init(GLsizei _count, uint32_t _bufs_shm_id, uint32_t _bufs_shm_offset) {
-    SetHeader();
-    count = _count;
-    bufs_shm_id = _bufs_shm_id;
-    bufs_shm_offset = _bufs_shm_offset;
-  }
-
-  void* Set(void* cmd,
-            GLsizei _count,
-            uint32_t _bufs_shm_id,
-            uint32_t _bufs_shm_offset) {
-    static_cast<ValueType*>(cmd)->Init(_count, _bufs_shm_id, _bufs_shm_offset);
-    return NextCmdAddress<ValueType>(cmd);
-  }
-
-  gpu::CommandHeader header;
-  int32_t count;
-  uint32_t bufs_shm_id;
-  uint32_t bufs_shm_offset;
-};
-
-COMPILE_ASSERT(sizeof(DrawBuffersEXT) == 16, Sizeof_DrawBuffersEXT_is_not_16);
-COMPILE_ASSERT(offsetof(DrawBuffersEXT, header) == 0,
-               OffsetOf_DrawBuffersEXT_header_not_0);
-COMPILE_ASSERT(offsetof(DrawBuffersEXT, count) == 4,
-               OffsetOf_DrawBuffersEXT_count_not_4);
-COMPILE_ASSERT(offsetof(DrawBuffersEXT, bufs_shm_id) == 8,
-               OffsetOf_DrawBuffersEXT_bufs_shm_id_not_8);
-COMPILE_ASSERT(offsetof(DrawBuffersEXT, bufs_shm_offset) == 12,
-               OffsetOf_DrawBuffersEXT_bufs_shm_offset_not_12);
-
 struct DrawBuffersEXTImmediate {
   typedef DrawBuffersEXTImmediate ValueType;
   static const CommandId kCmdId = kDrawBuffersEXTImmediate;
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index b76aa29..e3ccc12 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -495,21 +495,6 @@ TEST_F(GLES2FormatTest, CullFace) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, DeleteBuffers) {
-  cmds::DeleteBuffers& cmd = *GetBufferAs<cmds::DeleteBuffers>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteBuffers::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.buffers_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.buffers_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DeleteBuffersImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -528,21 +513,6 @@ TEST_F(GLES2FormatTest, DeleteBuffersImmediate) {
   // TODO(gman): Check that ids were inserted;
 }
 
-TEST_F(GLES2FormatTest, DeleteFramebuffers) {
-  cmds::DeleteFramebuffers& cmd = *GetBufferAs<cmds::DeleteFramebuffers>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteFramebuffers::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.framebuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.framebuffers_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DeleteFramebuffersImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -571,21 +541,6 @@ TEST_F(GLES2FormatTest, DeleteProgram) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, DeleteRenderbuffers) {
-  cmds::DeleteRenderbuffers& cmd = *GetBufferAs<cmds::DeleteRenderbuffers>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteRenderbuffers::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.renderbuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.renderbuffers_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DeleteRenderbuffersImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -614,21 +569,6 @@ TEST_F(GLES2FormatTest, DeleteShader) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, DeleteTextures) {
-  cmds::DeleteTextures& cmd = *GetBufferAs<cmds::DeleteTextures>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteTextures::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.textures_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.textures_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DeleteTexturesImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -821,21 +761,6 @@ TEST_F(GLES2FormatTest, FrontFace) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, GenBuffers) {
-  cmds::GenBuffers& cmd = *GetBufferAs<cmds::GenBuffers>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::GenBuffers::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.buffers_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.buffers_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, GenBuffersImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -863,21 +788,6 @@ TEST_F(GLES2FormatTest, GenerateMipmap) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, GenFramebuffers) {
-  cmds::GenFramebuffers& cmd = *GetBufferAs<cmds::GenFramebuffers>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::GenFramebuffers::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.framebuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.framebuffers_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, GenFramebuffersImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -896,21 +806,6 @@ TEST_F(GLES2FormatTest, GenFramebuffersImmediate) {
   // TODO(gman): Check that ids were inserted;
 }
 
-TEST_F(GLES2FormatTest, GenRenderbuffers) {
-  cmds::GenRenderbuffers& cmd = *GetBufferAs<cmds::GenRenderbuffers>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::GenRenderbuffers::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.renderbuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.renderbuffers_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, GenRenderbuffersImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -929,21 +824,6 @@ TEST_F(GLES2FormatTest, GenRenderbuffersImmediate) {
   // TODO(gman): Check that ids were inserted;
 }
 
-TEST_F(GLES2FormatTest, GenTextures) {
-  cmds::GenTextures& cmd = *GetBufferAs<cmds::GenTextures>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::GenTextures::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.textures_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.textures_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, GenTexturesImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -1769,23 +1649,6 @@ TEST_F(GLES2FormatTest, TexParameterf) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, TexParameterfv) {
-  cmds::TexParameterfv& cmd = *GetBufferAs<cmds::TexParameterfv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameterfv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -1821,23 +1684,6 @@ TEST_F(GLES2FormatTest, TexParameteri) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, TexParameteriv) {
-  cmds::TexParameteriv& cmd = *GetBufferAs<cmds::TexParameteriv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameteriv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, TexParameterivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
@@ -1900,23 +1746,6 @@ TEST_F(GLES2FormatTest, Uniform1f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform1fv) {
-  cmds::Uniform1fv& cmd = *GetBufferAs<cmds::Uniform1fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform1fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -1950,23 +1779,6 @@ TEST_F(GLES2FormatTest, Uniform1i) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform1iv) {
-  cmds::Uniform1iv& cmd = *GetBufferAs<cmds::Uniform1iv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1iv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform1ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
@@ -2003,23 +1815,6 @@ TEST_F(GLES2FormatTest, Uniform2f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform2fv) {
-  cmds::Uniform2fv& cmd = *GetBufferAs<cmds::Uniform2fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2058,23 +1853,6 @@ TEST_F(GLES2FormatTest, Uniform2i) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform2iv) {
-  cmds::Uniform2iv& cmd = *GetBufferAs<cmds::Uniform2iv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2iv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
@@ -2115,23 +1893,6 @@ TEST_F(GLES2FormatTest, Uniform3f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform3fv) {
-  cmds::Uniform3fv& cmd = *GetBufferAs<cmds::Uniform3fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2174,23 +1935,6 @@ TEST_F(GLES2FormatTest, Uniform3i) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform3iv) {
-  cmds::Uniform3iv& cmd = *GetBufferAs<cmds::Uniform3iv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3iv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
@@ -2235,23 +1979,6 @@ TEST_F(GLES2FormatTest, Uniform4f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform4fv) {
-  cmds::Uniform4fv& cmd = *GetBufferAs<cmds::Uniform4fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform4fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2298,23 +2025,6 @@ TEST_F(GLES2FormatTest, Uniform4i) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, Uniform4iv) {
-  cmds::Uniform4iv& cmd = *GetBufferAs<cmds::Uniform4iv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4iv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
@@ -2343,23 +2053,6 @@ TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
   // TODO(gman): Check that data was inserted;
 }
 
-TEST_F(GLES2FormatTest, UniformMatrix2fv) {
-  cmds::UniformMatrix2fv& cmd = *GetBufferAs<cmds::UniformMatrix2fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix2fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2389,23 +2082,6 @@ TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
   // TODO(gman): Check that data was inserted;
 }
 
-TEST_F(GLES2FormatTest, UniformMatrix3fv) {
-  cmds::UniformMatrix3fv& cmd = *GetBufferAs<cmds::UniformMatrix3fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix3fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2445,23 +2121,6 @@ TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
   // TODO(gman): Check that data was inserted;
 }
 
-TEST_F(GLES2FormatTest, UniformMatrix4fv) {
-  cmds::UniformMatrix4fv& cmd = *GetBufferAs<cmds::UniformMatrix4fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix4fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2547,21 +2206,6 @@ TEST_F(GLES2FormatTest, VertexAttrib1f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, VertexAttrib1fv) {
-  cmds::VertexAttrib1fv& cmd = *GetBufferAs<cmds::VertexAttrib1fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib1fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, VertexAttrib1fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2595,21 +2239,6 @@ TEST_F(GLES2FormatTest, VertexAttrib2f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, VertexAttrib2fv) {
-  cmds::VertexAttrib2fv& cmd = *GetBufferAs<cmds::VertexAttrib2fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib2fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2646,21 +2275,6 @@ TEST_F(GLES2FormatTest, VertexAttrib3f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, VertexAttrib3fv) {
-  cmds::VertexAttrib3fv& cmd = *GetBufferAs<cmds::VertexAttrib3fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib3fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, VertexAttrib3fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2700,21 +2314,6 @@ TEST_F(GLES2FormatTest, VertexAttrib4f) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, VertexAttrib4fv) {
-  cmds::VertexAttrib4fv& cmd = *GetBufferAs<cmds::VertexAttrib4fv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib4fv::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, VertexAttrib4fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
@@ -2885,21 +2484,6 @@ TEST_F(GLES2FormatTest, TexStorage2DEXT) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, GenQueriesEXT) {
-  cmds::GenQueriesEXT& cmd = *GetBufferAs<cmds::GenQueriesEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::GenQueriesEXT::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.queries_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.queries_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, GenQueriesEXTImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -2918,21 +2502,6 @@ TEST_F(GLES2FormatTest, GenQueriesEXTImmediate) {
   // TODO(gman): Check that ids were inserted;
 }
 
-TEST_F(GLES2FormatTest, DeleteQueriesEXT) {
-  cmds::DeleteQueriesEXT& cmd = *GetBufferAs<cmds::DeleteQueriesEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteQueriesEXT::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.queries_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.queries_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DeleteQueriesEXTImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -3009,21 +2578,6 @@ TEST_F(GLES2FormatTest, PopGroupMarkerEXT) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, GenVertexArraysOES) {
-  cmds::GenVertexArraysOES& cmd = *GetBufferAs<cmds::GenVertexArraysOES>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::GenVertexArraysOES::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.arrays_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.arrays_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, GenVertexArraysOESImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -3042,22 +2596,6 @@ TEST_F(GLES2FormatTest, GenVertexArraysOESImmediate) {
   // TODO(gman): Check that ids were inserted;
 }
 
-TEST_F(GLES2FormatTest, DeleteVertexArraysOES) {
-  cmds::DeleteVertexArraysOES& cmd =
-      *GetBufferAs<cmds::DeleteVertexArraysOES>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteVertexArraysOES::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.arrays_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.arrays_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DeleteVertexArraysOESImmediate) {
   static GLuint ids[] = {
       12, 23, 34,
@@ -3400,22 +2938,6 @@ TEST_F(GLES2FormatTest, VertexAttribDivisorANGLE) {
 }
 
 // TODO(gman): Write test for GenMailboxCHROMIUM
-TEST_F(GLES2FormatTest, ProduceTextureCHROMIUM) {
-  cmds::ProduceTextureCHROMIUM& cmd =
-      *GetBufferAs<cmds::ProduceTextureCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::ProduceTextureCHROMIUM::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.mailbox_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.mailbox_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, ProduceTextureCHROMIUMImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLbyte data[] = {
@@ -3498,22 +3020,6 @@ TEST_F(GLES2FormatTest, ProduceTextureCHROMIUMImmediate) {
   // TODO(gman): Check that data was inserted;
 }
 
-TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUM) {
-  cmds::ConsumeTextureCHROMIUM& cmd =
-      *GetBufferAs<cmds::ConsumeTextureCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::ConsumeTextureCHROMIUM::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.mailbox_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.mailbox_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUMImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLbyte data[] = {
@@ -3769,24 +3275,6 @@ TEST_F(GLES2FormatTest, WaitAllAsyncTexImage2DCHROMIUM) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, DiscardFramebufferEXT) {
-  cmds::DiscardFramebufferEXT& cmd =
-      *GetBufferAs<cmds::DiscardFramebufferEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DiscardFramebufferEXT::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.attachments_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.attachments_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLenum data[] = {
@@ -3834,21 +3322,6 @@ TEST_F(GLES2FormatTest, WaitSyncPointCHROMIUM) {
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
-TEST_F(GLES2FormatTest, DrawBuffersEXT) {
-  cmds::DrawBuffersEXT& cmd = *GetBufferAs<cmds::DrawBuffersEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
-  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawBuffersEXT::kCmdId),
-            cmd.header.command);
-  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<GLsizei>(11), cmd.count);
-  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bufs_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(13), cmd.bufs_shm_offset);
-  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
-}
-
 TEST_F(GLES2FormatTest, DrawBuffersEXTImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLenum data[] = {
diff --git a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
index aed4e77..c10d829 100644
--- a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
@@ -43,210 +43,177 @@
   OP(CreateProgram)                          /* 284 */ \
   OP(CreateShader)                           /* 285 */ \
   OP(CullFace)                               /* 286 */ \
-  OP(DeleteBuffers)                          /* 287 */ \
-  OP(DeleteBuffersImmediate)                 /* 288 */ \
-  OP(DeleteFramebuffers)                     /* 289 */ \
-  OP(DeleteFramebuffersImmediate)            /* 290 */ \
-  OP(DeleteProgram)                          /* 291 */ \
-  OP(DeleteRenderbuffers)                    /* 292 */ \
-  OP(DeleteRenderbuffersImmediate)           /* 293 */ \
-  OP(DeleteShader)                           /* 294 */ \
-  OP(DeleteTextures)                         /* 295 */ \
-  OP(DeleteTexturesImmediate)                /* 296 */ \
-  OP(DepthFunc)                              /* 297 */ \
-  OP(DepthMask)                              /* 298 */ \
-  OP(DepthRangef)                            /* 299 */ \
-  OP(DetachShader)                           /* 300 */ \
-  OP(Disable)                                /* 301 */ \
-  OP(DisableVertexAttribArray)               /* 302 */ \
-  OP(DrawArrays)                             /* 303 */ \
-  OP(DrawElements)                           /* 304 */ \
-  OP(Enable)                                 /* 305 */ \
-  OP(EnableVertexAttribArray)                /* 306 */ \
-  OP(Finish)                                 /* 307 */ \
-  OP(Flush)                                  /* 308 */ \
-  OP(FramebufferRenderbuffer)                /* 309 */ \
-  OP(FramebufferTexture2D)                   /* 310 */ \
-  OP(FrontFace)                              /* 311 */ \
-  OP(GenBuffers)                             /* 312 */ \
-  OP(GenBuffersImmediate)                    /* 313 */ \
-  OP(GenerateMipmap)                         /* 314 */ \
-  OP(GenFramebuffers)                        /* 315 */ \
-  OP(GenFramebuffersImmediate)               /* 316 */ \
-  OP(GenRenderbuffers)                       /* 317 */ \
-  OP(GenRenderbuffersImmediate)              /* 318 */ \
-  OP(GenTextures)                            /* 319 */ \
-  OP(GenTexturesImmediate)                   /* 320 */ \
-  OP(GetActiveAttrib)                        /* 321 */ \
-  OP(GetActiveUniform)                       /* 322 */ \
-  OP(GetAttachedShaders)                     /* 323 */ \
-  OP(GetAttribLocation)                      /* 324 */ \
-  OP(GetAttribLocationBucket)                /* 325 */ \
-  OP(GetBooleanv)                            /* 326 */ \
-  OP(GetBufferParameteriv)                   /* 327 */ \
-  OP(GetError)                               /* 328 */ \
-  OP(GetFloatv)                              /* 329 */ \
-  OP(GetFramebufferAttachmentParameteriv)    /* 330 */ \
-  OP(GetIntegerv)                            /* 331 */ \
-  OP(GetProgramiv)                           /* 332 */ \
-  OP(GetProgramInfoLog)                      /* 333 */ \
-  OP(GetRenderbufferParameteriv)             /* 334 */ \
-  OP(GetShaderiv)                            /* 335 */ \
-  OP(GetShaderInfoLog)                       /* 336 */ \
-  OP(GetShaderPrecisionFormat)               /* 337 */ \
-  OP(GetShaderSource)                        /* 338 */ \
-  OP(GetString)                              /* 339 */ \
-  OP(GetTexParameterfv)                      /* 340 */ \
-  OP(GetTexParameteriv)                      /* 341 */ \
-  OP(GetUniformfv)                           /* 342 */ \
-  OP(GetUniformiv)                           /* 343 */ \
-  OP(GetUniformLocation)                     /* 344 */ \
-  OP(GetUniformLocationBucket)               /* 345 */ \
-  OP(GetVertexAttribfv)                      /* 346 */ \
-  OP(GetVertexAttribiv)                      /* 347 */ \
-  OP(GetVertexAttribPointerv)                /* 348 */ \
-  OP(Hint)                                   /* 349 */ \
-  OP(IsBuffer)                               /* 350 */ \
-  OP(IsEnabled)                              /* 351 */ \
-  OP(IsFramebuffer)                          /* 352 */ \
-  OP(IsProgram)                              /* 353 */ \
-  OP(IsRenderbuffer)                         /* 354 */ \
-  OP(IsShader)                               /* 355 */ \
-  OP(IsTexture)                              /* 356 */ \
-  OP(LineWidth)                              /* 357 */ \
-  OP(LinkProgram)                            /* 358 */ \
-  OP(PixelStorei)                            /* 359 */ \
-  OP(PolygonOffset)                          /* 360 */ \
-  OP(ReadPixels)                             /* 361 */ \
-  OP(ReleaseShaderCompiler)                  /* 362 */ \
-  OP(RenderbufferStorage)                    /* 363 */ \
-  OP(SampleCoverage)                         /* 364 */ \
-  OP(Scissor)                                /* 365 */ \
-  OP(ShaderBinary)                           /* 366 */ \
-  OP(ShaderSource)                           /* 367 */ \
-  OP(ShaderSourceBucket)                     /* 368 */ \
-  OP(StencilFunc)                            /* 369 */ \
-  OP(StencilFuncSeparate)                    /* 370 */ \
-  OP(StencilMask)                            /* 371 */ \
-  OP(StencilMaskSeparate)                    /* 372 */ \
-  OP(StencilOp)                              /* 373 */ \
-  OP(StencilOpSeparate)                      /* 374 */ \
-  OP(TexImage2D)                             /* 375 */ \
-  OP(TexParameterf)                          /* 376 */ \
-  OP(TexParameterfv)                         /* 377 */ \
-  OP(TexParameterfvImmediate)                /* 378 */ \
-  OP(TexParameteri)                          /* 379 */ \
-  OP(TexParameteriv)                         /* 380 */ \
-  OP(TexParameterivImmediate)                /* 381 */ \
-  OP(TexSubImage2D)                          /* 382 */ \
-  OP(Uniform1f)                              /* 383 */ \
-  OP(Uniform1fv)                             /* 384 */ \
-  OP(Uniform1fvImmediate)                    /* 385 */ \
-  OP(Uniform1i)                              /* 386 */ \
-  OP(Uniform1iv)                             /* 387 */ \
-  OP(Uniform1ivImmediate)                    /* 388 */ \
-  OP(Uniform2f)                              /* 389 */ \
-  OP(Uniform2fv)                             /* 390 */ \
-  OP(Uniform2fvImmediate)                    /* 391 */ \
-  OP(Uniform2i)                              /* 392 */ \
-  OP(Uniform2iv)                             /* 393 */ \
-  OP(Uniform2ivImmediate)                    /* 394 */ \
-  OP(Uniform3f)                              /* 395 */ \
-  OP(Uniform3fv)                             /* 396 */ \
-  OP(Uniform3fvImmediate)                    /* 397 */ \
-  OP(Uniform3i)                              /* 398 */ \
-  OP(Uniform3iv)                             /* 399 */ \
-  OP(Uniform3ivImmediate)                    /* 400 */ \
-  OP(Uniform4f)                              /* 401 */ \
-  OP(Uniform4fv)                             /* 402 */ \
-  OP(Uniform4fvImmediate)                    /* 403 */ \
-  OP(Uniform4i)                              /* 404 */ \
-  OP(Uniform4iv)                             /* 405 */ \
-  OP(Uniform4ivImmediate)                    /* 406 */ \
-  OP(UniformMatrix2fv)                       /* 407 */ \
-  OP(UniformMatrix2fvImmediate)              /* 408 */ \
-  OP(UniformMatrix3fv)                       /* 409 */ \
-  OP(UniformMatrix3fvImmediate)              /* 410 */ \
-  OP(UniformMatrix4fv)                       /* 411 */ \
-  OP(UniformMatrix4fvImmediate)              /* 412 */ \
-  OP(UseProgram)                             /* 413 */ \
-  OP(ValidateProgram)                        /* 414 */ \
-  OP(VertexAttrib1f)                         /* 415 */ \
-  OP(VertexAttrib1fv)                        /* 416 */ \
-  OP(VertexAttrib1fvImmediate)               /* 417 */ \
-  OP(VertexAttrib2f)                         /* 418 */ \
-  OP(VertexAttrib2fv)                        /* 419 */ \
-  OP(VertexAttrib2fvImmediate)               /* 420 */ \
-  OP(VertexAttrib3f)                         /* 421 */ \
-  OP(VertexAttrib3fv)                        /* 422 */ \
-  OP(VertexAttrib3fvImmediate)               /* 423 */ \
-  OP(VertexAttrib4f)                         /* 424 */ \
-  OP(VertexAttrib4fv)                        /* 425 */ \
-  OP(VertexAttrib4fvImmediate)               /* 426 */ \
-  OP(VertexAttribPointer)                    /* 427 */ \
-  OP(Viewport)                               /* 428 */ \
-  OP(BlitFramebufferCHROMIUM)                /* 429 */ \
-  OP(RenderbufferStorageMultisampleCHROMIUM) /* 430 */ \
-  OP(RenderbufferStorageMultisampleEXT)      /* 431 */ \
-  OP(FramebufferTexture2DMultisampleEXT)     /* 432 */ \
-  OP(TexStorage2DEXT)                        /* 433 */ \
-  OP(GenQueriesEXT)                          /* 434 */ \
-  OP(GenQueriesEXTImmediate)                 /* 435 */ \
-  OP(DeleteQueriesEXT)                       /* 436 */ \
-  OP(DeleteQueriesEXTImmediate)              /* 437 */ \
-  OP(BeginQueryEXT)                          /* 438 */ \
-  OP(EndQueryEXT)                            /* 439 */ \
-  OP(InsertEventMarkerEXT)                   /* 440 */ \
-  OP(PushGroupMarkerEXT)                     /* 441 */ \
-  OP(PopGroupMarkerEXT)                      /* 442 */ \
-  OP(GenVertexArraysOES)                     /* 443 */ \
-  OP(GenVertexArraysOESImmediate)            /* 444 */ \
-  OP(DeleteVertexArraysOES)                  /* 445 */ \
-  OP(DeleteVertexArraysOESImmediate)         /* 446 */ \
-  OP(IsVertexArrayOES)                       /* 447 */ \
-  OP(BindVertexArrayOES)                     /* 448 */ \
-  OP(SwapBuffers)                            /* 449 */ \
-  OP(GetMaxValueInBufferCHROMIUM)            /* 450 */ \
-  OP(GenSharedIdsCHROMIUM)                   /* 451 */ \
-  OP(DeleteSharedIdsCHROMIUM)                /* 452 */ \
-  OP(RegisterSharedIdsCHROMIUM)              /* 453 */ \
-  OP(EnableFeatureCHROMIUM)                  /* 454 */ \
-  OP(ResizeCHROMIUM)                         /* 455 */ \
-  OP(GetRequestableExtensionsCHROMIUM)       /* 456 */ \
-  OP(RequestExtensionCHROMIUM)               /* 457 */ \
-  OP(GetMultipleIntegervCHROMIUM)            /* 458 */ \
-  OP(GetProgramInfoCHROMIUM)                 /* 459 */ \
-  OP(GetTranslatedShaderSourceANGLE)         /* 460 */ \
-  OP(PostSubBufferCHROMIUM)                  /* 461 */ \
-  OP(TexImageIOSurface2DCHROMIUM)            /* 462 */ \
-  OP(CopyTextureCHROMIUM)                    /* 463 */ \
-  OP(DrawArraysInstancedANGLE)               /* 464 */ \
-  OP(DrawElementsInstancedANGLE)             /* 465 */ \
-  OP(VertexAttribDivisorANGLE)               /* 466 */ \
-  OP(GenMailboxCHROMIUM)                     /* 467 */ \
-  OP(ProduceTextureCHROMIUM)                 /* 468 */ \
-  OP(ProduceTextureCHROMIUMImmediate)        /* 469 */ \
-  OP(ConsumeTextureCHROMIUM)                 /* 470 */ \
-  OP(ConsumeTextureCHROMIUMImmediate)        /* 471 */ \
-  OP(BindUniformLocationCHROMIUM)            /* 472 */ \
-  OP(BindUniformLocationCHROMIUMBucket)      /* 473 */ \
-  OP(BindTexImage2DCHROMIUM)                 /* 474 */ \
-  OP(ReleaseTexImage2DCHROMIUM)              /* 475 */ \
-  OP(TraceBeginCHROMIUM)                     /* 476 */ \
-  OP(TraceEndCHROMIUM)                       /* 477 */ \
-  OP(AsyncTexSubImage2DCHROMIUM)             /* 478 */ \
-  OP(AsyncTexImage2DCHROMIUM)                /* 479 */ \
-  OP(WaitAsyncTexImage2DCHROMIUM)            /* 480 */ \
-  OP(WaitAllAsyncTexImage2DCHROMIUM)         /* 481 */ \
-  OP(DiscardFramebufferEXT)                  /* 482 */ \
-  OP(DiscardFramebufferEXTImmediate)         /* 483 */ \
-  OP(LoseContextCHROMIUM)                    /* 484 */ \
-  OP(InsertSyncPointCHROMIUM)                /* 485 */ \
-  OP(WaitSyncPointCHROMIUM)                  /* 486 */ \
-  OP(DrawBuffersEXT)                         /* 487 */ \
-  OP(DrawBuffersEXTImmediate)                /* 488 */ \
-  OP(DiscardBackbufferCHROMIUM)              /* 489 */ \
-  OP(ScheduleOverlayPlaneCHROMIUM)           /* 490 */
+  OP(DeleteBuffersImmediate)                 /* 287 */ \
+  OP(DeleteFramebuffersImmediate)            /* 288 */ \
+  OP(DeleteProgram)                          /* 289 */ \
+  OP(DeleteRenderbuffersImmediate)           /* 290 */ \
+  OP(DeleteShader)                           /* 291 */ \
+  OP(DeleteTexturesImmediate)                /* 292 */ \
+  OP(DepthFunc)                              /* 293 */ \
+  OP(DepthMask)                              /* 294 */ \
+  OP(DepthRangef)                            /* 295 */ \
+  OP(DetachShader)                           /* 296 */ \
+  OP(Disable)                                /* 297 */ \
+  OP(DisableVertexAttribArray)               /* 298 */ \
+  OP(DrawArrays)                             /* 299 */ \
+  OP(DrawElements)                           /* 300 */ \
+  OP(Enable)                                 /* 301 */ \
+  OP(EnableVertexAttribArray)                /* 302 */ \
+  OP(Finish)                                 /* 303 */ \
+  OP(Flush)                                  /* 304 */ \
+  OP(FramebufferRenderbuffer)                /* 305 */ \
+  OP(FramebufferTexture2D)                   /* 306 */ \
+  OP(FrontFace)                              /* 307 */ \
+  OP(GenBuffersImmediate)                    /* 308 */ \
+  OP(GenerateMipmap)                         /* 309 */ \
+  OP(GenFramebuffersImmediate)               /* 310 */ \
+  OP(GenRenderbuffersImmediate)              /* 311 */ \
+  OP(GenTexturesImmediate)                   /* 312 */ \
+  OP(GetActiveAttrib)                        /* 313 */ \
+  OP(GetActiveUniform)                       /* 314 */ \
+  OP(GetAttachedShaders)                     /* 315 */ \
+  OP(GetAttribLocation)                      /* 316 */ \
+  OP(GetAttribLocationBucket)                /* 317 */ \
+  OP(GetBooleanv)                            /* 318 */ \
+  OP(GetBufferParameteriv)                   /* 319 */ \
+  OP(GetError)                               /* 320 */ \
+  OP(GetFloatv)                              /* 321 */ \
+  OP(GetFramebufferAttachmentParameteriv)    /* 322 */ \
+  OP(GetIntegerv)                            /* 323 */ \
+  OP(GetProgramiv)                           /* 324 */ \
+  OP(GetProgramInfoLog)                      /* 325 */ \
+  OP(GetRenderbufferParameteriv)             /* 326 */ \
+  OP(GetShaderiv)                            /* 327 */ \
+  OP(GetShaderInfoLog)                       /* 328 */ \
+  OP(GetShaderPrecisionFormat)               /* 329 */ \
+  OP(GetShaderSource)                        /* 330 */ \
+  OP(GetString)                              /* 331 */ \
+  OP(GetTexParameterfv)                      /* 332 */ \
+  OP(GetTexParameteriv)                      /* 333 */ \
+  OP(GetUniformfv)                           /* 334 */ \
+  OP(GetUniformiv)                           /* 335 */ \
+  OP(GetUniformLocation)                     /* 336 */ \
+  OP(GetUniformLocationBucket)               /* 337 */ \
+  OP(GetVertexAttribfv)                      /* 338 */ \
+  OP(GetVertexAttribiv)                      /* 339 */ \
+  OP(GetVertexAttribPointerv)                /* 340 */ \
+  OP(Hint)                                   /* 341 */ \
+  OP(IsBuffer)                               /* 342 */ \
+  OP(IsEnabled)                              /* 343 */ \
+  OP(IsFramebuffer)                          /* 344 */ \
+  OP(IsProgram)                              /* 345 */ \
+  OP(IsRenderbuffer)                         /* 346 */ \
+  OP(IsShader)                               /* 347 */ \
+  OP(IsTexture)                              /* 348 */ \
+  OP(LineWidth)                              /* 349 */ \
+  OP(LinkProgram)                            /* 350 */ \
+  OP(PixelStorei)                            /* 351 */ \
+  OP(PolygonOffset)                          /* 352 */ \
+  OP(ReadPixels)                             /* 353 */ \
+  OP(ReleaseShaderCompiler)                  /* 354 */ \
+  OP(RenderbufferStorage)                    /* 355 */ \
+  OP(SampleCoverage)                         /* 356 */ \
+  OP(Scissor)                                /* 357 */ \
+  OP(ShaderBinary)                           /* 358 */ \
+  OP(ShaderSource)                           /* 359 */ \
+  OP(ShaderSourceBucket)                     /* 360 */ \
+  OP(StencilFunc)                            /* 361 */ \
+  OP(StencilFuncSeparate)                    /* 362 */ \
+  OP(StencilMask)                            /* 363 */ \
+  OP(StencilMaskSeparate)                    /* 364 */ \
+  OP(StencilOp)                              /* 365 */ \
+  OP(StencilOpSeparate)                      /* 366 */ \
+  OP(TexImage2D)                             /* 367 */ \
+  OP(TexParameterf)                          /* 368 */ \
+  OP(TexParameterfvImmediate)                /* 369 */ \
+  OP(TexParameteri)                          /* 370 */ \
+  OP(TexParameterivImmediate)                /* 371 */ \
+  OP(TexSubImage2D)                          /* 372 */ \
+  OP(Uniform1f)                              /* 373 */ \
+  OP(Uniform1fvImmediate)                    /* 374 */ \
+  OP(Uniform1i)                              /* 375 */ \
+  OP(Uniform1ivImmediate)                    /* 376 */ \
+  OP(Uniform2f)                              /* 377 */ \
+  OP(Uniform2fvImmediate)                    /* 378 */ \
+  OP(Uniform2i)                              /* 379 */ \
+  OP(Uniform2ivImmediate)                    /* 380 */ \
+  OP(Uniform3f)                              /* 381 */ \
+  OP(Uniform3fvImmediate)                    /* 382 */ \
+  OP(Uniform3i)                              /* 383 */ \
+  OP(Uniform3ivImmediate)                    /* 384 */ \
+  OP(Uniform4f)                              /* 385 */ \
+  OP(Uniform4fvImmediate)                    /* 386 */ \
+  OP(Uniform4i)                              /* 387 */ \
+  OP(Uniform4ivImmediate)                    /* 388 */ \
+  OP(UniformMatrix2fvImmediate)              /* 389 */ \
+  OP(UniformMatrix3fvImmediate)              /* 390 */ \
+  OP(UniformMatrix4fvImmediate)              /* 391 */ \
+  OP(UseProgram)                             /* 392 */ \
+  OP(ValidateProgram)                        /* 393 */ \
+  OP(VertexAttrib1f)                         /* 394 */ \
+  OP(VertexAttrib1fvImmediate)               /* 395 */ \
+  OP(VertexAttrib2f)                         /* 396 */ \
+  OP(VertexAttrib2fvImmediate)               /* 397 */ \
+  OP(VertexAttrib3f)                         /* 398 */ \
+  OP(VertexAttrib3fvImmediate)               /* 399 */ \
+  OP(VertexAttrib4f)                         /* 400 */ \
+  OP(VertexAttrib4fvImmediate)               /* 401 */ \
+  OP(VertexAttribPointer)                    /* 402 */ \
+  OP(Viewport)                               /* 403 */ \
+  OP(BlitFramebufferCHROMIUM)                /* 404 */ \
+  OP(RenderbufferStorageMultisampleCHROMIUM) /* 405 */ \
+  OP(RenderbufferStorageMultisampleEXT)      /* 406 */ \
+  OP(FramebufferTexture2DMultisampleEXT)     /* 407 */ \
+  OP(TexStorage2DEXT)                        /* 408 */ \
+  OP(GenQueriesEXTImmediate)                 /* 409 */ \
+  OP(DeleteQueriesEXTImmediate)              /* 410 */ \
+  OP(BeginQueryEXT)                          /* 411 */ \
+  OP(EndQueryEXT)                            /* 412 */ \
+  OP(InsertEventMarkerEXT)                   /* 413 */ \
+  OP(PushGroupMarkerEXT)                     /* 414 */ \
+  OP(PopGroupMarkerEXT)                      /* 415 */ \
+  OP(GenVertexArraysOESImmediate)            /* 416 */ \
+  OP(DeleteVertexArraysOESImmediate)         /* 417 */ \
+  OP(IsVertexArrayOES)                       /* 418 */ \
+  OP(BindVertexArrayOES)                     /* 419 */ \
+  OP(SwapBuffers)                            /* 420 */ \
+  OP(GetMaxValueInBufferCHROMIUM)            /* 421 */ \
+  OP(GenSharedIdsCHROMIUM)                   /* 422 */ \
+  OP(DeleteSharedIdsCHROMIUM)                /* 423 */ \
+  OP(RegisterSharedIdsCHROMIUM)              /* 424 */ \
+  OP(EnableFeatureCHROMIUM)                  /* 425 */ \
+  OP(ResizeCHROMIUM)                         /* 426 */ \
+  OP(GetRequestableExtensionsCHROMIUM)       /* 427 */ \
+  OP(RequestExtensionCHROMIUM)               /* 428 */ \
+  OP(GetMultipleIntegervCHROMIUM)            /* 429 */ \
+  OP(GetProgramInfoCHROMIUM)                 /* 430 */ \
+  OP(GetTranslatedShaderSourceANGLE)         /* 431 */ \
+  OP(PostSubBufferCHROMIUM)                  /* 432 */ \
+  OP(TexImageIOSurface2DCHROMIUM)            /* 433 */ \
+  OP(CopyTextureCHROMIUM)                    /* 434 */ \
+  OP(DrawArraysInstancedANGLE)               /* 435 */ \
+  OP(DrawElementsInstancedANGLE)             /* 436 */ \
+  OP(VertexAttribDivisorANGLE)               /* 437 */ \
+  OP(GenMailboxCHROMIUM)                     /* 438 */ \
+  OP(ProduceTextureCHROMIUMImmediate)        /* 439 */ \
+  OP(ConsumeTextureCHROMIUMImmediate)        /* 440 */ \
+  OP(BindUniformLocationCHROMIUM)            /* 441 */ \
+  OP(BindUniformLocationCHROMIUMBucket)      /* 442 */ \
+  OP(BindTexImage2DCHROMIUM)                 /* 443 */ \
+  OP(ReleaseTexImage2DCHROMIUM)              /* 444 */ \
+  OP(TraceBeginCHROMIUM)                     /* 445 */ \
+  OP(TraceEndCHROMIUM)                       /* 446 */ \
+  OP(AsyncTexSubImage2DCHROMIUM)             /* 447 */ \
+  OP(AsyncTexImage2DCHROMIUM)                /* 448 */ \
+  OP(WaitAsyncTexImage2DCHROMIUM)            /* 449 */ \
+  OP(WaitAllAsyncTexImage2DCHROMIUM)         /* 450 */ \
+  OP(DiscardFramebufferEXTImmediate)         /* 451 */ \
+  OP(LoseContextCHROMIUM)                    /* 452 */ \
+  OP(InsertSyncPointCHROMIUM)                /* 453 */ \
+  OP(WaitSyncPointCHROMIUM)                  /* 454 */ \
+  OP(DrawBuffersEXTImmediate)                /* 455 */ \
+  OP(DiscardBackbufferCHROMIUM)              /* 456 */ \
+  OP(ScheduleOverlayPlaneCHROMIUM)           /* 457 */
 
 enum CommandId {
   kStartPoint = cmd::kLastCommonId,  // All GLES2 commands start after this.
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index b9a007a..edf5a57 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -475,23 +475,6 @@ error::Error GLES2DecoderImpl::HandleCullFace(uint32_t immediate_data_size,
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteBuffers(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DeleteBuffers& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLuint* buffers = GetSharedMemoryAs<const GLuint*>(
-      c.buffers_shm_id, c.buffers_shm_offset, data_size);
-  if (buffers == NULL) {
-    return error::kOutOfBounds;
-  }
-  DeleteBuffersHelper(n, buffers);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DeleteBuffersImmediate& c) {
@@ -509,23 +492,6 @@ error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteFramebuffers(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DeleteFramebuffers& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>(
-      c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
-  if (framebuffers == NULL) {
-    return error::kOutOfBounds;
-  }
-  DeleteFramebuffersHelper(n, framebuffers);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DeleteFramebuffersImmediate& c) {
@@ -543,23 +509,6 @@ error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteRenderbuffers(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DeleteRenderbuffers& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>(
-      c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
-  if (renderbuffers == NULL) {
-    return error::kOutOfBounds;
-  }
-  DeleteRenderbuffersHelper(n, renderbuffers);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DeleteRenderbuffersImmediate& c) {
@@ -577,23 +526,6 @@ error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteTextures(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DeleteTextures& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLuint* textures = GetSharedMemoryAs<const GLuint*>(
-      c.textures_shm_id, c.textures_shm_offset, data_size);
-  if (textures == NULL) {
-    return error::kOutOfBounds;
-  }
-  DeleteTexturesHelper(n, textures);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DeleteTexturesImmediate& c) {
@@ -777,25 +709,6 @@ error::Error GLES2DecoderImpl::HandleFrontFace(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGenBuffers(
-    uint32_t immediate_data_size,
-    const gles2::cmds::GenBuffers& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  GLuint* buffers = GetSharedMemoryAs<GLuint*>(
-      c.buffers_shm_id, c.buffers_shm_offset, data_size);
-  if (buffers == NULL) {
-    return error::kOutOfBounds;
-  }
-  if (!GenBuffersHelper(n, buffers)) {
-    return error::kInvalidArguments;
-  }
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::GenBuffersImmediate& c) {
@@ -827,25 +740,6 @@ error::Error GLES2DecoderImpl::HandleGenerateMipmap(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGenFramebuffers(
-    uint32_t immediate_data_size,
-    const gles2::cmds::GenFramebuffers& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  GLuint* framebuffers = GetSharedMemoryAs<GLuint*>(
-      c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
-  if (framebuffers == NULL) {
-    return error::kOutOfBounds;
-  }
-  if (!GenFramebuffersHelper(n, framebuffers)) {
-    return error::kInvalidArguments;
-  }
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::GenFramebuffersImmediate& c) {
@@ -865,25 +759,6 @@ error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGenRenderbuffers(
-    uint32_t immediate_data_size,
-    const gles2::cmds::GenRenderbuffers& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>(
-      c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
-  if (renderbuffers == NULL) {
-    return error::kOutOfBounds;
-  }
-  if (!GenRenderbuffersHelper(n, renderbuffers)) {
-    return error::kInvalidArguments;
-  }
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::GenRenderbuffersImmediate& c) {
@@ -903,25 +778,6 @@ error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGenTextures(
-    uint32_t immediate_data_size,
-    const gles2::cmds::GenTextures& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  GLuint* textures = GetSharedMemoryAs<GLuint*>(
-      c.textures_shm_id, c.textures_shm_offset, data_size);
-  if (textures == NULL) {
-    return error::kOutOfBounds;
-  }
-  if (!GenTexturesHelper(n, textures)) {
-    return error::kInvalidArguments;
-  }
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::GenTexturesImmediate& c) {
@@ -1816,32 +1672,6 @@ error::Error GLES2DecoderImpl::HandleTexParameterf(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleTexParameterfv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::TexParameterfv& c) {
-  GLenum target = static_cast<GLenum>(c.target);
-  GLenum pname = static_cast<GLenum>(c.pname);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* params = GetSharedMemoryAs<const GLfloat*>(
-      c.params_shm_id, c.params_shm_offset, data_size);
-  if (!validators_->texture_bind_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", target, "target");
-    return error::kNoError;
-  }
-  if (!validators_->texture_parameter.IsValid(pname)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameterfv", pname, "pname");
-    return error::kNoError;
-  }
-  if (params == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoTexParameterfv(target, pname, params);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleTexParameterfvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::TexParameterfvImmediate& c) {
@@ -1889,32 +1719,6 @@ error::Error GLES2DecoderImpl::HandleTexParameteri(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleTexParameteriv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::TexParameteriv& c) {
-  GLenum target = static_cast<GLenum>(c.target);
-  GLenum pname = static_cast<GLenum>(c.pname);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLint), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLint* params = GetSharedMemoryAs<const GLint*>(
-      c.params_shm_id, c.params_shm_offset, data_size);
-  if (!validators_->texture_bind_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", target, "target");
-    return error::kNoError;
-  }
-  if (!validators_->texture_parameter.IsValid(pname)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM("glTexParameteriv", pname, "pname");
-    return error::kNoError;
-  }
-  if (params == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoTexParameteriv(target, pname, params);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleTexParameterivImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::TexParameterivImmediate& c) {
@@ -1956,24 +1760,6 @@ error::Error GLES2DecoderImpl::HandleUniform1f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform1fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform1fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* v =
-      GetSharedMemoryAs<const GLfloat*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform1fv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform1fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform1fvImmediate& c) {
@@ -2004,24 +1790,6 @@ error::Error GLES2DecoderImpl::HandleUniform1i(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform1iv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform1iv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLint), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLint* v =
-      GetSharedMemoryAs<const GLint*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform1iv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform1ivImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform1ivImmediate& c) {
@@ -2056,24 +1824,6 @@ error::Error GLES2DecoderImpl::HandleUniform2f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform2fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform2fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 2, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* v =
-      GetSharedMemoryAs<const GLfloat*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform2fv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform2fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform2fvImmediate& c) {
@@ -2108,24 +1858,6 @@ error::Error GLES2DecoderImpl::HandleUniform2i(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform2iv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform2iv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLint), 2, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLint* v =
-      GetSharedMemoryAs<const GLint*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform2iv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform2ivImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform2ivImmediate& c) {
@@ -2161,24 +1893,6 @@ error::Error GLES2DecoderImpl::HandleUniform3f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform3fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform3fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 3, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* v =
-      GetSharedMemoryAs<const GLfloat*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform3fv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform3fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform3fvImmediate& c) {
@@ -2214,24 +1928,6 @@ error::Error GLES2DecoderImpl::HandleUniform3i(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform3iv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform3iv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLint), 3, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLint* v =
-      GetSharedMemoryAs<const GLint*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform3iv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform3ivImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform3ivImmediate& c) {
@@ -2268,24 +1964,6 @@ error::Error GLES2DecoderImpl::HandleUniform4f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform4fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform4fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* v =
-      GetSharedMemoryAs<const GLfloat*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform4fv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform4fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform4fvImmediate& c) {
@@ -2322,24 +2000,6 @@ error::Error GLES2DecoderImpl::HandleUniform4i(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniform4iv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::Uniform4iv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLint), 4, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLint* v =
-      GetSharedMemoryAs<const GLint*>(c.v_shm_id, c.v_shm_offset, data_size);
-  if (v == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniform4iv(location, count, v);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::Uniform4ivImmediate& c) {
@@ -2361,25 +2021,6 @@ error::Error GLES2DecoderImpl::HandleUniform4ivImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniformMatrix2fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::UniformMatrix2fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  GLboolean transpose = static_cast<GLboolean>(c.transpose);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 4, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
-      c.value_shm_id, c.value_shm_offset, data_size);
-  if (value == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniformMatrix2fv(location, count, transpose, value);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::UniformMatrix2fvImmediate& c) {
@@ -2402,25 +2043,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniformMatrix3fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::UniformMatrix3fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  GLboolean transpose = static_cast<GLboolean>(c.transpose);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 9, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
-      c.value_shm_id, c.value_shm_offset, data_size);
-  if (value == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniformMatrix3fv(location, count, transpose, value);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::UniformMatrix3fvImmediate& c) {
@@ -2443,25 +2065,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleUniformMatrix4fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::UniformMatrix4fv& c) {
-  GLint location = static_cast<GLint>(c.location);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  GLboolean transpose = static_cast<GLboolean>(c.transpose);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLfloat), 16, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
-      c.value_shm_id, c.value_shm_offset, data_size);
-  if (value == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoUniformMatrix4fv(location, count, transpose, value);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::UniformMatrix4fvImmediate& c) {
@@ -2509,23 +2112,6 @@ error::Error GLES2DecoderImpl::HandleVertexAttrib1f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleVertexAttrib1fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::VertexAttrib1fv& c) {
-  GLuint indx = static_cast<GLuint>(c.indx);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLfloat), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
-      c.values_shm_id, c.values_shm_offset, data_size);
-  if (values == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoVertexAttrib1fv(indx, values);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleVertexAttrib1fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::VertexAttrib1fvImmediate& c) {
@@ -2556,23 +2142,6 @@ error::Error GLES2DecoderImpl::HandleVertexAttrib2f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleVertexAttrib2fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::VertexAttrib2fv& c) {
-  GLuint indx = static_cast<GLuint>(c.indx);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLfloat), 2, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
-      c.values_shm_id, c.values_shm_offset, data_size);
-  if (values == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoVertexAttrib2fv(indx, values);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleVertexAttrib2fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::VertexAttrib2fvImmediate& c) {
@@ -2604,23 +2173,6 @@ error::Error GLES2DecoderImpl::HandleVertexAttrib3f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleVertexAttrib3fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::VertexAttrib3fv& c) {
-  GLuint indx = static_cast<GLuint>(c.indx);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLfloat), 3, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
-      c.values_shm_id, c.values_shm_offset, data_size);
-  if (values == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoVertexAttrib3fv(indx, values);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleVertexAttrib3fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::VertexAttrib3fvImmediate& c) {
@@ -2653,23 +2205,6 @@ error::Error GLES2DecoderImpl::HandleVertexAttrib4f(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleVertexAttrib4fv(
-    uint32_t immediate_data_size,
-    const gles2::cmds::VertexAttrib4fv& c) {
-  GLuint indx = static_cast<GLuint>(c.indx);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLfloat), 4, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLfloat* values = GetSharedMemoryAs<const GLfloat*>(
-      c.values_shm_id, c.values_shm_offset, data_size);
-  if (values == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoVertexAttrib4fv(indx, values);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleVertexAttrib4fvImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::VertexAttrib4fvImmediate& c) {
@@ -2915,25 +2450,6 @@ error::Error GLES2DecoderImpl::HandleTexStorage2DEXT(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGenQueriesEXT(
-    uint32_t immediate_data_size,
-    const gles2::cmds::GenQueriesEXT& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  GLuint* queries = GetSharedMemoryAs<GLuint*>(
-      c.queries_shm_id, c.queries_shm_offset, data_size);
-  if (queries == NULL) {
-    return error::kOutOfBounds;
-  }
-  if (!GenQueriesEXTHelper(n, queries)) {
-    return error::kInvalidArguments;
-  }
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGenQueriesEXTImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::GenQueriesEXTImmediate& c) {
@@ -2953,23 +2469,6 @@ error::Error GLES2DecoderImpl::HandleGenQueriesEXTImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteQueriesEXT(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DeleteQueriesEXT& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLuint* queries = GetSharedMemoryAs<const GLuint*>(
-      c.queries_shm_id, c.queries_shm_offset, data_size);
-  if (queries == NULL) {
-    return error::kOutOfBounds;
-  }
-  DeleteQueriesEXTHelper(n, queries);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDeleteQueriesEXTImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DeleteQueriesEXTImmediate& c) {
@@ -3026,25 +2525,6 @@ error::Error GLES2DecoderImpl::HandlePopGroupMarkerEXT(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGenVertexArraysOES(
-    uint32_t immediate_data_size,
-    const gles2::cmds::GenVertexArraysOES& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  GLuint* arrays = GetSharedMemoryAs<GLuint*>(
-      c.arrays_shm_id, c.arrays_shm_offset, data_size);
-  if (arrays == NULL) {
-    return error::kOutOfBounds;
-  }
-  if (!GenVertexArraysOESHelper(n, arrays)) {
-    return error::kInvalidArguments;
-  }
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGenVertexArraysOESImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::GenVertexArraysOESImmediate& c) {
@@ -3064,23 +2544,6 @@ error::Error GLES2DecoderImpl::HandleGenVertexArraysOESImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOES(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DeleteVertexArraysOES& c) {
-  GLsizei n = static_cast<GLsizei>(c.n);
-  uint32_t data_size;
-  if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLuint* arrays = GetSharedMemoryAs<const GLuint*>(
-      c.arrays_shm_id, c.arrays_shm_offset, data_size);
-  if (arrays == NULL) {
-    return error::kOutOfBounds;
-  }
-  DeleteVertexArraysOESHelper(n, arrays);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDeleteVertexArraysOESImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DeleteVertexArraysOESImmediate& c) {
@@ -3206,28 +2669,6 @@ error::Error GLES2DecoderImpl::HandleCopyTextureCHROMIUM(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUM(
-    uint32_t immediate_data_size,
-    const gles2::cmds::ProduceTextureCHROMIUM& c) {
-  GLenum target = static_cast<GLenum>(c.target);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
-      c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
-  if (!validators_->texture_bind_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(
-        "glProduceTextureCHROMIUM", target, "target");
-    return error::kNoError;
-  }
-  if (mailbox == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoProduceTextureCHROMIUM(target, mailbox);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUMImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::ProduceTextureCHROMIUMImmediate& c) {
@@ -3253,28 +2694,6 @@ error::Error GLES2DecoderImpl::HandleProduceTextureCHROMIUMImmediate(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUM(
-    uint32_t immediate_data_size,
-    const gles2::cmds::ConsumeTextureCHROMIUM& c) {
-  GLenum target = static_cast<GLenum>(c.target);
-  uint32_t data_size;
-  if (!ComputeDataSize(1, sizeof(GLbyte), 64, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLbyte* mailbox = GetSharedMemoryAs<const GLbyte*>(
-      c.mailbox_shm_id, c.mailbox_shm_offset, data_size);
-  if (!validators_->texture_bind_target.IsValid(target)) {
-    LOCAL_SET_GL_ERROR_INVALID_ENUM(
-        "glConsumeTextureCHROMIUM", target, "target");
-    return error::kNoError;
-  }
-  if (mailbox == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoConsumeTextureCHROMIUM(target, mailbox);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleConsumeTextureCHROMIUMImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::ConsumeTextureCHROMIUMImmediate& c) {
@@ -3335,36 +2754,6 @@ error::Error GLES2DecoderImpl::HandleTraceEndCHROMIUM(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXT(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DiscardFramebufferEXT& c) {
-  if (!features().ext_discard_framebuffer) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
-                       "glDiscardFramebufferEXT",
-                       "function not available");
-    return error::kNoError;
-  }
-
-  GLenum target = static_cast<GLenum>(c.target);
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLenum* attachments = GetSharedMemoryAs<const GLenum*>(
-      c.attachments_shm_id, c.attachments_shm_offset, data_size);
-  if (count < 0) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glDiscardFramebufferEXT", "count < 0");
-    return error::kNoError;
-  }
-  if (attachments == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoDiscardFramebufferEXT(target, count, attachments);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDiscardFramebufferEXTImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DiscardFramebufferEXTImmediate& c) {
@@ -3416,27 +2805,6 @@ error::Error GLES2DecoderImpl::HandleLoseContextCHROMIUM(
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDrawBuffersEXT(
-    uint32_t immediate_data_size,
-    const gles2::cmds::DrawBuffersEXT& c) {
-  GLsizei count = static_cast<GLsizei>(c.count);
-  uint32_t data_size;
-  if (!ComputeDataSize(count, sizeof(GLenum), 1, &data_size)) {
-    return error::kOutOfBounds;
-  }
-  const GLenum* bufs = GetSharedMemoryAs<const GLenum*>(
-      c.bufs_shm_id, c.bufs_shm_offset, data_size);
-  if (count < 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDrawBuffersEXT", "count < 0");
-    return error::kNoError;
-  }
-  if (bufs == NULL) {
-    return error::kOutOfBounds;
-  }
-  DoDrawBuffersEXT(count, bufs);
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleDrawBuffersEXTImmediate(
     uint32_t immediate_data_size,
     const gles2::cmds::DrawBuffersEXTImmediate& c) {
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 cdbf351d..8d605c5 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
@@ -431,25 +431,6 @@ TEST_P(GLES2DecoderTest1, CullFaceValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DeleteBuffersValidArgs) {
-  EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(kServiceBufferId))).Times(1);
-  GetSharedMemoryAs<GLuint*>()[0] = client_buffer_id_;
-  SpecializedSetup<cmds::DeleteBuffers, 0>(true);
-  cmds::DeleteBuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetBuffer(client_buffer_id_) == NULL);
-}
-
-TEST_P(GLES2DecoderTest1, DeleteBuffersInvalidArgs) {
-  GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
-  SpecializedSetup<cmds::DeleteBuffers, 0>(false);
-  cmds::DeleteBuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(kServiceBufferId))).Times(1);
   cmds::DeleteBuffersImmediate& cmd =
@@ -471,26 +452,6 @@ TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteFramebuffersValidArgs) {
-  EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(kServiceFramebufferId)))
-      .Times(1);
-  GetSharedMemoryAs<GLuint*>()[0] = client_framebuffer_id_;
-  SpecializedSetup<cmds::DeleteFramebuffers, 0>(true);
-  cmds::DeleteFramebuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetFramebuffer(client_framebuffer_id_) == NULL);
-}
-
-TEST_P(GLES2DecoderTest1, DeleteFramebuffersInvalidArgs) {
-  GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
-  SpecializedSetup<cmds::DeleteFramebuffers, 0>(false);
-  cmds::DeleteFramebuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(kServiceFramebufferId)))
       .Times(1);
@@ -522,26 +483,6 @@ TEST_P(GLES2DecoderTest1, DeleteProgramValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DeleteRenderbuffersValidArgs) {
-  EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(kServiceRenderbufferId)))
-      .Times(1);
-  GetSharedMemoryAs<GLuint*>()[0] = client_renderbuffer_id_;
-  SpecializedSetup<cmds::DeleteRenderbuffers, 0>(true);
-  cmds::DeleteRenderbuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetRenderbuffer(client_renderbuffer_id_) == NULL);
-}
-
-TEST_P(GLES2DecoderTest1, DeleteRenderbuffersInvalidArgs) {
-  GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
-  SpecializedSetup<cmds::DeleteRenderbuffers, 0>(false);
-  cmds::DeleteRenderbuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(kServiceRenderbufferId)))
       .Times(1);
@@ -573,25 +514,6 @@ TEST_P(GLES2DecoderTest1, DeleteShaderValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DeleteTexturesValidArgs) {
-  EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(kServiceTextureId))).Times(1);
-  GetSharedMemoryAs<GLuint*>()[0] = client_texture_id_;
-  SpecializedSetup<cmds::DeleteTextures, 0>(true);
-  cmds::DeleteTextures cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetTexture(client_texture_id_) == NULL);
-}
-
-TEST_P(GLES2DecoderTest1, DeleteTexturesInvalidArgs) {
-  GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
-  SpecializedSetup<cmds::DeleteTextures, 0>(false);
-  cmds::DeleteTextures cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(kServiceTextureId))).Times(1);
   cmds::DeleteTexturesImmediate& cmd =
@@ -853,27 +775,6 @@ TEST_P(GLES2DecoderTest1, FrontFaceValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GenBuffersValidArgs) {
-  EXPECT_CALL(*gl_, GenBuffersARB(1, _))
-      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
-  SpecializedSetup<cmds::GenBuffers, 0>(true);
-  cmds::GenBuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
-}
-
-TEST_P(GLES2DecoderTest1, GenBuffersInvalidArgs) {
-  EXPECT_CALL(*gl_, GenBuffersARB(_, _)).Times(0);
-  GetSharedMemoryAs<GLuint*>()[0] = client_buffer_id_;
-  SpecializedSetup<cmds::GenBuffers, 0>(false);
-  cmds::GenBuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, GenBuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -922,27 +823,6 @@ TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GenFramebuffersValidArgs) {
-  EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
-      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
-  SpecializedSetup<cmds::GenFramebuffers, 0>(true);
-  cmds::GenFramebuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetFramebuffer(kNewClientId) != NULL);
-}
-
-TEST_P(GLES2DecoderTest1, GenFramebuffersInvalidArgs) {
-  EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _)).Times(0);
-  GetSharedMemoryAs<GLuint*>()[0] = client_framebuffer_id_;
-  SpecializedSetup<cmds::GenFramebuffers, 0>(false);
-  cmds::GenFramebuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -966,27 +846,6 @@ TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateInvalidArgs) {
             ExecuteImmediateCmd(*cmd, sizeof(&client_framebuffer_id_)));
 }
 
-TEST_P(GLES2DecoderTest1, GenRenderbuffersValidArgs) {
-  EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
-      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
-  SpecializedSetup<cmds::GenRenderbuffers, 0>(true);
-  cmds::GenRenderbuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetRenderbuffer(kNewClientId) != NULL);
-}
-
-TEST_P(GLES2DecoderTest1, GenRenderbuffersInvalidArgs) {
-  EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _)).Times(0);
-  GetSharedMemoryAs<GLuint*>()[0] = client_renderbuffer_id_;
-  SpecializedSetup<cmds::GenRenderbuffers, 0>(false);
-  cmds::GenRenderbuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -1010,27 +869,6 @@ TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateInvalidArgs) {
             ExecuteImmediateCmd(*cmd, sizeof(&client_renderbuffer_id_)));
 }
 
-TEST_P(GLES2DecoderTest1, GenTexturesValidArgs) {
-  EXPECT_CALL(*gl_, GenTextures(1, _))
-      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
-  SpecializedSetup<cmds::GenTextures, 0>(true);
-  cmds::GenTextures cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
-}
-
-TEST_P(GLES2DecoderTest1, GenTexturesInvalidArgs) {
-  EXPECT_CALL(*gl_, GenTextures(_, _)).Times(0);
-  GetSharedMemoryAs<GLuint*>()[0] = client_texture_id_;
-  SpecializedSetup<cmds::GenTextures, 0>(false);
-  cmds::GenTextures cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest1, GenTexturesImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -1984,4 +1822,95 @@ TEST_P(GLES2DecoderTest1, IsProgramInvalidArgsBadSharedMemoryId) {
   cmd.Init(client_program_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
+
+TEST_P(GLES2DecoderTest1, IsRenderbufferValidArgs) {
+  SpecializedSetup<cmds::IsRenderbuffer, 0>(true);
+  cmds::IsRenderbuffer cmd;
+  cmd.Init(client_renderbuffer_id_, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_P(GLES2DecoderTest1, IsRenderbufferInvalidArgsBadSharedMemoryId) {
+  SpecializedSetup<cmds::IsRenderbuffer, 0>(false);
+  cmds::IsRenderbuffer cmd;
+  cmd.Init(
+      client_renderbuffer_id_, kInvalidSharedMemoryId, shared_memory_offset_);
+  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
+  cmd.Init(
+      client_renderbuffer_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
+  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
+}
+
+TEST_P(GLES2DecoderTest1, IsShaderValidArgs) {
+  SpecializedSetup<cmds::IsShader, 0>(true);
+  cmds::IsShader cmd;
+  cmd.Init(client_shader_id_, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_P(GLES2DecoderTest1, IsShaderInvalidArgsBadSharedMemoryId) {
+  SpecializedSetup<cmds::IsShader, 0>(false);
+  cmds::IsShader cmd;
+  cmd.Init(client_shader_id_, kInvalidSharedMemoryId, shared_memory_offset_);
+  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
+  cmd.Init(client_shader_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
+  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
+}
+
+TEST_P(GLES2DecoderTest1, IsTextureValidArgs) {
+  SpecializedSetup<cmds::IsTexture, 0>(true);
+  cmds::IsTexture cmd;
+  cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_P(GLES2DecoderTest1, IsTextureInvalidArgsBadSharedMemoryId) {
+  SpecializedSetup<cmds::IsTexture, 0>(false);
+  cmds::IsTexture cmd;
+  cmd.Init(client_texture_id_, kInvalidSharedMemoryId, shared_memory_offset_);
+  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
+  cmd.Init(client_texture_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
+  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
+}
+
+TEST_P(GLES2DecoderTest1, LineWidthValidArgs) {
+  EXPECT_CALL(*gl_, LineWidth(0.5f));
+  SpecializedSetup<cmds::LineWidth, 0>(true);
+  cmds::LineWidth cmd;
+  cmd.Init(0.5f);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+
+TEST_P(GLES2DecoderTest1, LineWidthInvalidValue0_0) {
+  SpecializedSetup<cmds::LineWidth, 0>(false);
+  cmds::LineWidth cmd;
+  cmd.Init(0.0f);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
+}
+
+TEST_P(GLES2DecoderTest1, LinkProgramValidArgs) {
+  EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId));
+  SpecializedSetup<cmds::LinkProgram, 0>(true);
+  cmds::LinkProgram cmd;
+  cmd.Init(client_program_id_);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+// TODO(gman): PixelStorei
+
+TEST_P(GLES2DecoderTest1, PolygonOffsetValidArgs) {
+  EXPECT_CALL(*gl_, PolygonOffset(1, 2));
+  SpecializedSetup<cmds::PolygonOffset, 0>(true);
+  cmds::PolygonOffset cmd;
+  cmd.Init(1, 2);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+}
+// TODO(gman): ReadPixels
+
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_1_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
index a16b298..de52efe 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
@@ -61,9 +61,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform1i;
-      cmds::Uniform1iv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform1ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform1ivImmediate>();
+      GLint data[2][1] = {{0}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -79,9 +81,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform2i;
-      cmds::Uniform2iv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform2ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform2ivImmediate>();
+      GLint data[2][2] = {{0}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -97,9 +101,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform3i;
-      cmds::Uniform3iv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform3ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform3ivImmediate>();
+      GLint data[2][3] = {{0}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -115,9 +121,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform4i;
-      cmds::Uniform4iv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform4ivImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform4ivImmediate>();
+      GLint data[2][4] = {{0}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -135,9 +143,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform1f;
-      cmds::Uniform1fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform1fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform1fvImmediate>();
+      GLfloat data[2][1] = {{0.0f}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -153,9 +163,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform2f;
-      cmds::Uniform2fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform2fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform2fvImmediate>();
+      GLfloat data[2][2] = {{0.0f}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -171,9 +183,11 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform3f;
-      cmds::Uniform3fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform3fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform3fvImmediate>();
+      GLfloat data[2][3] = {{0.0f}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -189,36 +203,45 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 
     {
       valid_uniform = accepts_apis & Program::kUniform4f;
-      cmds::Uniform4fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::Uniform4fvImmediate& cmd =
+          *GetImmediateAs<cmds::Uniform4fvImmediate>();
+      GLfloat data[2][4] = {{0.0f}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix2f;
-      cmds::UniformMatrix2fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::UniformMatrix2fvImmediate& cmd =
+          *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
+      GLfloat data[2][2 * 2] = {{0.0f}};
+
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix3f;
-      cmds::UniformMatrix3fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::UniformMatrix3fvImmediate& cmd =
+          *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
+      GLfloat data[2][3 * 3] = {{0.0f}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
 
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix4f;
-      cmds::UniformMatrix4fv cmd;
-      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+      cmds::UniformMatrix4fvImmediate& cmd =
+          *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
+      GLfloat data[2][4 * 4] = {{0.0f}};
+      cmd.Init(1, 2, &data[0][0]);
+      EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
     }
@@ -228,40 +251,16 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest2, ::testing::Bool());
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXT, 0>(
-    bool valid) {
-  if (!valid) {
-    // Make the client_query_id_ so that trying to make it again
-    // will fail.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  }
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXTImmediate, 0>(
     bool valid) {
   if (!valid) {
     // Make the client_query_id_ so that trying to make it again
     // will fail.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  }
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXT, 0>(
-    bool valid) {
-  if (valid) {
-    // Make the client_query_id_ so that trying to delete it will succeed.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+    cmds::GenQueriesEXTImmediate& cmd =
+        *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
+    cmd.Init(1, &client_query_id_);
+    EXPECT_EQ(error::kNoError,
+              ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
   }
 };
 
@@ -270,10 +269,11 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>(
     bool valid) {
   if (valid) {
     // Make the client_query_id_ so that trying to delete it will succeed.
-    GetSharedMemoryAs<GLuint*>()[0] = client_query_id_;
-    cmds::GenQueriesEXT cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+    cmds::GenQueriesEXTImmediate& cmd =
+        *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
+    cmd.Init(1, &client_query_id_);
+    EXPECT_EQ(error::kNoError,
+              ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
   }
 };
 
@@ -370,24 +370,12 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1f, 0>(
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1ivImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_INT);
@@ -406,18 +394,6 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2i, 0>(
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_VEC2);
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT_VEC2);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC2);
@@ -442,18 +418,6 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3i, 0>(
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_VEC3);
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT_VEC3);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC3);
@@ -478,18 +442,6 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4i, 0>(
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_VEC4);
-};
-
-template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4iv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_INT_VEC4);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_VEC4);
@@ -502,36 +454,18 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4ivImmediate, 0>(
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_MAT2);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_MAT2);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix3fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_MAT3);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_MAT3);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix4fv, 0>(
-    bool /* valid */) {
-  SetupShaderForUniform(GL_FLOAT_MAT4);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>(
     bool /* valid */) {
   SetupShaderForUniform(GL_FLOAT_MAT4);
@@ -569,24 +503,12 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteri, 0>(
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfv, 0>(
-    bool /* valid */) {
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfvImmediate, 0>(
     bool /* valid */) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 };
 
 template <>
-void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteriv, 0>(
-    bool /* valid */) {
-  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-};
-
-template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
     bool /* valid */) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
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 4a46d7d..80dc8f7 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
@@ -12,96 +12,6 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
 
-TEST_P(GLES2DecoderTest2, IsRenderbufferValidArgs) {
-  SpecializedSetup<cmds::IsRenderbuffer, 0>(true);
-  cmds::IsRenderbuffer cmd;
-  cmd.Init(client_renderbuffer_id_, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, IsRenderbufferInvalidArgsBadSharedMemoryId) {
-  SpecializedSetup<cmds::IsRenderbuffer, 0>(false);
-  cmds::IsRenderbuffer cmd;
-  cmd.Init(
-      client_renderbuffer_id_, kInvalidSharedMemoryId, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  cmd.Init(
-      client_renderbuffer_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, IsShaderValidArgs) {
-  SpecializedSetup<cmds::IsShader, 0>(true);
-  cmds::IsShader cmd;
-  cmd.Init(client_shader_id_, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, IsShaderInvalidArgsBadSharedMemoryId) {
-  SpecializedSetup<cmds::IsShader, 0>(false);
-  cmds::IsShader cmd;
-  cmd.Init(client_shader_id_, kInvalidSharedMemoryId, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  cmd.Init(client_shader_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, IsTextureValidArgs) {
-  SpecializedSetup<cmds::IsTexture, 0>(true);
-  cmds::IsTexture cmd;
-  cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, IsTextureInvalidArgsBadSharedMemoryId) {
-  SpecializedSetup<cmds::IsTexture, 0>(false);
-  cmds::IsTexture cmd;
-  cmd.Init(client_texture_id_, kInvalidSharedMemoryId, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  cmd.Init(client_texture_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, LineWidthValidArgs) {
-  EXPECT_CALL(*gl_, LineWidth(0.5f));
-  SpecializedSetup<cmds::LineWidth, 0>(true);
-  cmds::LineWidth cmd;
-  cmd.Init(0.5f);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, LineWidthInvalidValue0_0) {
-  SpecializedSetup<cmds::LineWidth, 0>(false);
-  cmds::LineWidth cmd;
-  cmd.Init(0.0f);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, LinkProgramValidArgs) {
-  EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId));
-  SpecializedSetup<cmds::LinkProgram, 0>(true);
-  cmds::LinkProgram cmd;
-  cmd.Init(client_program_id_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-// TODO(gman): PixelStorei
-
-TEST_P(GLES2DecoderTest2, PolygonOffsetValidArgs) {
-  EXPECT_CALL(*gl_, PolygonOffset(1, 2));
-  SpecializedSetup<cmds::PolygonOffset, 0>(true);
-  cmds::PolygonOffset cmd;
-  cmd.Init(1, 2);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-// TODO(gman): ReadPixels
-
 // TODO(gman): ReleaseShaderCompiler
 
 TEST_P(GLES2DecoderTest2, RenderbufferStorageValidArgs) {
@@ -270,83 +180,6 @@ TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvValidArgs) {
-  SpecializedSetup<cmds::TexParameterfv, 0>(true);
-  cmds::TexParameterfv cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-  EXPECT_CALL(
-      *gl_,
-      TexParameterf(GL_TEXTURE_2D,
-                    GL_TEXTURE_MAG_FILTER,
-                    *reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameterfv, 0>(false);
-  cmds::TexParameterfv cmd;
-  cmd.Init(GL_TEXTURE_1D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameterfv, 0>(false);
-  cmds::TexParameterfv cmd;
-  cmd.Init(GL_TEXTURE_3D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameterfv, 0>(false);
-  cmds::TexParameterfv cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_GENERATE_MIPMAP,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameterfv, 0>(false);
-  cmds::TexParameterfv cmd;
-  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
-  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameterfv, 0>(false);
-  cmds::TexParameterfv cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           kInvalidSharedMemoryOffset);
-  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
@@ -440,83 +273,6 @@ TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivValidArgs) {
-  SpecializedSetup<cmds::TexParameteriv, 0>(true);
-  cmds::TexParameteriv cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-  EXPECT_CALL(
-      *gl_,
-      TexParameteri(GL_TEXTURE_2D,
-                    GL_TEXTURE_MAG_FILTER,
-                    *reinterpret_cast<const GLint*>(shared_memory_address_)));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
-  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameteriv, 0>(false);
-  cmds::TexParameteriv cmd;
-  cmd.Init(GL_TEXTURE_1D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
-  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameteriv, 0>(false);
-  cmds::TexParameteriv cmd;
-  cmd.Init(GL_TEXTURE_3D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameteriv, 0>(false);
-  cmds::TexParameteriv cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_GENERATE_MIPMAP,
-           shared_memory_id_,
-           shared_memory_offset_);
-  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameteriv, 0>(false);
-  cmds::TexParameteriv cmd;
-  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
-  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
-  SpecializedSetup<cmds::TexParameteriv, 0>(false);
-  cmds::TexParameteriv cmd;
-  cmd.Init(GL_TEXTURE_2D,
-           GL_TEXTURE_MAG_FILTER,
-           shared_memory_id_,
-           kInvalidSharedMemoryOffset);
-  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
@@ -583,58 +339,6 @@ TEST_P(GLES2DecoderTest2, Uniform1fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform1fv(
-          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform1fv, 0>(true);
-  cmds::Uniform1fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform1fv, 0>(false);
-  cmds::Uniform1fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform1fv, 0>(false);
-  cmds::Uniform1fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform1fv, 0>(false);
-  cmds::Uniform1fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform1fvValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform1fv(
-          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform1fv, 0>(true);
-  cmds::Uniform1fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
   cmds::Uniform1fvImmediate& cmd = *GetImmediateAs<cmds::Uniform1fvImmediate>();
   EXPECT_CALL(
@@ -649,7 +353,6 @@ TEST_P(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 // TODO(gman): Uniform1i
-// TODO(gman): Uniform1iv
 // TODO(gman): Uniform1ivImmediate
 
 TEST_P(GLES2DecoderTest2, Uniform2fValidArgs) {
@@ -661,58 +364,6 @@ TEST_P(GLES2DecoderTest2, Uniform2fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform2fv(
-          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform2fv, 0>(true);
-  cmds::Uniform2fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform2fv, 0>(false);
-  cmds::Uniform2fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform2fv, 0>(false);
-  cmds::Uniform2fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform2fv, 0>(false);
-  cmds::Uniform2fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2fvValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform2fv(
-          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform2fv, 0>(true);
-  cmds::Uniform2fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
   cmds::Uniform2fvImmediate& cmd = *GetImmediateAs<cmds::Uniform2fvImmediate>();
   EXPECT_CALL(
@@ -736,56 +387,6 @@ TEST_P(GLES2DecoderTest2, Uniform2iValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform2iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform2iv, 0>(true);
-  cmds::Uniform2iv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform2iv, 0>(false);
-  cmds::Uniform2iv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform2iv, 0>(false);
-  cmds::Uniform2iv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform2iv, 0>(false);
-  cmds::Uniform2iv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform2ivValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform2iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform2iv, 0>(true);
-  cmds::Uniform2iv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
   cmds::Uniform2ivImmediate& cmd = *GetImmediateAs<cmds::Uniform2ivImmediate>();
   EXPECT_CALL(
@@ -809,58 +410,6 @@ TEST_P(GLES2DecoderTest2, Uniform3fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform3fv(
-          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform3fv, 0>(true);
-  cmds::Uniform3fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform3fv, 0>(false);
-  cmds::Uniform3fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform3fv, 0>(false);
-  cmds::Uniform3fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform3fv, 0>(false);
-  cmds::Uniform3fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3fvValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform3fv(
-          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform3fv, 0>(true);
-  cmds::Uniform3fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
   cmds::Uniform3fvImmediate& cmd = *GetImmediateAs<cmds::Uniform3fvImmediate>();
   EXPECT_CALL(
@@ -884,56 +433,6 @@ TEST_P(GLES2DecoderTest2, Uniform3iValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform3iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform3iv, 0>(true);
-  cmds::Uniform3iv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform3iv, 0>(false);
-  cmds::Uniform3iv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform3iv, 0>(false);
-  cmds::Uniform3iv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform3iv, 0>(false);
-  cmds::Uniform3iv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform3ivValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform3iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform3iv, 0>(true);
-  cmds::Uniform3iv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
   cmds::Uniform3ivImmediate& cmd = *GetImmediateAs<cmds::Uniform3ivImmediate>();
   EXPECT_CALL(
@@ -957,58 +456,6 @@ TEST_P(GLES2DecoderTest2, Uniform4fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform4fv(
-          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform4fv, 0>(true);
-  cmds::Uniform4fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform4fv, 0>(false);
-  cmds::Uniform4fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform4fv, 0>(false);
-  cmds::Uniform4fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform4fv, 0>(false);
-  cmds::Uniform4fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4fvValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform4fv(
-          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform4fv, 0>(true);
-  cmds::Uniform4fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
   cmds::Uniform4fvImmediate& cmd = *GetImmediateAs<cmds::Uniform4fvImmediate>();
   EXPECT_CALL(
@@ -1032,56 +479,6 @@ TEST_P(GLES2DecoderTest2, Uniform4iValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform4iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform4iv, 0>(true);
-  cmds::Uniform4iv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform4iv, 0>(false);
-  cmds::Uniform4iv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform4iv, 0>(false);
-  cmds::Uniform4iv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
-  SpecializedSetup<cmds::Uniform4iv, 0>(false);
-  cmds::Uniform4iv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, Uniform4ivValidArgsCountTooLarge) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform4iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
-  SpecializedSetup<cmds::Uniform4iv, 0>(true);
-  cmds::Uniform4iv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
   cmds::Uniform4ivImmediate& cmd = *GetImmediateAs<cmds::Uniform4ivImmediate>();
   EXPECT_CALL(
@@ -1096,62 +493,6 @@ TEST_P(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
-  EXPECT_CALL(*gl_,
-              UniformMatrix2fv(
-                  1,
-                  2,
-                  false,
-                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::UniformMatrix2fv, 0>(true);
-  cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
-  cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
-  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
-  cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
-  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
-  cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
-  EXPECT_CALL(*gl_,
-              UniformMatrix2fv(
-                  3,
-                  3,
-                  false,
-                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::UniformMatrix2fv, 0>(true);
-  cmds::UniformMatrix2fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
   cmds::UniformMatrix2fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
@@ -1168,62 +509,6 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
-  EXPECT_CALL(*gl_,
-              UniformMatrix3fv(
-                  1,
-                  2,
-                  false,
-                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::UniformMatrix3fv, 0>(true);
-  cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
-  cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
-  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
-  cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
-  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
-  cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
-  EXPECT_CALL(*gl_,
-              UniformMatrix3fv(
-                  3,
-                  3,
-                  false,
-                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::UniformMatrix3fv, 0>(true);
-  cmds::UniformMatrix3fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
   cmds::UniformMatrix3fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
@@ -1240,62 +525,6 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
-  EXPECT_CALL(*gl_,
-              UniformMatrix4fv(
-                  1,
-                  2,
-                  false,
-                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::UniformMatrix4fv, 0>(true);
-  cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
-  cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
-  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
-  cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
-  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
-  cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
-  EXPECT_CALL(*gl_,
-              UniformMatrix4fv(
-                  3,
-                  3,
-                  false,
-                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  SpecializedSetup<cmds::UniformMatrix4fv, 0>(true);
-  cmds::UniformMatrix4fv cmd;
-  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
-           5,
-           shared_memory_id_,
-           shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
   cmds::UniformMatrix4fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
@@ -1348,36 +577,6 @@ TEST_P(GLES2DecoderTest2, VertexAttrib1fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvValidArgs) {
-  SpecializedSetup<cmds::VertexAttrib1fv, 0>(true);
-  cmds::VertexAttrib1fv cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_CALL(*gl_,
-              VertexAttrib1fv(
-                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, VertexAttrib1fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib1fv, 0>(false);
-  cmds::VertexAttrib1fv cmd;
-  cmd.Init(1, kInvalidSharedMemoryId, 0);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_1) {
-  EXPECT_CALL(*gl_, VertexAttrib1fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib1fv, 0>(false);
-  cmds::VertexAttrib1fv cmd;
-  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest2, VertexAttrib1fvImmediateValidArgs) {
   cmds::VertexAttrib1fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib1fvImmediate>();
@@ -1402,36 +601,6 @@ TEST_P(GLES2DecoderTest2, VertexAttrib2fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvValidArgs) {
-  SpecializedSetup<cmds::VertexAttrib2fv, 0>(true);
-  cmds::VertexAttrib2fv cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_CALL(*gl_,
-              VertexAttrib2fv(
-                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, VertexAttrib2fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib2fv, 0>(false);
-  cmds::VertexAttrib2fv cmd;
-  cmd.Init(1, kInvalidSharedMemoryId, 0);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_1) {
-  EXPECT_CALL(*gl_, VertexAttrib2fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib2fv, 0>(false);
-  cmds::VertexAttrib2fv cmd;
-  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest2, VertexAttrib2fvImmediateValidArgs) {
   cmds::VertexAttrib2fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib2fvImmediate>();
@@ -1456,36 +625,6 @@ TEST_P(GLES2DecoderTest2, VertexAttrib3fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvValidArgs) {
-  SpecializedSetup<cmds::VertexAttrib3fv, 0>(true);
-  cmds::VertexAttrib3fv cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_CALL(*gl_,
-              VertexAttrib3fv(
-                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, VertexAttrib3fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib3fv, 0>(false);
-  cmds::VertexAttrib3fv cmd;
-  cmd.Init(1, kInvalidSharedMemoryId, 0);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_1) {
-  EXPECT_CALL(*gl_, VertexAttrib3fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib3fv, 0>(false);
-  cmds::VertexAttrib3fv cmd;
-  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest2, VertexAttrib3fvImmediateValidArgs) {
   cmds::VertexAttrib3fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib3fvImmediate>();
@@ -1510,36 +649,6 @@ TEST_P(GLES2DecoderTest2, VertexAttrib4fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvValidArgs) {
-  SpecializedSetup<cmds::VertexAttrib4fv, 0>(true);
-  cmds::VertexAttrib4fv cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_CALL(*gl_,
-              VertexAttrib4fv(
-                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, VertexAttrib4fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib4fv, 0>(false);
-  cmds::VertexAttrib4fv cmd;
-  cmd.Init(1, kInvalidSharedMemoryId, 0);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_1) {
-  EXPECT_CALL(*gl_, VertexAttrib4fv(_, _)).Times(0);
-  SpecializedSetup<cmds::VertexAttrib4fv, 0>(false);
-  cmds::VertexAttrib4fv cmd;
-  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
-  GetSharedMemoryAs<GLfloat*>()[0] = 0;
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderTest2, VertexAttrib4fvImmediateValidArgs) {
   cmds::VertexAttrib4fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib4fvImmediate>();
@@ -1587,9 +696,7 @@ TEST_P(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
 // TODO(gman): RenderbufferStorageMultisampleEXT
 // TODO(gman): FramebufferTexture2DMultisampleEXT
 // TODO(gman): TexStorage2DEXT
-// TODO(gman): GenQueriesEXT
 // TODO(gman): GenQueriesEXTImmediate
-// TODO(gman): DeleteQueriesEXT
 // TODO(gman): DeleteQueriesEXTImmediate
 // TODO(gman): BeginQueryEXT
 
@@ -1606,9 +713,7 @@ TEST_P(GLES2DecoderTest2, PopGroupMarkerEXTValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
-// TODO(gman): GenVertexArraysOES
 // TODO(gman): GenVertexArraysOESImmediate
-// TODO(gman): DeleteVertexArraysOES
 // TODO(gman): DeleteVertexArraysOESImmediate
 // TODO(gman): IsVertexArrayOES
 // TODO(gman): BindVertexArrayOES
@@ -1616,4 +721,47 @@ TEST_P(GLES2DecoderTest2, PopGroupMarkerEXTValidArgs) {
 // TODO(gman): GetMaxValueInBufferCHROMIUM
 // TODO(gman): GenSharedIdsCHROMIUM
 
+// TODO(gman): DeleteSharedIdsCHROMIUM
+
+// TODO(gman): RegisterSharedIdsCHROMIUM
+
+// TODO(gman): EnableFeatureCHROMIUM
+
+// TODO(gman): ResizeCHROMIUM
+// TODO(gman): GetRequestableExtensionsCHROMIUM
+
+// TODO(gman): RequestExtensionCHROMIUM
+
+// TODO(gman): GetMultipleIntegervCHROMIUM
+
+// TODO(gman): GetProgramInfoCHROMIUM
+
+// TODO(gman): GetTranslatedShaderSourceANGLE
+// TODO(gman): PostSubBufferCHROMIUM
+// TODO(gman): TexImageIOSurface2DCHROMIUM
+// TODO(gman): CopyTextureCHROMIUM
+// TODO(gman): DrawArraysInstancedANGLE
+// TODO(gman): DrawElementsInstancedANGLE
+// TODO(gman): VertexAttribDivisorANGLE
+// TODO(gman): GenMailboxCHROMIUM
+
+// TODO(gman): ProduceTextureCHROMIUMImmediate
+// TODO(gman): ConsumeTextureCHROMIUMImmediate
+// TODO(gman): BindUniformLocationCHROMIUM
+
+// TODO(gman): BindUniformLocationCHROMIUMBucket
+// TODO(gman): BindTexImage2DCHROMIUM
+// TODO(gman): ReleaseTexImage2DCHROMIUM
+// TODO(gman): TraceBeginCHROMIUM
+
+// TODO(gman): TraceEndCHROMIUM
+// TODO(gman): AsyncTexSubImage2DCHROMIUM
+
+// TODO(gman): AsyncTexImage2DCHROMIUM
+
+// TODO(gman): WaitAsyncTexImage2DCHROMIUM
+
+// TODO(gman): WaitAllAsyncTexImage2DCHROMIUM
+
+// TODO(gman): DiscardFramebufferEXTImmediate
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
index 7d83956..1c98b68 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
@@ -12,58 +12,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
 
-// TODO(gman): DeleteSharedIdsCHROMIUM
-
-// TODO(gman): RegisterSharedIdsCHROMIUM
-
-// TODO(gman): EnableFeatureCHROMIUM
-
-// TODO(gman): ResizeCHROMIUM
-// TODO(gman): GetRequestableExtensionsCHROMIUM
-
-// TODO(gman): RequestExtensionCHROMIUM
-
-// TODO(gman): GetMultipleIntegervCHROMIUM
-
-// TODO(gman): GetProgramInfoCHROMIUM
-
-// TODO(gman): GetTranslatedShaderSourceANGLE
-// TODO(gman): PostSubBufferCHROMIUM
-// TODO(gman): TexImageIOSurface2DCHROMIUM
-// TODO(gman): CopyTextureCHROMIUM
-// TODO(gman): DrawArraysInstancedANGLE
-// TODO(gman): DrawElementsInstancedANGLE
-// TODO(gman): VertexAttribDivisorANGLE
-// TODO(gman): GenMailboxCHROMIUM
-
-// TODO(gman): ProduceTextureCHROMIUM
-// TODO(gman): ProduceTextureCHROMIUMImmediate
-// TODO(gman): ConsumeTextureCHROMIUM
-// TODO(gman): ConsumeTextureCHROMIUMImmediate
-// TODO(gman): BindUniformLocationCHROMIUM
-
-// TODO(gman): BindUniformLocationCHROMIUMBucket
-// TODO(gman): BindTexImage2DCHROMIUM
-// TODO(gman): ReleaseTexImage2DCHROMIUM
-// TODO(gman): TraceBeginCHROMIUM
-
-// TODO(gman): TraceEndCHROMIUM
-// TODO(gman): AsyncTexSubImage2DCHROMIUM
-
-// TODO(gman): AsyncTexImage2DCHROMIUM
-
-// TODO(gman): WaitAsyncTexImage2DCHROMIUM
-
-// TODO(gman): WaitAllAsyncTexImage2DCHROMIUM
-
-// TODO(gman): DiscardFramebufferEXT
-// TODO(gman): DiscardFramebufferEXTImmediate
 // TODO(gman): LoseContextCHROMIUM
 // TODO(gman): InsertSyncPointCHROMIUM
 
 // TODO(gman): WaitSyncPointCHROMIUM
 
-// TODO(gman): DrawBuffersEXT
 // TODO(gman): DrawBuffersEXTImmediate
 // TODO(gman): DiscardBackbufferCHROMIUM
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
index cf3ecd0..022c94b 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc
@@ -260,25 +260,6 @@ class GLES2DecoderVertexArraysOESTest : public GLES2DecoderWithShaderTest {
     GLES2DecoderWithShaderTest::TearDown();
   }
 
-  void GenVertexArraysOESValidArgs() {
-    AddExpectationsForGenVertexArraysOES();
-    GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
-    GenVertexArraysOES cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_TRUE(GetVertexArrayInfo(kNewClientId) != NULL);
-    AddExpectationsForDeleteVertexArraysOES();
-  }
-
-  void GenVertexArraysOESInvalidArgs() {
-    EXPECT_CALL(*gl_, GenVertexArraysOES(_, _)).Times(0);
-    GetSharedMemoryAs<GLuint*>()[0] = client_vertexarray_id_;
-    GenVertexArraysOES cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-  }
-
   void GenVertexArraysOESImmediateValidArgs() {
     AddExpectationsForGenVertexArraysOES();
     GenVertexArraysOESImmediate* cmd =
@@ -300,24 +281,6 @@ class GLES2DecoderVertexArraysOESTest : public GLES2DecoderWithShaderTest {
               ExecuteImmediateCmd(*cmd, sizeof(&client_vertexarray_id_)));
   }
 
-  void DeleteVertexArraysOESValidArgs() {
-    AddExpectationsForDeleteVertexArraysOES();
-    GetSharedMemoryAs<GLuint*>()[0] = client_vertexarray_id_;
-    DeleteVertexArraysOES cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_TRUE(GetVertexArrayInfo(client_vertexarray_id_) == NULL);
-    vertex_array_deleted_manually_ = true;
-  }
-
-  void DeleteVertexArraysOESInvalidArgs() {
-    GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
-    DeleteVertexArraysOES cmd;
-    cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  }
-
   void DeleteVertexArraysOESImmediateValidArgs() {
     AddExpectationsForDeleteVertexArraysOES();
     DeleteVertexArraysOESImmediate& cmd =
@@ -413,20 +376,6 @@ INSTANTIATE_TEST_CASE_P(Service,
                         ::testing::Bool());
 
 // Test vertex array objects with native support
-TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESValidArgs) {
-  GenVertexArraysOESValidArgs();
-}
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, GenVertexArraysOESValidArgs) {
-  GenVertexArraysOESValidArgs();
-}
-
-TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESInvalidArgs) {
-  GenVertexArraysOESInvalidArgs();
-}
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, ) {
-  GenVertexArraysOESInvalidArgs();
-}
-
 TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESImmediateValidArgs) {
   GenVertexArraysOESImmediateValidArgs();
 }
@@ -444,22 +393,6 @@ TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
   GenVertexArraysOESImmediateInvalidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESValidArgs) {
-  DeleteVertexArraysOESValidArgs();
-}
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       DeleteVertexArraysOESValidArgs) {
-  DeleteVertexArraysOESValidArgs();
-}
-
-TEST_P(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESInvalidArgs) {
-  DeleteVertexArraysOESInvalidArgs();
-}
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       DeleteVertexArraysOESInvalidArgs) {
-  DeleteVertexArraysOESInvalidArgs();
-}
-
 TEST_P(GLES2DecoderVertexArraysOESTest,
        DeleteVertexArraysOESImmediateValidArgs) {
   DeleteVertexArraysOESImmediateValidArgs();
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index ec98832..38089b6 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -645,10 +645,7 @@ void GLES2DecoderTestBase::DoDeleteBuffer(
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  cmds::DeleteBuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  memcpy(shared_memory_address_, &client_id, sizeof(client_id));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  GenHelper<cmds::DeleteBuffersImmediate>(client_id);
 }
 
 void GLES2DecoderTestBase::SetupExpectationsForColorMask(bool red,
@@ -840,10 +837,7 @@ void GLES2DecoderTestBase::DoDeleteFramebuffer(
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  cmds::DeleteFramebuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  memcpy(shared_memory_address_, &client_id, sizeof(client_id));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  GenHelper<cmds::DeleteFramebuffersImmediate>(client_id);
 }
 
 void GLES2DecoderTestBase::DoBindRenderbuffer(
@@ -866,10 +860,7 @@ void GLES2DecoderTestBase::DoDeleteRenderbuffer(
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  cmds::DeleteRenderbuffers cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  memcpy(shared_memory_address_, &client_id, sizeof(client_id));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  GenHelper<cmds::DeleteRenderbuffersImmediate>(client_id);
 }
 
 void GLES2DecoderTestBase::DoBindTexture(
@@ -891,10 +882,7 @@ void GLES2DecoderTestBase::DoDeleteTexture(
   EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  cmds::DeleteTextures cmd;
-  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
-  memcpy(shared_memory_address_, &client_id, sizeof(client_id));
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  GenHelper<cmds::DeleteTexturesImmediate>(client_id);
 }
 
 void GLES2DecoderTestBase::DoTexImage2D(
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
index 91ff2e1..a364a0d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
@@ -587,6 +587,10 @@ class GLES2DecoderWithShaderTestBase : public GLES2DecoderTestBase {
 
 };
 
+// SpecializedSetup specializations that are needed in multiple unittest files.
+template <>
+void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(bool valid);
+
 }  // namespace gles2
 }  // namespace gpu
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
index 5c0cecf..ec7fd48 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc
@@ -795,32 +795,6 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) {
-  EXPECT_CALL(
-      *gl_,
-      Uniform1iv(kUniform1RealLocation,
-                 1,
-                 reinterpret_cast<const GLint*>(shared_memory_address_)));
-  Uniform1iv cmd;
-  cmd.Init(kUniform1FakeLocation, 1, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
-  Uniform1iv cmd;
-  cmd.Init(kUniform1FakeLocation, 1, kInvalidSharedMemoryId, 0);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
-  Uniform1iv cmd;
-  cmd.Init(
-      kUniform1FakeLocation, 1, shared_memory_id_, kInvalidSharedMemoryOffset);
-  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
-}
-
 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
   EXPECT_CALL(*gl_,
@@ -834,19 +808,23 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateInvalidValidArgs) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
-  Uniform1iv cmd;
-  cmd.Init(kUniform1FakeLocation, 2, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
+  GLint temp[1 * 2] = {
+      0,
+  };
+  cmd.Init(kUniform1FakeLocation, 2, &temp[0]);
+  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
-  Uniform1iv cmd;
-  cmd.Init(kUniform1FakeLocation, 0, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
+  GLint temp = 0;
+  cmd.Init(kUniform1FakeLocation, 0, &temp);
+  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
index a0a5624..5e6a0d4 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
@@ -1204,13 +1204,13 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-    TexParameterfv cmd2;
+    GLfloat data = GL_NEAREST;
+    TexParameterfvImmediate& cmd2 =
+      *GetImmediateAs<TexParameterfvImmediate>();
     cmd2.Init(GL_TEXTURE_2D,
               GL_TEXTURE_MAG_FILTER,
-              shared_memory_id_,
-              shared_memory_offset_);
-    GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
+              &data);
+    EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 
@@ -1221,13 +1221,13 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-    TexParameterfv cmd2;
+    GLfloat data = GL_NEAREST;
+    TexParameterfvImmediate& cmd2 =
+      *GetImmediateAs<TexParameterfvImmediate>();
     cmd2.Init(GL_TEXTURE_CUBE_MAP,
               GL_TEXTURE_MAG_FILTER,
-              shared_memory_id_,
-              shared_memory_offset_);
-    GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
+              &data);
+    EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 }
@@ -1244,13 +1244,13 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-    TexParameteriv cmd2;
+    GLfloat data = GL_NEAREST;
+    TexParameterfvImmediate& cmd2 =
+      *GetImmediateAs<TexParameterfvImmediate>();
     cmd2.Init(GL_TEXTURE_2D,
               GL_TEXTURE_MAG_FILTER,
-              shared_memory_id_,
-              shared_memory_offset_);
-    GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
+              &data);
+    EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 
@@ -1261,13 +1261,13 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-    TexParameteriv cmd2;
+    GLfloat data = GL_NEAREST;
+    TexParameterfvImmediate& cmd2 =
+      *GetImmediateAs<TexParameterfvImmediate>();
     cmd2.Init(GL_TEXTURE_CUBE_MAP,
               GL_TEXTURE_MAG_FILTER,
-              shared_memory_id_,
-              shared_memory_offset_);
-    GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
+              &data);
+    EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 }
@@ -1852,8 +1852,6 @@ TEST_P(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
 TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   Mailbox mailbox = Mailbox::Generate();
 
-  memcpy(shared_memory_address_, mailbox.name, sizeof(mailbox.name));
-
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
@@ -1865,9 +1863,11 @@ TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
-  ProduceTextureCHROMIUM produce_cmd;
-  produce_cmd.Init(GL_TEXTURE_2D, kSharedMemoryId, kSharedMemoryOffset);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(produce_cmd));
+  ProduceTextureCHROMIUMImmediate& produce_cmd =
+      *GetImmediateAs<ProduceTextureCHROMIUMImmediate>();
+  produce_cmd.Init(GL_TEXTURE_2D, mailbox.name);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Texture didn't change.
@@ -1905,10 +1905,11 @@ TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
       .Times(1)
       .RetiresOnSaturation();
 
-  memcpy(shared_memory_address_, mailbox.name, sizeof(mailbox.name));
-  ConsumeTextureCHROMIUM consume_cmd;
-  consume_cmd.Init(GL_TEXTURE_2D, kSharedMemoryId, kSharedMemoryOffset);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(consume_cmd));
+  ConsumeTextureCHROMIUMImmediate& consume_cmd =
+      *GetImmediateAs<ConsumeTextureCHROMIUMImmediate>();
+  consume_cmd.Init(GL_TEXTURE_2D, mailbox.name);
+  EXPECT_EQ(error::kNoError,
+            ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Texture is redefined.