Another round of gcc fixes for GPU command buffers.

gpu/command_buffer/common/gles2_cmd_format_autogen.h

 // This file is auto-generated. DO NOT EDIT!
 
 #pragma pack(push, 1)
 
 struct ActiveTexture {
   typedef ActiveTexture ValueType;
   static const CommandId kCmdId = kActiveTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   static uint32 ComputeSize() {
@@ skipping 896 matching lines @@
     SetHeader();
     s = _s;
   }
 
   void* Set(void* cmd, GLint _s) {
     static_cast<ValueType*>(cmd)->Init(_s);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 s;
+  int32 s;
 };
 
 COMPILE_ASSERT(sizeof(ClearStencil) == 8,
                Sizeof_ClearStencil_is_not_8);
 COMPILE_ASSERT(offsetof(ClearStencil, header) == 0,
                OffsetOf_ClearStencil_header_not_0);
 COMPILE_ASSERT(offsetof(ClearStencil, s) == 4,
                OffsetOf_ClearStencil_s_not_4);
 
 struct ColorMask {
@@ skipping 114 matching lines @@
       uint32 _data_shm_id, uint32 _data_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border,
             _imageSize, _data_shm_id, _data_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
+  int32 level;
   uint32 internalformat;
-  uint32 width;
-  uint32 height;
-  uint32 border;
-  uint32 imageSize;
+  int32 width;
+  int32 height;
+  int32 border;
+  int32 imageSize;
   uint32 data_shm_id;
   uint32 data_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 40,
                Sizeof_CompressedTexImage2D_is_not_40);
 COMPILE_ASSERT(offsetof(CompressedTexImage2D, header) == 0,
                OffsetOf_CompressedTexImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(CompressedTexImage2D, target) == 4,
                OffsetOf_CompressedTexImage2D_target_not_4);
@@ skipping 49 matching lines @@
     uint32 total_size = 0;  // TODO(gman): get correct size.
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border,
             _imageSize);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
+  int32 level;
   uint32 internalformat;
-  uint32 width;
-  uint32 height;
-  uint32 border;
-  uint32 imageSize;
+  int32 width;
+  int32 height;
+  int32 border;
+  int32 imageSize;
 };
 
 COMPILE_ASSERT(sizeof(CompressedTexImage2DImmediate) == 32,
                Sizeof_CompressedTexImage2DImmediate_is_not_32);
 COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, header) == 0,
                OffsetOf_CompressedTexImage2DImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, target) == 4,
                OffsetOf_CompressedTexImage2DImmediate_target_not_4);
 COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, level) == 8,
                OffsetOf_CompressedTexImage2DImmediate_level_not_8);
@@ skipping 44 matching lines @@
       uint32 _data_shm_id, uint32 _data_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _imageSize, _data_shm_id, _data_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 xoffset;
-  uint32 yoffset;
-  uint32 width;
-  uint32 height;
+  int32 level;
+  int32 xoffset;
+  int32 yoffset;
+  int32 width;
+  int32 height;
   uint32 format;
-  uint32 imageSize;
+  int32 imageSize;
   uint32 data_shm_id;
   uint32 data_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(CompressedTexSubImage2D) == 44,
                Sizeof_CompressedTexSubImage2D_is_not_44);
 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, header) == 0,
                OffsetOf_CompressedTexSubImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, target) == 4,
                OffsetOf_CompressedTexSubImage2D_target_not_4);
@@ skipping 52 matching lines @@
     uint32 total_size = ComputeSize(_imageSize);
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _imageSize);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 xoffset;
-  uint32 yoffset;
-  uint32 width;
-  uint32 height;
+  int32 level;
+  int32 xoffset;
+  int32 yoffset;
+  int32 width;
+  int32 height;
   uint32 format;
-  uint32 imageSize;
+  int32 imageSize;
 };
 
 COMPILE_ASSERT(sizeof(CompressedTexSubImage2DImmediate) == 36,
                Sizeof_CompressedTexSubImage2DImmediate_is_not_36);
 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, header) == 0,
                OffsetOf_CompressedTexSubImage2DImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, target) == 4,
                OffsetOf_CompressedTexSubImage2DImmediate_target_not_4);
 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, level) == 8,
                OffsetOf_CompressedTexSubImage2DImmediate_level_not_8);
@@ skipping 42 matching lines @@
       GLint _y, GLsizei _width, GLsizei _height, GLint _border) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _x, _y, _width, _height,
             _border);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
+  int32 level;
   uint32 internalformat;
-  uint32 x;
-  uint32 y;
-  uint32 width;
-  uint32 height;
-  uint32 border;
+  int32 x;
+  int32 y;
+  int32 width;
+  int32 height;
+  int32 border;
 };
 
 COMPILE_ASSERT(sizeof(CopyTexImage2D) == 36,
                Sizeof_CopyTexImage2D_is_not_36);
 COMPILE_ASSERT(offsetof(CopyTexImage2D, header) == 0,
                OffsetOf_CopyTexImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(CopyTexImage2D, target) == 4,
                OffsetOf_CopyTexImage2D_target_not_4);
 COMPILE_ASSERT(offsetof(CopyTexImage2D, level) == 8,
                OffsetOf_CopyTexImage2D_level_not_8);
@@ skipping 41 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset,
       GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 xoffset;
-  uint32 yoffset;
-  uint32 x;
-  uint32 y;
-  uint32 width;
-  uint32 height;
+  int32 level;
+  int32 xoffset;
+  int32 yoffset;
+  int32 x;
+  int32 y;
+  int32 width;
+  int32 height;
 };
 
 COMPILE_ASSERT(sizeof(CopyTexSubImage2D) == 36,
                Sizeof_CopyTexSubImage2D_is_not_36);
 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, header) == 0,
                OffsetOf_CopyTexSubImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, target) == 4,
                OffsetOf_CopyTexSubImage2D_target_not_4);
 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, level) == 8,
                OffsetOf_CopyTexSubImage2D_level_not_8);
@@ skipping 138 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _buffers_shm_id,
       uint32 _buffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 buffers_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _buffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8,
                Sizeof_DeleteBuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0,
                OffsetOf_DeleteBuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4,
                OffsetOf_DeleteBuffersImmediate_n_not_4);
 
 struct DeleteFramebuffers {
@@ skipping 20 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _framebuffers_shm_id,
       uint32 _framebuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 framebuffers_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _framebuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8,
                Sizeof_DeleteFramebuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, header) == 0,
                OffsetOf_DeleteFramebuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, n) == 4,
                OffsetOf_DeleteFramebuffersImmediate_n_not_4);
 
 struct DeleteProgram {
@@ skipping 54 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id,
       uint32 _renderbuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 renderbuffers_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _renderbuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8,
                Sizeof_DeleteRenderbuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, header) == 0,
                OffsetOf_DeleteRenderbuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, n) == 4,
                OffsetOf_DeleteRenderbuffersImmediate_n_not_4);
 
 struct DeleteShader {
@@ skipping 52 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _textures_shm_id,
       uint32 _textures_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _textures_shm_id, _textures_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 textures_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _textures, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _textures) {
     static_cast<ValueType*>(cmd)->Init(_n, _textures);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8,
                Sizeof_DeleteTexturesImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, header) == 0,
                OffsetOf_DeleteTexturesImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, n) == 4,
                OffsetOf_DeleteTexturesImmediate_n_not_4);
 
 struct DepthFunc {
@@ skipping 228 matching lines @@
     count = _count;
   }
 
   void* Set(void* cmd, GLenum _mode, GLint _first, GLsizei _count) {
     static_cast<ValueType*>(cmd)->Init(_mode, _first, _count);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 mode;
-  uint32 first;
-  uint32 count;
+  int32 first;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(DrawArrays) == 16,
                Sizeof_DrawArrays_is_not_16);
 COMPILE_ASSERT(offsetof(DrawArrays, header) == 0,
                OffsetOf_DrawArrays_header_not_0);
 COMPILE_ASSERT(offsetof(DrawArrays, mode) == 4,
                OffsetOf_DrawArrays_mode_not_4);
 COMPILE_ASSERT(offsetof(DrawArrays, first) == 8,
                OffsetOf_DrawArrays_first_not_8);
@@ skipping 23 matching lines @@
 
   void* Set(
       void* cmd, GLenum _mode, GLsizei _count, GLenum _type,
       GLuint _index_offset) {
     static_cast<ValueType*>(cmd)->Init(_mode, _count, _type, _index_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 mode;
-  uint32 count;
+  int32 count;
   uint32 type;
   uint32 index_offset;
 };
 
 COMPILE_ASSERT(sizeof(DrawElements) == 20,
                Sizeof_DrawElements_is_not_20);
 COMPILE_ASSERT(offsetof(DrawElements, header) == 0,
                OffsetOf_DrawElements_header_not_0);
 COMPILE_ASSERT(offsetof(DrawElements, mode) == 4,
                OffsetOf_DrawElements_mode_not_4);
@@ skipping 213 matching lines @@
     static_cast<ValueType*>(
         cmd)->Init(_target, _attachment, _textarget, _texture, _level);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
   uint32 attachment;
   uint32 textarget;
   uint32 texture;
-  uint32 level;
+  int32 level;
 };
 
 COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 24,
                Sizeof_FramebufferTexture2D_is_not_24);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0,
                OffsetOf_FramebufferTexture2D_header_not_0);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, target) == 4,
                OffsetOf_FramebufferTexture2D_target_not_4);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, attachment) == 8,
                OffsetOf_FramebufferTexture2D_attachment_not_8);
@@ skipping 60 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _buffers_shm_id,
       uint32 _buffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 buffers_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _buffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _buffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8,
                Sizeof_GenBuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenBuffersImmediate, header) == 0,
                OffsetOf_GenBuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenBuffersImmediate, n) == 4,
                OffsetOf_GenBuffersImmediate_n_not_4);
 
 struct GenerateMipmap {
@@ skipping 54 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _framebuffers_shm_id,
       uint32 _framebuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 framebuffers_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _framebuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8,
                Sizeof_GenFramebuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0,
                OffsetOf_GenFramebuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4,
                OffsetOf_GenFramebuffersImmediate_n_not_4);
 
 struct GenRenderbuffers {
@@ skipping 20 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id,
       uint32 _renderbuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 renderbuffers_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _renderbuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8,
                Sizeof_GenRenderbuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0,
                OffsetOf_GenRenderbuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4,
                OffsetOf_GenRenderbuffersImmediate_n_not_4);
 
 struct GenTextures {
@@ skipping 18 matching lines @@
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _textures_shm_id,
       uint32 _textures_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _textures_shm_id, _textures_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
   uint32 textures_shm_id;
   uint32 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);
@@ skipping 27 matching lines @@
            _textures, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _textures) {
     static_cast<ValueType*>(cmd)->Init(_n, _textures);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 n;
+  int32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8,
                Sizeof_GenTexturesImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenTexturesImmediate, header) == 0,
                OffsetOf_GenTexturesImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenTexturesImmediate, n) == 4,
                OffsetOf_GenTexturesImmediate_n_not_4);
 
 struct GetActiveAttrib {
@@ skipping 37 matching lines @@
         cmd)->Init(
             _program, _index, _bufsize, _length_shm_id, _length_shm_offset,
             _size_shm_id, _size_shm_offset, _type_shm_id, _type_shm_offset,
             _name_shm_id, _name_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 program;
   uint32 index;
-  uint32 bufsize;
+  int32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 size_shm_id;
   uint32 size_shm_offset;
   uint32 type_shm_id;
   uint32 type_shm_offset;
   uint32 name_shm_id;
   uint32 name_shm_offset;
 };
 
@@ skipping 65 matching lines @@
         cmd)->Init(
             _program, _index, _bufsize, _length_shm_id, _length_shm_offset,
             _size_shm_id, _size_shm_offset, _type_shm_id, _type_shm_offset,
             _name_shm_id, _name_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 program;
   uint32 index;
-  uint32 bufsize;
+  int32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 size_shm_id;
   uint32 size_shm_offset;
   uint32 type_shm_id;
   uint32 type_shm_offset;
   uint32 name_shm_id;
   uint32 name_shm_offset;
 };
 
@@ skipping 56 matching lines @@
       uint32 _shaders_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _maxcount, _count_shm_id, _count_shm_offset,
             _shaders_shm_id, _shaders_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 program;
-  uint32 maxcount;
+  int32 maxcount;
   uint32 count_shm_id;
   uint32 count_shm_offset;
   uint32 shaders_shm_id;
   uint32 shaders_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetAttachedShaders) == 28,
                Sizeof_GetAttachedShaders_is_not_28);
 COMPILE_ASSERT(offsetof(GetAttachedShaders, header) == 0,
                OffsetOf_GetAttachedShaders_header_not_0);
@@ skipping 375 matching lines @@
       uint32 _infolog_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _bufsize, _length_shm_id, _length_shm_offset,
             _infolog_shm_id, _infolog_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 program;
-  uint32 bufsize;
+  int32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 infolog_shm_id;
   uint32 infolog_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 28,
                Sizeof_GetProgramInfoLog_is_not_28);
 COMPILE_ASSERT(offsetof(GetProgramInfoLog, header) == 0,
                OffsetOf_GetProgramInfoLog_header_not_0);
@@ skipping 144 matching lines @@
       uint32 _infolog_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shader, _bufsize, _length_shm_id, _length_shm_offset,
             _infolog_shm_id, _infolog_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 shader;
-  uint32 bufsize;
+  int32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 infolog_shm_id;
   uint32 infolog_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 28,
                Sizeof_GetShaderInfoLog_is_not_28);
 COMPILE_ASSERT(offsetof(GetShaderInfoLog, header) == 0,
                OffsetOf_GetShaderInfoLog_header_not_0);
@@ skipping 105 matching lines @@
       uint32 _source_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shader, _bufsize, _length_shm_id, _length_shm_offset,
             _source_shm_id, _source_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 shader;
-  uint32 bufsize;
+  int32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 source_shm_id;
   uint32 source_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetShaderSource) == 28,
                Sizeof_GetShaderSource_is_not_28);
 COMPILE_ASSERT(offsetof(GetShaderSource, header) == 0,
                OffsetOf_GetShaderSource_header_not_0);
@@ skipping 172 matching lines @@
   void* Set(
       void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 program;
-  uint32 location;
+  int32 location;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetUniformfv) == 20,
                Sizeof_GetUniformfv_is_not_20);
 COMPILE_ASSERT(offsetof(GetUniformfv, header) == 0,
                OffsetOf_GetUniformfv_header_not_0);
 COMPILE_ASSERT(offsetof(GetUniformfv, program) == 4,
                OffsetOf_GetUniformfv_program_not_4);
@@ skipping 30 matching lines @@
   void* Set(
       void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 program;
-  uint32 location;
+  int32 location;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetUniformiv) == 20,
                Sizeof_GetUniformiv_is_not_20);
 COMPILE_ASSERT(offsetof(GetUniformiv, header) == 0,
                OffsetOf_GetUniformiv_header_not_0);
 COMPILE_ASSERT(offsetof(GetUniformiv, program) == 4,
                OffsetOf_GetUniformiv_program_not_4);
@@ skipping 601 matching lines @@
     param = _param;
   }
 
   void* Set(void* cmd, GLenum _pname, GLint _param) {
     static_cast<ValueType*>(cmd)->Init(_pname, _param);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 pname;
-  uint32 param;
+  int32 param;
 };
 
 COMPILE_ASSERT(sizeof(PixelStorei) == 12,
                Sizeof_PixelStorei_is_not_12);
 COMPILE_ASSERT(offsetof(PixelStorei, header) == 0,
                OffsetOf_PixelStorei_header_not_0);
 COMPILE_ASSERT(offsetof(PixelStorei, pname) == 4,
                OffsetOf_PixelStorei_pname_not_4);
 COMPILE_ASSERT(offsetof(PixelStorei, param) == 8,
                OffsetOf_PixelStorei_param_not_8);
@@ skipping 68 matching lines @@
       GLenum _format, GLenum _type, uint32 _pixels_shm_id,
       uint32 _pixels_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _x, _y, _width, _height, _format, _type, _pixels_shm_id,
             _pixels_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 x;
-  uint32 y;
-  uint32 width;
-  uint32 height;
+  int32 x;
+  int32 y;
+  int32 width;
+  int32 height;
   uint32 format;
   uint32 type;
   uint32 pixels_shm_id;
   uint32 pixels_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(ReadPixels) == 36,
                Sizeof_ReadPixels_is_not_36);
 COMPILE_ASSERT(offsetof(ReadPixels, header) == 0,
                OffsetOf_ReadPixels_header_not_0);
@@ skipping 41 matching lines @@
       void* cmd, GLenum _target, GLenum _internalformat, GLsizei _width,
       GLsizei _height) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _internalformat, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
   uint32 internalformat;
-  uint32 width;
-  uint32 height;
+  int32 width;
+  int32 height;
 };
 
 COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20,
                Sizeof_RenderbufferStorage_is_not_20);
 COMPILE_ASSERT(offsetof(RenderbufferStorage, header) == 0,
                OffsetOf_RenderbufferStorage_header_not_0);
 COMPILE_ASSERT(offsetof(RenderbufferStorage, target) == 4,
                OffsetOf_RenderbufferStorage_target_not_4);
 COMPILE_ASSERT(offsetof(RenderbufferStorage, internalformat) == 8,
                OffsetOf_RenderbufferStorage_internalformat_not_8);
@@ skipping 60 matching lines @@
     width = _width;
     height = _height;
   }
 
   void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 x;
-  uint32 y;
-  uint32 width;
-  uint32 height;
+  int32 x;
+  int32 y;
+  int32 width;
+  int32 height;
 };
 
 COMPILE_ASSERT(sizeof(Scissor) == 20,
                Sizeof_Scissor_is_not_20);
 COMPILE_ASSERT(offsetof(Scissor, header) == 0,
                OffsetOf_Scissor_header_not_0);
 COMPILE_ASSERT(offsetof(Scissor, x) == 4,
                OffsetOf_Scissor_x_not_4);
 COMPILE_ASSERT(offsetof(Scissor, y) == 8,
                OffsetOf_Scissor_y_not_8);
@@ skipping 30 matching lines @@
       void* cmd, GLuint _shader, GLsizei _count, uint32 _data_shm_id,
       uint32 _data_shm_offset, uint32 _data_size) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shader, _count, _data_shm_id, _data_shm_offset, _data_size);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 shader;
-  uint32 count;
+  int32 count;
   uint32 data_shm_id;
   uint32 data_shm_offset;
   uint32 data_size;
 };
 
 COMPILE_ASSERT(sizeof(ShaderSource) == 24,
                Sizeof_ShaderSource_is_not_24);
 COMPILE_ASSERT(offsetof(ShaderSource, header) == 0,
                OffsetOf_ShaderSource_header_not_0);
 COMPILE_ASSERT(offsetof(ShaderSource, shader) == 4,
@@ skipping 31 matching lines @@
   }
 
   void* Set(void* cmd, GLuint _shader, GLsizei _count, uint32 _data_size) {
     uint32 total_size = ComputeSize(_data_size);
     static_cast<ValueType*>(cmd)->Init(_shader, _count, _data_size);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
   gpu::CommandHeader header;
   uint32 shader;
-  uint32 count;
+  int32 count;
   uint32 data_size;
 };
 
 COMPILE_ASSERT(sizeof(ShaderSourceImmediate) == 16,
                Sizeof_ShaderSourceImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(ShaderSourceImmediate, header) == 0,
                OffsetOf_ShaderSourceImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(ShaderSourceImmediate, shader) == 4,
                OffsetOf_ShaderSourceImmediate_shader_not_4);
 COMPILE_ASSERT(offsetof(ShaderSourceImmediate, count) == 8,
@@ skipping 21 matching lines @@
     mask = _mask;
   }
 
   void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) {
     static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 func;
-  uint32 ref;
+  int32 ref;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(StencilFunc) == 16,
                Sizeof_StencilFunc_is_not_16);
 COMPILE_ASSERT(offsetof(StencilFunc, header) == 0,
                OffsetOf_StencilFunc_header_not_0);
 COMPILE_ASSERT(offsetof(StencilFunc, func) == 4,
                OffsetOf_StencilFunc_func_not_4);
 COMPILE_ASSERT(offsetof(StencilFunc, ref) == 8,
@@ skipping 23 matching lines @@
   }
 
   void* Set(void* cmd, GLenum _face, GLenum _func, GLint _ref, GLuint _mask) {
     static_cast<ValueType*>(cmd)->Init(_face, _func, _ref, _mask);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 face;
   uint32 func;
-  uint32 ref;
+  int32 ref;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20,
                Sizeof_StencilFuncSeparate_is_not_20);
 COMPILE_ASSERT(offsetof(StencilFuncSeparate, header) == 0,
                OffsetOf_StencilFuncSeparate_header_not_0);
 COMPILE_ASSERT(offsetof(StencilFuncSeparate, face) == 4,
                OffsetOf_StencilFuncSeparate_face_not_4);
 COMPILE_ASSERT(offsetof(StencilFuncSeparate, func) == 8,
@@ skipping 200 matching lines @@
       GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border, _format,
             _type, _pixels_shm_id, _pixels_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 internalformat;
-  uint32 width;
-  uint32 height;
-  uint32 border;
+  int32 level;
+  int32 internalformat;
+  int32 width;
+  int32 height;
+  int32 border;
   uint32 format;
   uint32 type;
   uint32 pixels_shm_id;
   uint32 pixels_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(TexImage2D) == 44,
                Sizeof_TexImage2D_is_not_44);
 COMPILE_ASSERT(offsetof(TexImage2D, header) == 0,
                OffsetOf_TexImage2D_header_not_0);
@@ skipping 55 matching lines @@
     uint32 total_size = 0;  // TODO(gman): get correct size.
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border, _format,
             _type);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 internalformat;
-  uint32 width;
-  uint32 height;
-  uint32 border;
+  int32 level;
+  int32 internalformat;
+  int32 width;
+  int32 height;
+  int32 border;
   uint32 format;
   uint32 type;
 };
 
 COMPILE_ASSERT(sizeof(TexImage2DImmediate) == 36,
                Sizeof_TexImage2DImmediate_is_not_36);
 COMPILE_ASSERT(offsetof(TexImage2DImmediate, header) == 0,
                OffsetOf_TexImage2DImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(TexImage2DImmediate, target) == 4,
                OffsetOf_TexImage2DImmediate_target_not_4);
@@ skipping 173 matching lines @@
   }
 
   void* Set(void* cmd, GLenum _target, GLenum _pname, GLint _param) {
     static_cast<ValueType*>(cmd)->Init(_target, _pname, _param);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
-  uint32 param;
+  int32 param;
 };
 
 COMPILE_ASSERT(sizeof(TexParameteri) == 16,
                Sizeof_TexParameteri_is_not_16);
 COMPILE_ASSERT(offsetof(TexParameteri, header) == 0,
                OffsetOf_TexParameteri_header_not_0);
 COMPILE_ASSERT(offsetof(TexParameteri, target) == 4,
                OffsetOf_TexParameteri_target_not_4);
 COMPILE_ASSERT(offsetof(TexParameteri, pname) == 8,
                OffsetOf_TexParameteri_pname_not_8);
@@ skipping 134 matching lines @@
       uint32 _pixels_shm_id, uint32 _pixels_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _type, _pixels_shm_id, _pixels_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 xoffset;
-  uint32 yoffset;
-  uint32 width;
-  uint32 height;
+  int32 level;
+  int32 xoffset;
+  int32 yoffset;
+  int32 width;
+  int32 height;
   uint32 format;
   uint32 type;
   uint32 pixels_shm_id;
   uint32 pixels_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(TexSubImage2D) == 44,
                Sizeof_TexSubImage2D_is_not_44);
 COMPILE_ASSERT(offsetof(TexSubImage2D, header) == 0,
                OffsetOf_TexSubImage2D_header_not_0);
@@ skipping 54 matching lines @@
     uint32 total_size = 0;  // TODO(gman): get correct size
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _type);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
   gpu::CommandHeader header;
   uint32 target;
-  uint32 level;
-  uint32 xoffset;
-  uint32 yoffset;
-  uint32 width;
-  uint32 height;
+  int32 level;
+  int32 xoffset;
+  int32 yoffset;
+  int32 width;
+  int32 height;
   uint32 format;
   uint32 type;
 };
 
 COMPILE_ASSERT(sizeof(TexSubImage2DImmediate) == 36,
                Sizeof_TexSubImage2DImmediate_is_not_36);
 COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, header) == 0,
                OffsetOf_TexSubImage2DImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, target) == 4,
                OffsetOf_TexSubImage2DImmediate_target_not_4);
@@ skipping 30 matching lines @@
     location = _location;
     x = _x;
   }
 
   void* Set(void* cmd, GLint _location, GLfloat _x) {
     static_cast<ValueType*>(cmd)->Init(_location, _x);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
+  int32 location;
   float x;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1f) == 12,
                Sizeof_Uniform1f_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1f, header) == 0,
                OffsetOf_Uniform1f_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1f, location) == 4,
                OffsetOf_Uniform1f_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform1f, x) == 8,
@@ skipping 24 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12,
                Sizeof_Uniform1fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, header) == 0,
                OffsetOf_Uniform1fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, location) == 4,
                OffsetOf_Uniform1fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, count) == 8,
                OffsetOf_Uniform1fvImmediate_count_not_8);
@@ skipping 16 matching lines @@
     location = _location;
     x = _x;
   }
 
   void* Set(void* cmd, GLint _location, GLint _x) {
     static_cast<ValueType*>(cmd)->Init(_location, _x);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 x;
+  int32 location;
+  int32 x;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1i) == 12,
                Sizeof_Uniform1i_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1i, header) == 0,
                OffsetOf_Uniform1i_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1i, location) == 4,
                OffsetOf_Uniform1i_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform1i, x) == 8,
                OffsetOf_Uniform1i_x_not_8);
@@ skipping 23 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12,
                Sizeof_Uniform1ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, header) == 0,
                OffsetOf_Uniform1ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4,
                OffsetOf_Uniform1ivImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8,
                OffsetOf_Uniform1ivImmediate_count_not_8);
@@ skipping 17 matching lines @@
     x = _x;
     y = _y;
   }
 
   void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
+  int32 location;
   float x;
   float y;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2f) == 16,
                Sizeof_Uniform2f_is_not_16);
 COMPILE_ASSERT(offsetof(Uniform2f, header) == 0,
                OffsetOf_Uniform2f_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2f, location) == 4,
                OffsetOf_Uniform2f_location_not_4);
@@ skipping 27 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12,
                Sizeof_Uniform2fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, header) == 0,
                OffsetOf_Uniform2fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, location) == 4,
                OffsetOf_Uniform2fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, count) == 8,
                OffsetOf_Uniform2fvImmediate_count_not_8);
@@ skipping 17 matching lines @@
     x = _x;
     y = _y;
   }
 
   void* Set(void* cmd, GLint _location, GLint _x, GLint _y) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 x;
-  uint32 y;
+  int32 location;
+  int32 x;
+  int32 y;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2i) == 16,
                Sizeof_Uniform2i_is_not_16);
 COMPILE_ASSERT(offsetof(Uniform2i, header) == 0,
                OffsetOf_Uniform2i_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2i, location) == 4,
                OffsetOf_Uniform2i_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform2i, x) == 8,
                OffsetOf_Uniform2i_x_not_8);
@@ skipping 25 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12,
                Sizeof_Uniform2ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, header) == 0,
                OffsetOf_Uniform2ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4,
                OffsetOf_Uniform2ivImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8,
                OffsetOf_Uniform2ivImmediate_count_not_8);
@@ skipping 18 matching lines @@
     y = _y;
     z = _z;
   }
 
   void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
+  int32 location;
   float x;
   float y;
   float z;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3f) == 20,
                Sizeof_Uniform3f_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform3f, header) == 0,
                OffsetOf_Uniform3f_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform3f, location) == 4,
@@ skipping 30 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12,
                Sizeof_Uniform3fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, header) == 0,
                OffsetOf_Uniform3fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, location) == 4,
                OffsetOf_Uniform3fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, count) == 8,
                OffsetOf_Uniform3fvImmediate_count_not_8);
@@ skipping 18 matching lines @@
     y = _y;
     z = _z;
   }
 
   void* Set(void* cmd, GLint _location, GLint _x, GLint _y, GLint _z) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 x;
-  uint32 y;
-  uint32 z;
+  int32 location;
+  int32 x;
+  int32 y;
+  int32 z;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3i) == 20,
                Sizeof_Uniform3i_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform3i, header) == 0,
                OffsetOf_Uniform3i_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform3i, location) == 4,
                OffsetOf_Uniform3i_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform3i, x) == 8,
                OffsetOf_Uniform3i_x_not_8);
@@ skipping 27 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12,
                Sizeof_Uniform3ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, header) == 0,
                OffsetOf_Uniform3ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4,
                OffsetOf_Uniform3ivImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8,
                OffsetOf_Uniform3ivImmediate_count_not_8);
@@ skipping 21 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z,
       GLfloat _w) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
+  int32 location;
   float x;
   float y;
   float z;
   float w;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4f) == 24,
                Sizeof_Uniform4f_is_not_24);
 COMPILE_ASSERT(offsetof(Uniform4f, header) == 0,
                OffsetOf_Uniform4f_header_not_0);
@@ skipping 33 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12,
                Sizeof_Uniform4fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, header) == 0,
                OffsetOf_Uniform4fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, location) == 4,
                OffsetOf_Uniform4fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, count) == 8,
                OffsetOf_Uniform4fvImmediate_count_not_8);
@@ skipping 20 matching lines @@
     w = _w;
   }
 
   void* Set(
       void* cmd, GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 x;
-  uint32 y;
-  uint32 z;
-  uint32 w;
+  int32 location;
+  int32 x;
+  int32 y;
+  int32 z;
+  int32 w;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4i) == 24,
                Sizeof_Uniform4i_is_not_24);
 COMPILE_ASSERT(offsetof(Uniform4i, header) == 0,
                OffsetOf_Uniform4i_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform4i, location) == 4,
                OffsetOf_Uniform4i_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform4i, x) == 8,
                OffsetOf_Uniform4i_x_not_8);
@@ skipping 29 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 v_shm_id;
   uint32 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);
@@ skipping 31 matching lines @@
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12,
                Sizeof_Uniform4ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, header) == 0,
                OffsetOf_Uniform4ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4,
                OffsetOf_Uniform4ivImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8,
                OffsetOf_Uniform4ivImmediate_count_not_8);
@@ skipping 25 matching lines @@
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       uint32 _value_shm_id, uint32 _value_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _location, _count, _transpose, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 transpose;
   uint32 value_shm_id;
   uint32 value_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 24,
                Sizeof_UniformMatrix2fv_is_not_24);
 COMPILE_ASSERT(offsetof(UniformMatrix2fv, header) == 0,
                OffsetOf_UniformMatrix2fv_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix2fv, location) == 4,
@@ skipping 39 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       const GLfloat* _value) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 transpose;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 16,
                Sizeof_UniformMatrix2fvImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0,
                OffsetOf_UniformMatrix2fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
                OffsetOf_UniformMatrix2fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8,
@@ skipping 28 matching lines @@
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       uint32 _value_shm_id, uint32 _value_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _location, _count, _transpose, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 transpose;
   uint32 value_shm_id;
   uint32 value_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 24,
                Sizeof_UniformMatrix3fv_is_not_24);
 COMPILE_ASSERT(offsetof(UniformMatrix3fv, header) == 0,
                OffsetOf_UniformMatrix3fv_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix3fv, location) == 4,
@@ skipping 39 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       const GLfloat* _value) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 transpose;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 16,
                Sizeof_UniformMatrix3fvImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0,
                OffsetOf_UniformMatrix3fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
                OffsetOf_UniformMatrix3fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8,
@@ skipping 28 matching lines @@
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       uint32 _value_shm_id, uint32 _value_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _location, _count, _transpose, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 transpose;
   uint32 value_shm_id;
   uint32 value_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 24,
                Sizeof_UniformMatrix4fv_is_not_24);
 COMPILE_ASSERT(offsetof(UniformMatrix4fv, header) == 0,
                OffsetOf_UniformMatrix4fv_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix4fv, location) == 4,
@@ skipping 39 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       const GLfloat* _value) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
   gpu::CommandHeader header;
-  uint32 location;
-  uint32 count;
+  int32 location;
+  int32 count;
   uint32 transpose;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 16,
                Sizeof_UniformMatrix4fvImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0,
                OffsetOf_UniformMatrix4fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4,
                OffsetOf_UniformMatrix4fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8,
@@ skipping 627 matching lines @@
   void* Set(
       void* cmd, GLuint _indx, GLint _size, GLenum _type, GLboolean _normalized,
       GLsizei _stride, GLuint _offset) {
     static_cast<ValueType*>(
         cmd)->Init(_indx, _size, _type, _normalized, _stride, _offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   uint32 indx;
-  uint32 size;
+  int32 size;
   uint32 type;
   uint32 normalized;
-  uint32 stride;
+  int32 stride;
   uint32 offset;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28,
                Sizeof_VertexAttribPointer_is_not_28);
 COMPILE_ASSERT(offsetof(VertexAttribPointer, header) == 0,
                OffsetOf_VertexAttribPointer_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttribPointer, indx) == 4,
                OffsetOf_VertexAttribPointer_indx_not_4);
 COMPILE_ASSERT(offsetof(VertexAttribPointer, size) == 8,
@@ skipping 27 matching lines @@
     width = _width;
     height = _height;
   }
 
   void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
-  uint32 x;
-  uint32 y;
-  uint32 width;
-  uint32 height;
+  int32 x;
+  int32 y;
+  int32 width;
+  int32 height;
 };
 
 COMPILE_ASSERT(sizeof(Viewport) == 20,
                Sizeof_Viewport_is_not_20);
 COMPILE_ASSERT(offsetof(Viewport, header) == 0,
                OffsetOf_Viewport_header_not_0);
 COMPILE_ASSERT(offsetof(Viewport, x) == 4,
                OffsetOf_Viewport_x_not_4);
 COMPILE_ASSERT(offsetof(Viewport, y) == 8,
                OffsetOf_Viewport_y_not_8);
@@ skipping 27 matching lines @@
   gpu::CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(SwapBuffers) == 4,
                Sizeof_SwapBuffers_is_not_4);
 COMPILE_ASSERT(offsetof(SwapBuffers, header) == 0,
                OffsetOf_SwapBuffers_header_not_0);
 
 #pragma pack(pop)