Remove shm versions of immediate commands from command buffer

gpu/command_buffer/client/gles2_cmd_helper_autogen.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 300 matching lines @@
   }
 }
 
 void CullFace(GLenum mode) {
   gles2::cmds::CullFace* c = GetCmdSpace<gles2::cmds::CullFace>();
   if (c) {
     c->Init(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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteBuffersImmediate>(size);
   if (c) {
     c->Init(n, 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);
   gles2::cmds::DeleteFramebuffersImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteFramebuffersImmediate>(
           size);
   if (c) {
     c->Init(n, framebuffers);
   }
 }
 
 void DeleteProgram(GLuint program) {
   gles2::cmds::DeleteProgram* c = GetCmdSpace<gles2::cmds::DeleteProgram>();
   if (c) {
     c->Init(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);
   gles2::cmds::DeleteRenderbuffersImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteRenderbuffersImmediate>(
           size);
   if (c) {
     c->Init(n, renderbuffers);
   }
 }
 
 void DeleteShader(GLuint shader) {
   gles2::cmds::DeleteShader* c = GetCmdSpace<gles2::cmds::DeleteShader>();
   if (c) {
     c->Init(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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteTexturesImmediate>(size);
   if (c) {
     c->Init(n, textures);
   }
 }
 
 void DepthFunc(GLenum func) {
@@ skipping 107 matching lines @@
   }
 }
 
 void FrontFace(GLenum mode) {
   gles2::cmds::FrontFace* c = GetCmdSpace<gles2::cmds::FrontFace>();
   if (c) {
     c->Init(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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenBuffersImmediate>(size);
   if (c) {
     c->Init(n, buffers);
   }
 }
 
 void GenerateMipmap(GLenum target) {
   gles2::cmds::GenerateMipmap* c = GetCmdSpace<gles2::cmds::GenerateMipmap>();
   if (c) {
     c->Init(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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenFramebuffersImmediate>(
           size);
   if (c) {
     c->Init(n, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenRenderbuffersImmediate>(
           size);
   if (c) {
     c->Init(n, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenTexturesImmediate>(size);
   if (c) {
     c->Init(n, textures);
   }
 }
 
 void GetActiveAttrib(GLuint program,
@@ skipping 495 matching lines @@
   }
 }
 
 void TexParameterf(GLenum target, GLenum pname, GLfloat param) {
   gles2::cmds::TexParameterf* c = GetCmdSpace<gles2::cmds::TexParameterf>();
   if (c) {
     c->Init(target, pname, 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) {
   const uint32_t size = gles2::cmds::TexParameterfvImmediate::ComputeSize();
   gles2::cmds::TexParameterfvImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::TexParameterfvImmediate>(size);
   if (c) {
     c->Init(target, pname, params);
   }
 }
 
 void TexParameteri(GLenum target, GLenum pname, GLint param) {
   gles2::cmds::TexParameteri* c = GetCmdSpace<gles2::cmds::TexParameteri>();
   if (c) {
     c->Init(target, pname, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::TexParameterivImmediate>(size);
   if (c) {
     c->Init(target, pname, params);
   }
 }
 
 void TexSubImage2D(GLenum target,
@@ skipping 23 matching lines @@
   }
 }
 
 void Uniform1f(GLint location, GLfloat x) {
   gles2::cmds::Uniform1f* c = GetCmdSpace<gles2::cmds::Uniform1f>();
   if (c) {
     c->Init(location, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1fvImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform1i(GLint location, GLint x) {
   gles2::cmds::Uniform1i* c = GetCmdSpace<gles2::cmds::Uniform1i>();
   if (c) {
     c->Init(location, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1ivImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform2f(GLint location, GLfloat x, GLfloat y) {
   gles2::cmds::Uniform2f* c = GetCmdSpace<gles2::cmds::Uniform2f>();
   if (c) {
     c->Init(location, x, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2fvImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform2i(GLint location, GLint x, GLint y) {
   gles2::cmds::Uniform2i* c = GetCmdSpace<gles2::cmds::Uniform2i>();
   if (c) {
     c->Init(location, x, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2ivImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
   gles2::cmds::Uniform3f* c = GetCmdSpace<gles2::cmds::Uniform3f>();
   if (c) {
     c->Init(location, x, y, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3fvImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform3i(GLint location, GLint x, GLint y, GLint z) {
   gles2::cmds::Uniform3i* c = GetCmdSpace<gles2::cmds::Uniform3i>();
   if (c) {
     c->Init(location, x, y, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3ivImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   gles2::cmds::Uniform4f* c = GetCmdSpace<gles2::cmds::Uniform4f>();
   if (c) {
     c->Init(location, x, y, z, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4fvImmediate>(size);
   if (c) {
     c->Init(location, count, v);
   }
 }
 
 void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
   gles2::cmds::Uniform4i* c = GetCmdSpace<gles2::cmds::Uniform4i>();
   if (c) {
     c->Init(location, x, y, z, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4ivImmediate>(size);
   if (c) {
     c->Init(location, count, 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) {
   const uint32_t size =
       gles2::cmds::UniformMatrix2fvImmediate::ComputeSize(count);
   gles2::cmds::UniformMatrix2fvImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix2fvImmediate>(
           size);
   if (c) {
     c->Init(location, count, value);
   }
 }
 
-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) {
   const uint32_t size =
       gles2::cmds::UniformMatrix3fvImmediate::ComputeSize(count);
   gles2::cmds::UniformMatrix3fvImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix3fvImmediate>(
           size);
   if (c) {
     c->Init(location, count, value);
   }
 }
 
-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) {
   const uint32_t size =
       gles2::cmds::UniformMatrix4fvImmediate::ComputeSize(count);
   gles2::cmds::UniformMatrix4fvImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix4fvImmediate>(
           size);
   if (c) {
     c->Init(location, count, value);
@@ skipping 14 matching lines @@
   }
 }
 
 void VertexAttrib1f(GLuint indx, GLfloat x) {
   gles2::cmds::VertexAttrib1f* c = GetCmdSpace<gles2::cmds::VertexAttrib1f>();
   if (c) {
     c->Init(indx, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib1fvImmediate>(
           size);
   if (c) {
     c->Init(indx, values);
   }
 }
 
 void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
   gles2::cmds::VertexAttrib2f* c = GetCmdSpace<gles2::cmds::VertexAttrib2f>();
   if (c) {
     c->Init(indx, x, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib2fvImmediate>(
           size);
   if (c) {
     c->Init(indx, values);
   }
 }
 
 void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
   gles2::cmds::VertexAttrib3f* c = GetCmdSpace<gles2::cmds::VertexAttrib3f>();
   if (c) {
     c->Init(indx, x, y, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib3fvImmediate>(
           size);
   if (c) {
     c->Init(indx, values);
   }
 }
 
 void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   gles2::cmds::VertexAttrib4f* c = GetCmdSpace<gles2::cmds::VertexAttrib4f>();
   if (c) {
     c->Init(indx, x, y, z, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib4fvImmediate>(
           size);
   if (c) {
     c->Init(indx, values);
   }
 }
 
@@ skipping 75 matching lines @@
                      GLsizei levels,
                      GLenum internalFormat,
                      GLsizei width,
                      GLsizei height) {
   gles2::cmds::TexStorage2DEXT* c = GetCmdSpace<gles2::cmds::TexStorage2DEXT>();
   if (c) {
     c->Init(target, levels, internalFormat, width, height);
   }
 }
 
-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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenQueriesEXTImmediate>(size);
   if (c) {
     c->Init(n, 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 =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteQueriesEXTImmediate>(
           size);
   if (c) {
     c->Init(n, queries);
   }
 }
 
@@ skipping 31 matching lines @@
 }
 
 void PopGroupMarkerEXT() {
   gles2::cmds::PopGroupMarkerEXT* c =
       GetCmdSpace<gles2::cmds::PopGroupMarkerEXT>();
   if (c) {
     c->Init();
   }
 }
 
-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);
   gles2::cmds::GenVertexArraysOESImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenVertexArraysOESImmediate>(
           size);
   if (c) {
     c->Init(n, 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);
   gles2::cmds::DeleteVertexArraysOESImmediate* c =
       GetImmediateCmdSpaceTotalSize<
           gles2::cmds::DeleteVertexArraysOESImmediate>(size);
   if (c) {
     c->Init(n, arrays);
   }
 }
@@ skipping 194 matching lines @@
 }
 
 void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
   gles2::cmds::VertexAttribDivisorANGLE* c =
       GetCmdSpace<gles2::cmds::VertexAttribDivisorANGLE>();
   if (c) {
     c->Init(index, 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();
   gles2::cmds::ProduceTextureCHROMIUMImmediate* c =
       GetImmediateCmdSpaceTotalSize<
           gles2::cmds::ProduceTextureCHROMIUMImmediate>(size);
   if (c) {
     c->Init(target, 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();
   gles2::cmds::ConsumeTextureCHROMIUMImmediate* c =
       GetImmediateCmdSpaceTotalSize<
           gles2::cmds::ConsumeTextureCHROMIUMImmediate>(size);
   if (c) {
     c->Init(target, mailbox);
   }
 }
@@ skipping 123 matching lines @@
 }
 
 void WaitAllAsyncTexImage2DCHROMIUM() {
   gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM* c =
       GetCmdSpace<gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM>();
   if (c) {
     c->Init();
   }
 }
 
-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) {
   const uint32_t size =
       gles2::cmds::DiscardFramebufferEXTImmediate::ComputeSize(count);
   gles2::cmds::DiscardFramebufferEXTImmediate* c =
       GetImmediateCmdSpaceTotalSize<
           gles2::cmds::DiscardFramebufferEXTImmediate>(size);
   if (c) {
     c->Init(target, count, attachments);
   }
 }
 
 void LoseContextCHROMIUM(GLenum current, GLenum other) {
   gles2::cmds::LoseContextCHROMIUM* c =
       GetCmdSpace<gles2::cmds::LoseContextCHROMIUM>();
   if (c) {
     c->Init(current, other);
   }
 }
 
 void WaitSyncPointCHROMIUM(GLuint sync_point) {
   gles2::cmds::WaitSyncPointCHROMIUM* c =
       GetCmdSpace<gles2::cmds::WaitSyncPointCHROMIUM>();
   if (c) {
     c->Init(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);
   gles2::cmds::DrawBuffersEXTImmediate* c =
       GetImmediateCmdSpaceTotalSize<gles2::cmds::DrawBuffersEXTImmediate>(size);
   if (c) {
     c->Init(count, bufs);
   }
 }
 
@@ skipping 27 matching lines @@
             bounds_width,
             bounds_height,
             uv_x,
             uv_y,
             uv_width,
             uv_height);
   }
 }
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_