Update from https://crrev.com/306655

gpu/command_buffer/common/gles2_cmd_format_autogen.h

Index: gpu/command_buffer/common/gles2_cmd_format_autogen.h
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index 14f07282789ea29a0ddd7327d4489544924bd3d2..c451b98ba72c667033915459c225764860c5f3c7 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -1168,6 +1168,65 @@ COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_id) == 36,
 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40,
                OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40);
 
+struct CopyBufferSubData {
+  typedef CopyBufferSubData ValueType;
+  static const CommandId kCmdId = kCopyBufferSubData;
+  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 _readtarget,
+            GLenum _writetarget,
+            GLintptr _readoffset,
+            GLintptr _writeoffset,
+            GLsizeiptr _size) {
+    SetHeader();
+    readtarget = _readtarget;
+    writetarget = _writetarget;
+    readoffset = _readoffset;
+    writeoffset = _writeoffset;
+    size = _size;
+  }
+
+  void* Set(void* cmd,
+            GLenum _readtarget,
+            GLenum _writetarget,
+            GLintptr _readoffset,
+            GLintptr _writeoffset,
+            GLsizeiptr _size) {
+    static_cast<ValueType*>(cmd)
+        ->Init(_readtarget, _writetarget, _readoffset, _writeoffset, _size);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t readtarget;
+  uint32_t writetarget;
+  int32_t readoffset;
+  int32_t writeoffset;
+  int32_t size;
+};
+
+COMPILE_ASSERT(sizeof(CopyBufferSubData) == 24,
+               Sizeof_CopyBufferSubData_is_not_24);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, header) == 0,
+               OffsetOf_CopyBufferSubData_header_not_0);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, readtarget) == 4,
+               OffsetOf_CopyBufferSubData_readtarget_not_4);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, writetarget) == 8,
+               OffsetOf_CopyBufferSubData_writetarget_not_8);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, readoffset) == 12,
+               OffsetOf_CopyBufferSubData_readoffset_not_12);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, writeoffset) == 16,
+               OffsetOf_CopyBufferSubData_writeoffset_not_16);
+COMPILE_ASSERT(offsetof(CopyBufferSubData, size) == 20,
+               OffsetOf_CopyBufferSubData_size_not_20);
+
 struct CopyTexImage2D {
   typedef CopyTexImage2D ValueType;
   static const CommandId kCmdId = kCopyTexImage2D;
@@ -2150,6 +2209,65 @@ COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12,
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16,
                OffsetOf_FramebufferTexture2D_texture_not_16);
 
+struct FramebufferTextureLayer {
+  typedef FramebufferTextureLayer ValueType;
+  static const CommandId kCmdId = kFramebufferTextureLayer;
+  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 _attachment,
+            GLuint _texture,
+            GLint _level,
+            GLint _layer) {
+    SetHeader();
+    target = _target;
+    attachment = _attachment;
+    texture = _texture;
+    level = _level;
+    layer = _layer;
+  }
+
+  void* Set(void* cmd,
+            GLenum _target,
+            GLenum _attachment,
+            GLuint _texture,
+            GLint _level,
+            GLint _layer) {
+    static_cast<ValueType*>(cmd)
+        ->Init(_target, _attachment, _texture, _level, _layer);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t target;
+  uint32_t attachment;
+  uint32_t texture;
+  int32_t level;
+  int32_t layer;
+};
+
+COMPILE_ASSERT(sizeof(FramebufferTextureLayer) == 24,
+               Sizeof_FramebufferTextureLayer_is_not_24);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, header) == 0,
+               OffsetOf_FramebufferTextureLayer_header_not_0);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, target) == 4,
+               OffsetOf_FramebufferTextureLayer_target_not_4);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, attachment) == 8,
+               OffsetOf_FramebufferTextureLayer_attachment_not_8);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, texture) == 12,
+               OffsetOf_FramebufferTextureLayer_texture_not_12);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, level) == 16,
+               OffsetOf_FramebufferTextureLayer_level_not_16);
+COMPILE_ASSERT(offsetof(FramebufferTextureLayer, layer) == 20,
+               OffsetOf_FramebufferTextureLayer_layer_not_20);
+
 struct FrontFace {
   typedef FrontFace ValueType;
   static const CommandId kCmdId = kFrontFace;
@@ -2930,6 +3048,73 @@ COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_id) == 8,
 COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_offset) == 12,
                OffsetOf_GetIntegerv_params_shm_offset_not_12);
 
+struct GetInternalformativ {
+  typedef GetInternalformativ ValueType;
+  static const CommandId kCmdId = kGetInternalformativ;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  typedef SizedResult<GLint> Result;
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLenum _target,
+            GLenum _format,
+            GLenum _pname,
+            GLsizei _bufSize,
+            uint32_t _params_shm_id,
+            uint32_t _params_shm_offset) {
+    SetHeader();
+    target = _target;
+    format = _format;
+    pname = _pname;
+    bufSize = _bufSize;
+    params_shm_id = _params_shm_id;
+    params_shm_offset = _params_shm_offset;
+  }
+
+  void* Set(void* cmd,
+            GLenum _target,
+            GLenum _format,
+            GLenum _pname,
+            GLsizei _bufSize,
+            uint32_t _params_shm_id,
+            uint32_t _params_shm_offset) {
+    static_cast<ValueType*>(cmd)->Init(_target, _format, _pname, _bufSize,
+                                       _params_shm_id, _params_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t target;
+  uint32_t format;
+  uint32_t pname;
+  int32_t bufSize;
+  uint32_t params_shm_id;
+  uint32_t params_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GetInternalformativ) == 28,
+               Sizeof_GetInternalformativ_is_not_28);
+COMPILE_ASSERT(offsetof(GetInternalformativ, header) == 0,
+               OffsetOf_GetInternalformativ_header_not_0);
+COMPILE_ASSERT(offsetof(GetInternalformativ, target) == 4,
+               OffsetOf_GetInternalformativ_target_not_4);
+COMPILE_ASSERT(offsetof(GetInternalformativ, format) == 8,
+               OffsetOf_GetInternalformativ_format_not_8);
+COMPILE_ASSERT(offsetof(GetInternalformativ, pname) == 12,
+               OffsetOf_GetInternalformativ_pname_not_12);
+COMPILE_ASSERT(offsetof(GetInternalformativ, bufSize) == 16,
+               OffsetOf_GetInternalformativ_bufSize_not_16);
+COMPILE_ASSERT(offsetof(GetInternalformativ, params_shm_id) == 20,
+               OffsetOf_GetInternalformativ_params_shm_id_not_20);
+COMPILE_ASSERT(offsetof(GetInternalformativ, params_shm_offset) == 24,
+               OffsetOf_GetInternalformativ_params_shm_offset_not_24);
+
 struct GetProgramiv {
   typedef GetProgramiv ValueType;
   static const CommandId kCmdId = kGetProgramiv;
@@ -5093,6 +5278,70 @@ COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4,
 COMPILE_ASSERT(offsetof(TexParameterivImmediate, pname) == 8,
                OffsetOf_TexParameterivImmediate_pname_not_8);
 
+struct TexStorage3D {
+  typedef TexStorage3D ValueType;
+  static const CommandId kCmdId = kTexStorage3D;
+  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 _levels,
+            GLenum _internalFormat,
+            GLsizei _width,
+            GLsizei _height,
+            GLsizei _depth) {
+    SetHeader();
+    target = _target;
+    levels = _levels;
+    internalFormat = _internalFormat;
+    width = _width;
+    height = _height;
+    depth = _depth;
+  }
+
+  void* Set(void* cmd,
+            GLenum _target,
+            GLsizei _levels,
+            GLenum _internalFormat,
+            GLsizei _width,
+            GLsizei _height,
+            GLsizei _depth) {
+    static_cast<ValueType*>(cmd)
+        ->Init(_target, _levels, _internalFormat, _width, _height, _depth);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t target;
+  int32_t levels;
+  uint32_t internalFormat;
+  int32_t width;
+  int32_t height;
+  int32_t depth;
+};
+
+COMPILE_ASSERT(sizeof(TexStorage3D) == 28, Sizeof_TexStorage3D_is_not_28);
+COMPILE_ASSERT(offsetof(TexStorage3D, header) == 0,
+               OffsetOf_TexStorage3D_header_not_0);
+COMPILE_ASSERT(offsetof(TexStorage3D, target) == 4,
+               OffsetOf_TexStorage3D_target_not_4);
+COMPILE_ASSERT(offsetof(TexStorage3D, levels) == 8,
+               OffsetOf_TexStorage3D_levels_not_8);
+COMPILE_ASSERT(offsetof(TexStorage3D, internalFormat) == 12,
+               OffsetOf_TexStorage3D_internalFormat_not_12);
+COMPILE_ASSERT(offsetof(TexStorage3D, width) == 16,
+               OffsetOf_TexStorage3D_width_not_16);
+COMPILE_ASSERT(offsetof(TexStorage3D, height) == 20,
+               OffsetOf_TexStorage3D_height_not_20);
+COMPILE_ASSERT(offsetof(TexStorage3D, depth) == 24,
+               OffsetOf_TexStorage3D_depth_not_24);
+
 struct TexSubImage2D {
   typedef TexSubImage2D ValueType;
   static const CommandId kCmdId = kTexSubImage2D;
@@ -5350,6 +5599,87 @@ COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8,
                OffsetOf_Uniform1ivImmediate_count_not_8);
 
+struct Uniform1ui {
+  typedef Uniform1ui ValueType;
+  static const CommandId kCmdId = kUniform1ui;
+  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, GLuint _x) {
+    SetHeader();
+    location = _location;
+    x = _x;
+  }
+
+  void* Set(void* cmd, GLint _location, GLuint _x) {
+    static_cast<ValueType*>(cmd)->Init(_location, _x);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  uint32_t x;
+};
+
+COMPILE_ASSERT(sizeof(Uniform1ui) == 12, Sizeof_Uniform1ui_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform1ui, header) == 0,
+               OffsetOf_Uniform1ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform1ui, location) == 4,
+               OffsetOf_Uniform1ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform1ui, x) == 8, OffsetOf_Uniform1ui_x_not_8);
+
+struct Uniform1uivImmediate {
+  typedef Uniform1uivImmediate ValueType;
+  static const CommandId kCmdId = kUniform1uivImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLuint) * 1 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLuint* _v) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform1uivImmediate) == 12,
+               Sizeof_Uniform1uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform1uivImmediate, header) == 0,
+               OffsetOf_Uniform1uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform1uivImmediate, location) == 4,
+               OffsetOf_Uniform1uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform1uivImmediate, count) == 8,
+               OffsetOf_Uniform1uivImmediate_count_not_8);
+
 struct Uniform2f {
   typedef Uniform2f ValueType;
   static const CommandId kCmdId = kUniform2f;
@@ -5518,6 +5848,90 @@ COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8,
                OffsetOf_Uniform2ivImmediate_count_not_8);
 
+struct Uniform2ui {
+  typedef Uniform2ui ValueType;
+  static const CommandId kCmdId = kUniform2ui;
+  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, GLuint _x, GLuint _y) {
+    SetHeader();
+    location = _location;
+    x = _x;
+    y = _y;
+  }
+
+  void* Set(void* cmd, GLint _location, GLuint _x, GLuint _y) {
+    static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  uint32_t x;
+  uint32_t y;
+};
+
+COMPILE_ASSERT(sizeof(Uniform2ui) == 16, Sizeof_Uniform2ui_is_not_16);
+COMPILE_ASSERT(offsetof(Uniform2ui, header) == 0,
+               OffsetOf_Uniform2ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform2ui, location) == 4,
+               OffsetOf_Uniform2ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform2ui, x) == 8, OffsetOf_Uniform2ui_x_not_8);
+COMPILE_ASSERT(offsetof(Uniform2ui, y) == 12, OffsetOf_Uniform2ui_y_not_12);
+
+struct Uniform2uivImmediate {
+  typedef Uniform2uivImmediate ValueType;
+  static const CommandId kCmdId = kUniform2uivImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLuint) * 2 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLuint* _v) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform2uivImmediate) == 12,
+               Sizeof_Uniform2uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform2uivImmediate, header) == 0,
+               OffsetOf_Uniform2uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform2uivImmediate, location) == 4,
+               OffsetOf_Uniform2uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform2uivImmediate, count) == 8,
+               OffsetOf_Uniform2uivImmediate_count_not_8);
+
 struct Uniform3f {
   typedef Uniform3f ValueType;
   static const CommandId kCmdId = kUniform3f;
@@ -5692,9 +6106,9 @@ COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8,
                OffsetOf_Uniform3ivImmediate_count_not_8);
 
-struct Uniform4f {
-  typedef Uniform4f ValueType;
-  static const CommandId kCmdId = kUniform4f;
+struct Uniform3ui {
+  typedef Uniform3ui ValueType;
+  static const CommandId kCmdId = kUniform3ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
@@ -5704,7 +6118,94 @@ struct Uniform4f {
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
-  void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
+  void Init(GLint _location, GLuint _x, GLuint _y, GLuint _z) {
+    SetHeader();
+    location = _location;
+    x = _x;
+    y = _y;
+    z = _z;
+  }
+
+  void* Set(void* cmd, GLint _location, GLuint _x, GLuint _y, GLuint _z) {
+    static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  uint32_t x;
+  uint32_t y;
+  uint32_t z;
+};
+
+COMPILE_ASSERT(sizeof(Uniform3ui) == 20, Sizeof_Uniform3ui_is_not_20);
+COMPILE_ASSERT(offsetof(Uniform3ui, header) == 0,
+               OffsetOf_Uniform3ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform3ui, location) == 4,
+               OffsetOf_Uniform3ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform3ui, x) == 8, OffsetOf_Uniform3ui_x_not_8);
+COMPILE_ASSERT(offsetof(Uniform3ui, y) == 12, OffsetOf_Uniform3ui_y_not_12);
+COMPILE_ASSERT(offsetof(Uniform3ui, z) == 16, OffsetOf_Uniform3ui_z_not_16);
+
+struct Uniform3uivImmediate {
+  typedef Uniform3uivImmediate ValueType;
+  static const CommandId kCmdId = kUniform3uivImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLuint) * 3 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLuint* _v) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform3uivImmediate) == 12,
+               Sizeof_Uniform3uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform3uivImmediate, header) == 0,
+               OffsetOf_Uniform3uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform3uivImmediate, location) == 4,
+               OffsetOf_Uniform3uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform3uivImmediate, count) == 8,
+               OffsetOf_Uniform3uivImmediate_count_not_8);
+
+struct Uniform4f {
+  typedef Uniform4f ValueType;
+  static const CommandId kCmdId = kUniform4f;
+  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, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
     SetHeader();
     location = _location;
     x = _x;
@@ -5882,6 +6383,101 @@ COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8,
                OffsetOf_Uniform4ivImmediate_count_not_8);
 
+struct Uniform4ui {
+  typedef Uniform4ui ValueType;
+  static const CommandId kCmdId = kUniform4ui;
+  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, GLuint _x, GLuint _y, GLuint _z, GLuint _w) {
+    SetHeader();
+    location = _location;
+    x = _x;
+    y = _y;
+    z = _z;
+    w = _w;
+  }
+
+  void* Set(void* cmd,
+            GLint _location,
+            GLuint _x,
+            GLuint _y,
+            GLuint _z,
+            GLuint _w) {
+    static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  uint32_t x;
+  uint32_t y;
+  uint32_t z;
+  uint32_t w;
+};
+
+COMPILE_ASSERT(sizeof(Uniform4ui) == 24, Sizeof_Uniform4ui_is_not_24);
+COMPILE_ASSERT(offsetof(Uniform4ui, header) == 0,
+               OffsetOf_Uniform4ui_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform4ui, location) == 4,
+               OffsetOf_Uniform4ui_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform4ui, x) == 8, OffsetOf_Uniform4ui_x_not_8);
+COMPILE_ASSERT(offsetof(Uniform4ui, y) == 12, OffsetOf_Uniform4ui_y_not_12);
+COMPILE_ASSERT(offsetof(Uniform4ui, z) == 16, OffsetOf_Uniform4ui_z_not_16);
+COMPILE_ASSERT(offsetof(Uniform4ui, w) == 20, OffsetOf_Uniform4ui_w_not_20);
+
+struct Uniform4uivImmediate {
+  typedef Uniform4uivImmediate ValueType;
+  static const CommandId kCmdId = kUniform4uivImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLuint) * 4 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLuint* _v) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLuint* _v) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+};
+
+COMPILE_ASSERT(sizeof(Uniform4uivImmediate) == 12,
+               Sizeof_Uniform4uivImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(Uniform4uivImmediate, header) == 0,
+               OffsetOf_Uniform4uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(Uniform4uivImmediate, location) == 4,
+               OffsetOf_Uniform4uivImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(Uniform4uivImmediate, count) == 8,
+               OffsetOf_Uniform4uivImmediate_count_not_8);
+
 struct UniformMatrix2fvImmediate {
   typedef UniformMatrix2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2fvImmediate;
@@ -5929,6 +6525,100 @@ COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8,
                OffsetOf_UniformMatrix2fvImmediate_count_not_8);
 
+struct UniformMatrix2x3fvImmediate {
+  typedef UniformMatrix2x3fvImmediate ValueType;
+  static const CommandId kCmdId = kUniformMatrix2x3fvImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLfloat) * 6 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+  static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix2x3fvImmediate) == 12,
+               Sizeof_UniformMatrix2x3fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix2x3fvImmediate, header) == 0,
+               OffsetOf_UniformMatrix2x3fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix2x3fvImmediate, location) == 4,
+               OffsetOf_UniformMatrix2x3fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix2x3fvImmediate, count) == 8,
+               OffsetOf_UniformMatrix2x3fvImmediate_count_not_8);
+
+struct UniformMatrix2x4fvImmediate {
+  typedef UniformMatrix2x4fvImmediate ValueType;
+  static const CommandId kCmdId = kUniformMatrix2x4fvImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLfloat) * 8 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+  static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix2x4fvImmediate) == 12,
+               Sizeof_UniformMatrix2x4fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix2x4fvImmediate, header) == 0,
+               OffsetOf_UniformMatrix2x4fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix2x4fvImmediate, location) == 4,
+               OffsetOf_UniformMatrix2x4fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix2x4fvImmediate, count) == 8,
+               OffsetOf_UniformMatrix2x4fvImmediate_count_not_8);
+
 struct UniformMatrix3fvImmediate {
   typedef UniformMatrix3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3fvImmediate;
@@ -5976,6 +6666,100 @@ COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8,
                OffsetOf_UniformMatrix3fvImmediate_count_not_8);
 
+struct UniformMatrix3x2fvImmediate {
+  typedef UniformMatrix3x2fvImmediate ValueType;
+  static const CommandId kCmdId = kUniformMatrix3x2fvImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLfloat) * 6 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+  static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix3x2fvImmediate) == 12,
+               Sizeof_UniformMatrix3x2fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix3x2fvImmediate, header) == 0,
+               OffsetOf_UniformMatrix3x2fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix3x2fvImmediate, location) == 4,
+               OffsetOf_UniformMatrix3x2fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix3x2fvImmediate, count) == 8,
+               OffsetOf_UniformMatrix3x2fvImmediate_count_not_8);
+
+struct UniformMatrix3x4fvImmediate {
+  typedef UniformMatrix3x4fvImmediate ValueType;
+  static const CommandId kCmdId = kUniformMatrix3x4fvImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLfloat) * 12 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+  static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix3x4fvImmediate) == 12,
+               Sizeof_UniformMatrix3x4fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix3x4fvImmediate, header) == 0,
+               OffsetOf_UniformMatrix3x4fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix3x4fvImmediate, location) == 4,
+               OffsetOf_UniformMatrix3x4fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix3x4fvImmediate, count) == 8,
+               OffsetOf_UniformMatrix3x4fvImmediate_count_not_8);
+
 struct UniformMatrix4fvImmediate {
   typedef UniformMatrix4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4fvImmediate;
@@ -6023,6 +6807,100 @@ COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4,
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8,
                OffsetOf_UniformMatrix4fvImmediate_count_not_8);
 
+struct UniformMatrix4x2fvImmediate {
+  typedef UniformMatrix4x2fvImmediate ValueType;
+  static const CommandId kCmdId = kUniformMatrix4x2fvImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLfloat) * 8 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+  static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix4x2fvImmediate) == 12,
+               Sizeof_UniformMatrix4x2fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix4x2fvImmediate, header) == 0,
+               OffsetOf_UniformMatrix4x2fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix4x2fvImmediate, location) == 4,
+               OffsetOf_UniformMatrix4x2fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix4x2fvImmediate, count) == 8,
+               OffsetOf_UniformMatrix4x2fvImmediate_count_not_8);
+
+struct UniformMatrix4x3fvImmediate {
+  typedef UniformMatrix4x3fvImmediate ValueType;
+  static const CommandId kCmdId = kUniformMatrix4x3fvImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(GLfloat) * 12 * count);  // NOLINT
+  }
+
+  static uint32_t ComputeSize(GLsizei count) {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize(count));  // NOLINT
+  }
+
+  void SetHeader(GLsizei count) {
+    header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
+  }
+
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
+    SetHeader(_count);
+    location = _location;
+    count = _count;
+    memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
+  }
+
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
+    const uint32_t size = ComputeSize(_count);
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  int32_t location;
+  int32_t count;
+  static const uint32_t transpose = false;
+};
+
+COMPILE_ASSERT(sizeof(UniformMatrix4x3fvImmediate) == 12,
+               Sizeof_UniformMatrix4x3fvImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix4x3fvImmediate, header) == 0,
+               OffsetOf_UniformMatrix4x3fvImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(UniformMatrix4x3fvImmediate, location) == 4,
+               OffsetOf_UniformMatrix4x3fvImmediate_location_not_4);
+COMPILE_ASSERT(offsetof(UniformMatrix4x3fvImmediate, count) == 8,
+               OffsetOf_UniformMatrix4x3fvImmediate_count_not_8);
+
 struct UseProgram {
   typedef UseProgram ValueType;
   static const CommandId kCmdId = kUseProgram;
@@ -6420,6 +7298,246 @@ COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0,
 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4,
                OffsetOf_VertexAttrib4fvImmediate_indx_not_4);
 
+struct VertexAttribI4i {
+  typedef VertexAttribI4i ValueType;
+  static const CommandId kCmdId = kVertexAttribI4i;
+  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, GLint _x, GLint _y, GLint _z, GLint _w) {
+    SetHeader();
+    indx = _indx;
+    x = _x;
+    y = _y;
+    z = _z;
+    w = _w;
+  }
+
+  void* Set(void* cmd, GLuint _indx, GLint _x, GLint _y, GLint _z, GLint _w) {
+    static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t indx;
+  int32_t x;
+  int32_t y;
+  int32_t z;
+  int32_t w;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4i) == 24, Sizeof_VertexAttribI4i_is_not_24);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, header) == 0,
+               OffsetOf_VertexAttribI4i_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, indx) == 4,
+               OffsetOf_VertexAttribI4i_indx_not_4);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, x) == 8,
+               OffsetOf_VertexAttribI4i_x_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, y) == 12,
+               OffsetOf_VertexAttribI4i_y_not_12);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, z) == 16,
+               OffsetOf_VertexAttribI4i_z_not_16);
+COMPILE_ASSERT(offsetof(VertexAttribI4i, w) == 20,
+               OffsetOf_VertexAttribI4i_w_not_20);
+
+struct VertexAttribI4ivImmediate {
+  typedef VertexAttribI4ivImmediate ValueType;
+  static const CommandId kCmdId = kVertexAttribI4ivImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize() {
+    return static_cast<uint32_t>(sizeof(GLint) * 4);  // NOLINT
+  }
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize());  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+  void Init(GLuint _indx, const GLint* _values) {
+    SetHeader();
+    indx = _indx;
+    memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
+  }
+
+  void* Set(void* cmd, GLuint _indx, const GLint* _values) {
+    static_cast<ValueType*>(cmd)->Init(_indx, _values);
+    const uint32_t size = ComputeSize();
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t indx;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4ivImmediate) == 8,
+               Sizeof_VertexAttribI4ivImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4ivImmediate, header) == 0,
+               OffsetOf_VertexAttribI4ivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4ivImmediate, indx) == 4,
+               OffsetOf_VertexAttribI4ivImmediate_indx_not_4);
+
+struct VertexAttribI4ui {
+  typedef VertexAttribI4ui ValueType;
+  static const CommandId kCmdId = kVertexAttribI4ui;
+  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, GLuint _x, GLuint _y, GLuint _z, GLuint _w) {
+    SetHeader();
+    indx = _indx;
+    x = _x;
+    y = _y;
+    z = _z;
+    w = _w;
+  }
+
+  void* Set(void* cmd,
+            GLuint _indx,
+            GLuint _x,
+            GLuint _y,
+            GLuint _z,
+            GLuint _w) {
+    static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t indx;
+  uint32_t x;
+  uint32_t y;
+  uint32_t z;
+  uint32_t w;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4ui) == 24,
+               Sizeof_VertexAttribI4ui_is_not_24);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, header) == 0,
+               OffsetOf_VertexAttribI4ui_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, indx) == 4,
+               OffsetOf_VertexAttribI4ui_indx_not_4);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, x) == 8,
+               OffsetOf_VertexAttribI4ui_x_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, y) == 12,
+               OffsetOf_VertexAttribI4ui_y_not_12);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, z) == 16,
+               OffsetOf_VertexAttribI4ui_z_not_16);
+COMPILE_ASSERT(offsetof(VertexAttribI4ui, w) == 20,
+               OffsetOf_VertexAttribI4ui_w_not_20);
+
+struct VertexAttribI4uivImmediate {
+  typedef VertexAttribI4uivImmediate ValueType;
+  static const CommandId kCmdId = kVertexAttribI4uivImmediate;
+  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeDataSize() {
+    return static_cast<uint32_t>(sizeof(GLuint) * 4);  // NOLINT
+  }
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType) +
+                                 ComputeDataSize());  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
+
+  void Init(GLuint _indx, const GLuint* _values) {
+    SetHeader();
+    indx = _indx;
+    memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
+  }
+
+  void* Set(void* cmd, GLuint _indx, const GLuint* _values) {
+    static_cast<ValueType*>(cmd)->Init(_indx, _values);
+    const uint32_t size = ComputeSize();
+    return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t indx;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribI4uivImmediate) == 8,
+               Sizeof_VertexAttribI4uivImmediate_is_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribI4uivImmediate, header) == 0,
+               OffsetOf_VertexAttribI4uivImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribI4uivImmediate, indx) == 4,
+               OffsetOf_VertexAttribI4uivImmediate_indx_not_4);
+
+struct VertexAttribIPointer {
+  typedef VertexAttribIPointer ValueType;
+  static const CommandId kCmdId = kVertexAttribIPointer;
+  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,
+            GLint _size,
+            GLenum _type,
+            GLsizei _stride,
+            GLuint _offset) {
+    SetHeader();
+    indx = _indx;
+    size = _size;
+    type = _type;
+    stride = _stride;
+    offset = _offset;
+  }
+
+  void* Set(void* cmd,
+            GLuint _indx,
+            GLint _size,
+            GLenum _type,
+            GLsizei _stride,
+            GLuint _offset) {
+    static_cast<ValueType*>(cmd)->Init(_indx, _size, _type, _stride, _offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t indx;
+  int32_t size;
+  uint32_t type;
+  int32_t stride;
+  uint32_t offset;
+};
+
+COMPILE_ASSERT(sizeof(VertexAttribIPointer) == 24,
+               Sizeof_VertexAttribIPointer_is_not_24);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, header) == 0,
+               OffsetOf_VertexAttribIPointer_header_not_0);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, indx) == 4,
+               OffsetOf_VertexAttribIPointer_indx_not_4);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, size) == 8,
+               OffsetOf_VertexAttribIPointer_size_not_8);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, type) == 12,
+               OffsetOf_VertexAttribIPointer_type_not_12);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, stride) == 16,
+               OffsetOf_VertexAttribIPointer_stride_not_16);
+COMPILE_ASSERT(offsetof(VertexAttribIPointer, offset) == 20,
+               OffsetOf_VertexAttribIPointer_offset_not_20);
+
 struct VertexAttribPointer {
   typedef VertexAttribPointer ValueType;
   static const CommandId kCmdId = kVertexAttribPointer;