src/gpu/command_buffer/common/gles2_cmd_format_autogen.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is auto-generated from
   6 // gpu/command_buffer/build_gles2_cmd_buffer.py
   7 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_
  12 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_
  13
  14 struct ActiveTexture {
  15   typedef ActiveTexture ValueType;
  16   static const CommandId kCmdId = kActiveTexture;
  17   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
  18   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
  19
  20   static uint32_t ComputeSize() {
  21     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
  22   }
  23
  24   void SetHeader() { header.SetCmd<ValueType>(); }
  25
  26   void Init(GLenum _texture) {
  27     SetHeader();
  28     texture = _texture;
  29   }
  30
  31   void* Set(void* cmd, GLenum _texture) {
  32     static_cast<ValueType*>(cmd)->Init(_texture);
  33     return NextCmdAddress<ValueType>(cmd);
  34   }
  35
  36   gpu::CommandHeader header;
  37   uint32_t texture;
  38 };
  39
  40 COMPILE_ASSERT(sizeof(ActiveTexture) == 8, Sizeof_ActiveTexture_is_not_8);
  41 COMPILE_ASSERT(offsetof(ActiveTexture, header) == 0,
  42                OffsetOf_ActiveTexture_header_not_0);
  43 COMPILE_ASSERT(offsetof(ActiveTexture, texture) == 4,
  44                OffsetOf_ActiveTexture_texture_not_4);
  45
  46 struct AttachShader {
  47   typedef AttachShader ValueType;
  48   static const CommandId kCmdId = kAttachShader;
  49   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
  50   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
  51
  52   static uint32_t ComputeSize() {
  53     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
  54   }
  55
  56   void SetHeader() { header.SetCmd<ValueType>(); }
  57
  58   void Init(GLuint _program, GLuint _shader) {
  59     SetHeader();
  60     program = _program;
  61     shader = _shader;
  62   }
  63
  64   void* Set(void* cmd, GLuint _program, GLuint _shader) {
  65     static_cast<ValueType*>(cmd)->Init(_program, _shader);
  66     return NextCmdAddress<ValueType>(cmd);
  67   }
  68
  69   gpu::CommandHeader header;
  70   uint32_t program;
  71   uint32_t shader;
  72 };
  73
  74 COMPILE_ASSERT(sizeof(AttachShader) == 12, Sizeof_AttachShader_is_not_12);
  75 COMPILE_ASSERT(offsetof(AttachShader, header) == 0,
  76                OffsetOf_AttachShader_header_not_0);
  77 COMPILE_ASSERT(offsetof(AttachShader, program) == 4,
  78                OffsetOf_AttachShader_program_not_4);
  79 COMPILE_ASSERT(offsetof(AttachShader, shader) == 8,
  80                OffsetOf_AttachShader_shader_not_8);
  81
  82 struct BindAttribLocationBucket {
  83   typedef BindAttribLocationBucket ValueType;
  84   static const CommandId kCmdId = kBindAttribLocationBucket;
  85   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
  86   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
  87
  88   static uint32_t ComputeSize() {
  89     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
  90   }
  91
  92   void SetHeader() { header.SetCmd<ValueType>(); }
  93
  94   void Init(GLuint _program, GLuint _index, uint32_t _name_bucket_id) {
  95     SetHeader();
  96     program = _program;
  97     index = _index;
  98     name_bucket_id = _name_bucket_id;
  99   }
 100
 101   void* Set(void* cmd,
 102             GLuint _program,
 103             GLuint _index,
 104             uint32_t _name_bucket_id) {
 105     static_cast<ValueType*>(cmd)->Init(_program, _index, _name_bucket_id);
 106     return NextCmdAddress<ValueType>(cmd);
 107   }
 108
 109   gpu::CommandHeader header;
 110   uint32_t program;
 111   uint32_t index;
 112   uint32_t name_bucket_id;
 113 };
 114
 115 COMPILE_ASSERT(sizeof(BindAttribLocationBucket) == 16,
 116                Sizeof_BindAttribLocationBucket_is_not_16);
 117 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, header) == 0,
 118                OffsetOf_BindAttribLocationBucket_header_not_0);
 119 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, program) == 4,
 120                OffsetOf_BindAttribLocationBucket_program_not_4);
 121 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, index) == 8,
 122                OffsetOf_BindAttribLocationBucket_index_not_8);
 123 COMPILE_ASSERT(offsetof(BindAttribLocationBucket, name_bucket_id) == 12,
 124                OffsetOf_BindAttribLocationBucket_name_bucket_id_not_12);
 125
 126 struct BindBuffer {
 127   typedef BindBuffer ValueType;
 128   static const CommandId kCmdId = kBindBuffer;
 129   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 130   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 131
 132   static uint32_t ComputeSize() {
 133     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 134   }
 135
 136   void SetHeader() { header.SetCmd<ValueType>(); }
 137
 138   void Init(GLenum _target, GLuint _buffer) {
 139     SetHeader();
 140     target = _target;
 141     buffer = _buffer;
 142   }
 143
 144   void* Set(void* cmd, GLenum _target, GLuint _buffer) {
 145     static_cast<ValueType*>(cmd)->Init(_target, _buffer);
 146     return NextCmdAddress<ValueType>(cmd);
 147   }
 148
 149   gpu::CommandHeader header;
 150   uint32_t target;
 151   uint32_t buffer;
 152 };
 153
 154 COMPILE_ASSERT(sizeof(BindBuffer) == 12, Sizeof_BindBuffer_is_not_12);
 155 COMPILE_ASSERT(offsetof(BindBuffer, header) == 0,
 156                OffsetOf_BindBuffer_header_not_0);
 157 COMPILE_ASSERT(offsetof(BindBuffer, target) == 4,
 158                OffsetOf_BindBuffer_target_not_4);
 159 COMPILE_ASSERT(offsetof(BindBuffer, buffer) == 8,
 160                OffsetOf_BindBuffer_buffer_not_8);
 161
 162 struct BindFramebuffer {
 163   typedef BindFramebuffer ValueType;
 164   static const CommandId kCmdId = kBindFramebuffer;
 165   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 166   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 167
 168   static uint32_t ComputeSize() {
 169     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 170   }
 171
 172   void SetHeader() { header.SetCmd<ValueType>(); }
 173
 174   void Init(GLenum _target, GLuint _framebuffer) {
 175     SetHeader();
 176     target = _target;
 177     framebuffer = _framebuffer;
 178   }
 179
 180   void* Set(void* cmd, GLenum _target, GLuint _framebuffer) {
 181     static_cast<ValueType*>(cmd)->Init(_target, _framebuffer);
 182     return NextCmdAddress<ValueType>(cmd);
 183   }
 184
 185   gpu::CommandHeader header;
 186   uint32_t target;
 187   uint32_t framebuffer;
 188 };
 189
 190 COMPILE_ASSERT(sizeof(BindFramebuffer) == 12, Sizeof_BindFramebuffer_is_not_12);
 191 COMPILE_ASSERT(offsetof(BindFramebuffer, header) == 0,
 192                OffsetOf_BindFramebuffer_header_not_0);
 193 COMPILE_ASSERT(offsetof(BindFramebuffer, target) == 4,
 194                OffsetOf_BindFramebuffer_target_not_4);
 195 COMPILE_ASSERT(offsetof(BindFramebuffer, framebuffer) == 8,
 196                OffsetOf_BindFramebuffer_framebuffer_not_8);
 197
 198 struct BindRenderbuffer {
 199   typedef BindRenderbuffer ValueType;
 200   static const CommandId kCmdId = kBindRenderbuffer;
 201   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 202   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 203
 204   static uint32_t ComputeSize() {
 205     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 206   }
 207
 208   void SetHeader() { header.SetCmd<ValueType>(); }
 209
 210   void Init(GLenum _target, GLuint _renderbuffer) {
 211     SetHeader();
 212     target = _target;
 213     renderbuffer = _renderbuffer;
 214   }
 215
 216   void* Set(void* cmd, GLenum _target, GLuint _renderbuffer) {
 217     static_cast<ValueType*>(cmd)->Init(_target, _renderbuffer);
 218     return NextCmdAddress<ValueType>(cmd);
 219   }
 220
 221   gpu::CommandHeader header;
 222   uint32_t target;
 223   uint32_t renderbuffer;
 224 };
 225
 226 COMPILE_ASSERT(sizeof(BindRenderbuffer) == 12,
 227                Sizeof_BindRenderbuffer_is_not_12);
 228 COMPILE_ASSERT(offsetof(BindRenderbuffer, header) == 0,
 229                OffsetOf_BindRenderbuffer_header_not_0);
 230 COMPILE_ASSERT(offsetof(BindRenderbuffer, target) == 4,
 231                OffsetOf_BindRenderbuffer_target_not_4);
 232 COMPILE_ASSERT(offsetof(BindRenderbuffer, renderbuffer) == 8,
 233                OffsetOf_BindRenderbuffer_renderbuffer_not_8);
 234
 235 struct BindTexture {
 236   typedef BindTexture ValueType;
 237   static const CommandId kCmdId = kBindTexture;
 238   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 239   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 240
 241   static uint32_t ComputeSize() {
 242     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 243   }
 244
 245   void SetHeader() { header.SetCmd<ValueType>(); }
 246
 247   void Init(GLenum _target, GLuint _texture) {
 248     SetHeader();
 249     target = _target;
 250     texture = _texture;
 251   }
 252
 253   void* Set(void* cmd, GLenum _target, GLuint _texture) {
 254     static_cast<ValueType*>(cmd)->Init(_target, _texture);
 255     return NextCmdAddress<ValueType>(cmd);
 256   }
 257
 258   gpu::CommandHeader header;
 259   uint32_t target;
 260   uint32_t texture;
 261 };
 262
 263 COMPILE_ASSERT(sizeof(BindTexture) == 12, Sizeof_BindTexture_is_not_12);
 264 COMPILE_ASSERT(offsetof(BindTexture, header) == 0,
 265                OffsetOf_BindTexture_header_not_0);
 266 COMPILE_ASSERT(offsetof(BindTexture, target) == 4,
 267                OffsetOf_BindTexture_target_not_4);
 268 COMPILE_ASSERT(offsetof(BindTexture, texture) == 8,
 269                OffsetOf_BindTexture_texture_not_8);
 270
 271 struct BlendColor {
 272   typedef BlendColor ValueType;
 273   static const CommandId kCmdId = kBlendColor;
 274   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 275   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 276
 277   static uint32_t ComputeSize() {
 278     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 279   }
 280
 281   void SetHeader() { header.SetCmd<ValueType>(); }
 282
 283   void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) {
 284     SetHeader();
 285     red = _red;
 286     green = _green;
 287     blue = _blue;
 288     alpha = _alpha;
 289   }
 290
 291   void* Set(void* cmd,
 292             GLclampf _red,
 293             GLclampf _green,
 294             GLclampf _blue,
 295             GLclampf _alpha) {
 296     static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
 297     return NextCmdAddress<ValueType>(cmd);
 298   }
 299
 300   gpu::CommandHeader header;
 301   float red;
 302   float green;
 303   float blue;
 304   float alpha;
 305 };
 306
 307 COMPILE_ASSERT(sizeof(BlendColor) == 20, Sizeof_BlendColor_is_not_20);
 308 COMPILE_ASSERT(offsetof(BlendColor, header) == 0,
 309                OffsetOf_BlendColor_header_not_0);
 310 COMPILE_ASSERT(offsetof(BlendColor, red) == 4, OffsetOf_BlendColor_red_not_4);
 311 COMPILE_ASSERT(offsetof(BlendColor, green) == 8,
 312                OffsetOf_BlendColor_green_not_8);
 313 COMPILE_ASSERT(offsetof(BlendColor, blue) == 12,
 314                OffsetOf_BlendColor_blue_not_12);
 315 COMPILE_ASSERT(offsetof(BlendColor, alpha) == 16,
 316                OffsetOf_BlendColor_alpha_not_16);
 317
 318 struct BlendEquation {
 319   typedef BlendEquation ValueType;
 320   static const CommandId kCmdId = kBlendEquation;
 321   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 322   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 323
 324   static uint32_t ComputeSize() {
 325     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 326   }
 327
 328   void SetHeader() { header.SetCmd<ValueType>(); }
 329
 330   void Init(GLenum _mode) {
 331     SetHeader();
 332     mode = _mode;
 333   }
 334
 335   void* Set(void* cmd, GLenum _mode) {
 336     static_cast<ValueType*>(cmd)->Init(_mode);
 337     return NextCmdAddress<ValueType>(cmd);
 338   }
 339
 340   gpu::CommandHeader header;
 341   uint32_t mode;
 342 };
 343
 344 COMPILE_ASSERT(sizeof(BlendEquation) == 8, Sizeof_BlendEquation_is_not_8);
 345 COMPILE_ASSERT(offsetof(BlendEquation, header) == 0,
 346                OffsetOf_BlendEquation_header_not_0);
 347 COMPILE_ASSERT(offsetof(BlendEquation, mode) == 4,
 348                OffsetOf_BlendEquation_mode_not_4);
 349
 350 struct BlendEquationSeparate {
 351   typedef BlendEquationSeparate ValueType;
 352   static const CommandId kCmdId = kBlendEquationSeparate;
 353   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 354   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 355
 356   static uint32_t ComputeSize() {
 357     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 358   }
 359
 360   void SetHeader() { header.SetCmd<ValueType>(); }
 361
 362   void Init(GLenum _modeRGB, GLenum _modeAlpha) {
 363     SetHeader();
 364     modeRGB = _modeRGB;
 365     modeAlpha = _modeAlpha;
 366   }
 367
 368   void* Set(void* cmd, GLenum _modeRGB, GLenum _modeAlpha) {
 369     static_cast<ValueType*>(cmd)->Init(_modeRGB, _modeAlpha);
 370     return NextCmdAddress<ValueType>(cmd);
 371   }
 372
 373   gpu::CommandHeader header;
 374   uint32_t modeRGB;
 375   uint32_t modeAlpha;
 376 };
 377
 378 COMPILE_ASSERT(sizeof(BlendEquationSeparate) == 12,
 379                Sizeof_BlendEquationSeparate_is_not_12);
 380 COMPILE_ASSERT(offsetof(BlendEquationSeparate, header) == 0,
 381                OffsetOf_BlendEquationSeparate_header_not_0);
 382 COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeRGB) == 4,
 383                OffsetOf_BlendEquationSeparate_modeRGB_not_4);
 384 COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeAlpha) == 8,
 385                OffsetOf_BlendEquationSeparate_modeAlpha_not_8);
 386
 387 struct BlendFunc {
 388   typedef BlendFunc ValueType;
 389   static const CommandId kCmdId = kBlendFunc;
 390   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 391   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 392
 393   static uint32_t ComputeSize() {
 394     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 395   }
 396
 397   void SetHeader() { header.SetCmd<ValueType>(); }
 398
 399   void Init(GLenum _sfactor, GLenum _dfactor) {
 400     SetHeader();
 401     sfactor = _sfactor;
 402     dfactor = _dfactor;
 403   }
 404
 405   void* Set(void* cmd, GLenum _sfactor, GLenum _dfactor) {
 406     static_cast<ValueType*>(cmd)->Init(_sfactor, _dfactor);
 407     return NextCmdAddress<ValueType>(cmd);
 408   }
 409
 410   gpu::CommandHeader header;
 411   uint32_t sfactor;
 412   uint32_t dfactor;
 413 };
 414
 415 COMPILE_ASSERT(sizeof(BlendFunc) == 12, Sizeof_BlendFunc_is_not_12);
 416 COMPILE_ASSERT(offsetof(BlendFunc, header) == 0,
 417                OffsetOf_BlendFunc_header_not_0);
 418 COMPILE_ASSERT(offsetof(BlendFunc, sfactor) == 4,
 419                OffsetOf_BlendFunc_sfactor_not_4);
 420 COMPILE_ASSERT(offsetof(BlendFunc, dfactor) == 8,
 421                OffsetOf_BlendFunc_dfactor_not_8);
 422
 423 struct BlendFuncSeparate {
 424   typedef BlendFuncSeparate ValueType;
 425   static const CommandId kCmdId = kBlendFuncSeparate;
 426   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 427   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 428
 429   static uint32_t ComputeSize() {
 430     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 431   }
 432
 433   void SetHeader() { header.SetCmd<ValueType>(); }
 434
 435   void Init(GLenum _srcRGB,
 436             GLenum _dstRGB,
 437             GLenum _srcAlpha,
 438             GLenum _dstAlpha) {
 439     SetHeader();
 440     srcRGB = _srcRGB;
 441     dstRGB = _dstRGB;
 442     srcAlpha = _srcAlpha;
 443     dstAlpha = _dstAlpha;
 444   }
 445
 446   void* Set(void* cmd,
 447             GLenum _srcRGB,
 448             GLenum _dstRGB,
 449             GLenum _srcAlpha,
 450             GLenum _dstAlpha) {
 451     static_cast<ValueType*>(cmd)->Init(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha);
 452     return NextCmdAddress<ValueType>(cmd);
 453   }
 454
 455   gpu::CommandHeader header;
 456   uint32_t srcRGB;
 457   uint32_t dstRGB;
 458   uint32_t srcAlpha;
 459   uint32_t dstAlpha;
 460 };
 461
 462 COMPILE_ASSERT(sizeof(BlendFuncSeparate) == 20,
 463                Sizeof_BlendFuncSeparate_is_not_20);
 464 COMPILE_ASSERT(offsetof(BlendFuncSeparate, header) == 0,
 465                OffsetOf_BlendFuncSeparate_header_not_0);
 466 COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcRGB) == 4,
 467                OffsetOf_BlendFuncSeparate_srcRGB_not_4);
 468 COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstRGB) == 8,
 469                OffsetOf_BlendFuncSeparate_dstRGB_not_8);
 470 COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcAlpha) == 12,
 471                OffsetOf_BlendFuncSeparate_srcAlpha_not_12);
 472 COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstAlpha) == 16,
 473                OffsetOf_BlendFuncSeparate_dstAlpha_not_16);
 474
 475 struct BufferData {
 476   typedef BufferData ValueType;
 477   static const CommandId kCmdId = kBufferData;
 478   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 479   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 480
 481   static uint32_t ComputeSize() {
 482     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 483   }
 484
 485   void SetHeader() { header.SetCmd<ValueType>(); }
 486
 487   void Init(GLenum _target,
 488             GLsizeiptr _size,
 489             uint32_t _data_shm_id,
 490             uint32_t _data_shm_offset,
 491             GLenum _usage) {
 492     SetHeader();
 493     target = _target;
 494     size = _size;
 495     data_shm_id = _data_shm_id;
 496     data_shm_offset = _data_shm_offset;
 497     usage = _usage;
 498   }
 499
 500   void* Set(void* cmd,
 501             GLenum _target,
 502             GLsizeiptr _size,
 503             uint32_t _data_shm_id,
 504             uint32_t _data_shm_offset,
 505             GLenum _usage) {
 506     static_cast<ValueType*>(cmd)
 507         ->Init(_target, _size, _data_shm_id, _data_shm_offset, _usage);
 508     return NextCmdAddress<ValueType>(cmd);
 509   }
 510
 511   gpu::CommandHeader header;
 512   uint32_t target;
 513   int32_t size;
 514   uint32_t data_shm_id;
 515   uint32_t data_shm_offset;
 516   uint32_t usage;
 517 };
 518
 519 COMPILE_ASSERT(sizeof(BufferData) == 24, Sizeof_BufferData_is_not_24);
 520 COMPILE_ASSERT(offsetof(BufferData, header) == 0,
 521                OffsetOf_BufferData_header_not_0);
 522 COMPILE_ASSERT(offsetof(BufferData, target) == 4,
 523                OffsetOf_BufferData_target_not_4);
 524 COMPILE_ASSERT(offsetof(BufferData, size) == 8, OffsetOf_BufferData_size_not_8);
 525 COMPILE_ASSERT(offsetof(BufferData, data_shm_id) == 12,
 526                OffsetOf_BufferData_data_shm_id_not_12);
 527 COMPILE_ASSERT(offsetof(BufferData, data_shm_offset) == 16,
 528                OffsetOf_BufferData_data_shm_offset_not_16);
 529 COMPILE_ASSERT(offsetof(BufferData, usage) == 20,
 530                OffsetOf_BufferData_usage_not_20);
 531
 532 struct BufferSubData {
 533   typedef BufferSubData ValueType;
 534   static const CommandId kCmdId = kBufferSubData;
 535   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 536   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 537
 538   static uint32_t ComputeSize() {
 539     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 540   }
 541
 542   void SetHeader() { header.SetCmd<ValueType>(); }
 543
 544   void Init(GLenum _target,
 545             GLintptr _offset,
 546             GLsizeiptr _size,
 547             uint32_t _data_shm_id,
 548             uint32_t _data_shm_offset) {
 549     SetHeader();
 550     target = _target;
 551     offset = _offset;
 552     size = _size;
 553     data_shm_id = _data_shm_id;
 554     data_shm_offset = _data_shm_offset;
 555   }
 556
 557   void* Set(void* cmd,
 558             GLenum _target,
 559             GLintptr _offset,
 560             GLsizeiptr _size,
 561             uint32_t _data_shm_id,
 562             uint32_t _data_shm_offset) {
 563     static_cast<ValueType*>(cmd)
 564         ->Init(_target, _offset, _size, _data_shm_id, _data_shm_offset);
 565     return NextCmdAddress<ValueType>(cmd);
 566   }
 567
 568   gpu::CommandHeader header;
 569   uint32_t target;
 570   int32_t offset;
 571   int32_t size;
 572   uint32_t data_shm_id;
 573   uint32_t data_shm_offset;
 574 };
 575
 576 COMPILE_ASSERT(sizeof(BufferSubData) == 24, Sizeof_BufferSubData_is_not_24);
 577 COMPILE_ASSERT(offsetof(BufferSubData, header) == 0,
 578                OffsetOf_BufferSubData_header_not_0);
 579 COMPILE_ASSERT(offsetof(BufferSubData, target) == 4,
 580                OffsetOf_BufferSubData_target_not_4);
 581 COMPILE_ASSERT(offsetof(BufferSubData, offset) == 8,
 582                OffsetOf_BufferSubData_offset_not_8);
 583 COMPILE_ASSERT(offsetof(BufferSubData, size) == 12,
 584                OffsetOf_BufferSubData_size_not_12);
 585 COMPILE_ASSERT(offsetof(BufferSubData, data_shm_id) == 16,
 586                OffsetOf_BufferSubData_data_shm_id_not_16);
 587 COMPILE_ASSERT(offsetof(BufferSubData, data_shm_offset) == 20,
 588                OffsetOf_BufferSubData_data_shm_offset_not_20);
 589
 590 struct CheckFramebufferStatus {
 591   typedef CheckFramebufferStatus ValueType;
 592   static const CommandId kCmdId = kCheckFramebufferStatus;
 593   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 594   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 595
 596   typedef GLenum Result;
 597
 598   static uint32_t ComputeSize() {
 599     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 600   }
 601
 602   void SetHeader() { header.SetCmd<ValueType>(); }
 603
 604   void Init(GLenum _target,
 605             uint32_t _result_shm_id,
 606             uint32_t _result_shm_offset) {
 607     SetHeader();
 608     target = _target;
 609     result_shm_id = _result_shm_id;
 610     result_shm_offset = _result_shm_offset;
 611   }
 612
 613   void* Set(void* cmd,
 614             GLenum _target,
 615             uint32_t _result_shm_id,
 616             uint32_t _result_shm_offset) {
 617     static_cast<ValueType*>(cmd)
 618         ->Init(_target, _result_shm_id, _result_shm_offset);
 619     return NextCmdAddress<ValueType>(cmd);
 620   }
 621
 622   gpu::CommandHeader header;
 623   uint32_t target;
 624   uint32_t result_shm_id;
 625   uint32_t result_shm_offset;
 626 };
 627
 628 COMPILE_ASSERT(sizeof(CheckFramebufferStatus) == 16,
 629                Sizeof_CheckFramebufferStatus_is_not_16);
 630 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, header) == 0,
 631                OffsetOf_CheckFramebufferStatus_header_not_0);
 632 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, target) == 4,
 633                OffsetOf_CheckFramebufferStatus_target_not_4);
 634 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, result_shm_id) == 8,
 635                OffsetOf_CheckFramebufferStatus_result_shm_id_not_8);
 636 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, result_shm_offset) == 12,
 637                OffsetOf_CheckFramebufferStatus_result_shm_offset_not_12);
 638
 639 struct Clear {
 640   typedef Clear ValueType;
 641   static const CommandId kCmdId = kClear;
 642   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 643   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 644
 645   static uint32_t ComputeSize() {
 646     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 647   }
 648
 649   void SetHeader() { header.SetCmd<ValueType>(); }
 650
 651   void Init(GLbitfield _mask) {
 652     SetHeader();
 653     mask = _mask;
 654   }
 655
 656   void* Set(void* cmd, GLbitfield _mask) {
 657     static_cast<ValueType*>(cmd)->Init(_mask);
 658     return NextCmdAddress<ValueType>(cmd);
 659   }
 660
 661   gpu::CommandHeader header;
 662   uint32_t mask;
 663 };
 664
 665 COMPILE_ASSERT(sizeof(Clear) == 8, Sizeof_Clear_is_not_8);
 666 COMPILE_ASSERT(offsetof(Clear, header) == 0, OffsetOf_Clear_header_not_0);
 667 COMPILE_ASSERT(offsetof(Clear, mask) == 4, OffsetOf_Clear_mask_not_4);
 668
 669 struct ClearColor {
 670   typedef ClearColor ValueType;
 671   static const CommandId kCmdId = kClearColor;
 672   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 673   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 674
 675   static uint32_t ComputeSize() {
 676     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 677   }
 678
 679   void SetHeader() { header.SetCmd<ValueType>(); }
 680
 681   void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) {
 682     SetHeader();
 683     red = _red;
 684     green = _green;
 685     blue = _blue;
 686     alpha = _alpha;
 687   }
 688
 689   void* Set(void* cmd,
 690             GLclampf _red,
 691             GLclampf _green,
 692             GLclampf _blue,
 693             GLclampf _alpha) {
 694     static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
 695     return NextCmdAddress<ValueType>(cmd);
 696   }
 697
 698   gpu::CommandHeader header;
 699   float red;
 700   float green;
 701   float blue;
 702   float alpha;
 703 };
 704
 705 COMPILE_ASSERT(sizeof(ClearColor) == 20, Sizeof_ClearColor_is_not_20);
 706 COMPILE_ASSERT(offsetof(ClearColor, header) == 0,
 707                OffsetOf_ClearColor_header_not_0);
 708 COMPILE_ASSERT(offsetof(ClearColor, red) == 4, OffsetOf_ClearColor_red_not_4);
 709 COMPILE_ASSERT(offsetof(ClearColor, green) == 8,
 710                OffsetOf_ClearColor_green_not_8);
 711 COMPILE_ASSERT(offsetof(ClearColor, blue) == 12,
 712                OffsetOf_ClearColor_blue_not_12);
 713 COMPILE_ASSERT(offsetof(ClearColor, alpha) == 16,
 714                OffsetOf_ClearColor_alpha_not_16);
 715
 716 struct ClearDepthf {
 717   typedef ClearDepthf ValueType;
 718   static const CommandId kCmdId = kClearDepthf;
 719   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 720   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 721
 722   static uint32_t ComputeSize() {
 723     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 724   }
 725
 726   void SetHeader() { header.SetCmd<ValueType>(); }
 727
 728   void Init(GLclampf _depth) {
 729     SetHeader();
 730     depth = _depth;
 731   }
 732
 733   void* Set(void* cmd, GLclampf _depth) {
 734     static_cast<ValueType*>(cmd)->Init(_depth);
 735     return NextCmdAddress<ValueType>(cmd);
 736   }
 737
 738   gpu::CommandHeader header;
 739   float depth;
 740 };
 741
 742 COMPILE_ASSERT(sizeof(ClearDepthf) == 8, Sizeof_ClearDepthf_is_not_8);
 743 COMPILE_ASSERT(offsetof(ClearDepthf, header) == 0,
 744                OffsetOf_ClearDepthf_header_not_0);
 745 COMPILE_ASSERT(offsetof(ClearDepthf, depth) == 4,
 746                OffsetOf_ClearDepthf_depth_not_4);
 747
 748 struct ClearStencil {
 749   typedef ClearStencil ValueType;
 750   static const CommandId kCmdId = kClearStencil;
 751   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 752   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 753
 754   static uint32_t ComputeSize() {
 755     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 756   }
 757
 758   void SetHeader() { header.SetCmd<ValueType>(); }
 759
 760   void Init(GLint _s) {
 761     SetHeader();
 762     s = _s;
 763   }
 764
 765   void* Set(void* cmd, GLint _s) {
 766     static_cast<ValueType*>(cmd)->Init(_s);
 767     return NextCmdAddress<ValueType>(cmd);
 768   }
 769
 770   gpu::CommandHeader header;
 771   int32_t s;
 772 };
 773
 774 COMPILE_ASSERT(sizeof(ClearStencil) == 8, Sizeof_ClearStencil_is_not_8);
 775 COMPILE_ASSERT(offsetof(ClearStencil, header) == 0,
 776                OffsetOf_ClearStencil_header_not_0);
 777 COMPILE_ASSERT(offsetof(ClearStencil, s) == 4, OffsetOf_ClearStencil_s_not_4);
 778
 779 struct ColorMask {
 780   typedef ColorMask ValueType;
 781   static const CommandId kCmdId = kColorMask;
 782   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 783   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 784
 785   static uint32_t ComputeSize() {
 786     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 787   }
 788
 789   void SetHeader() { header.SetCmd<ValueType>(); }
 790
 791   void Init(GLboolean _red,
 792             GLboolean _green,
 793             GLboolean _blue,
 794             GLboolean _alpha) {
 795     SetHeader();
 796     red = _red;
 797     green = _green;
 798     blue = _blue;
 799     alpha = _alpha;
 800   }
 801
 802   void* Set(void* cmd,
 803             GLboolean _red,
 804             GLboolean _green,
 805             GLboolean _blue,
 806             GLboolean _alpha) {
 807     static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
 808     return NextCmdAddress<ValueType>(cmd);
 809   }
 810
 811   gpu::CommandHeader header;
 812   uint32_t red;
 813   uint32_t green;
 814   uint32_t blue;
 815   uint32_t alpha;
 816 };
 817
 818 COMPILE_ASSERT(sizeof(ColorMask) == 20, Sizeof_ColorMask_is_not_20);
 819 COMPILE_ASSERT(offsetof(ColorMask, header) == 0,
 820                OffsetOf_ColorMask_header_not_0);
 821 COMPILE_ASSERT(offsetof(ColorMask, red) == 4, OffsetOf_ColorMask_red_not_4);
 822 COMPILE_ASSERT(offsetof(ColorMask, green) == 8, OffsetOf_ColorMask_green_not_8);
 823 COMPILE_ASSERT(offsetof(ColorMask, blue) == 12, OffsetOf_ColorMask_blue_not_12);
 824 COMPILE_ASSERT(offsetof(ColorMask, alpha) == 16,
 825                OffsetOf_ColorMask_alpha_not_16);
 826
 827 struct CompileShader {
 828   typedef CompileShader ValueType;
 829   static const CommandId kCmdId = kCompileShader;
 830   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 831   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 832
 833   static uint32_t ComputeSize() {
 834     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 835   }
 836
 837   void SetHeader() { header.SetCmd<ValueType>(); }
 838
 839   void Init(GLuint _shader) {
 840     SetHeader();
 841     shader = _shader;
 842   }
 843
 844   void* Set(void* cmd, GLuint _shader) {
 845     static_cast<ValueType*>(cmd)->Init(_shader);
 846     return NextCmdAddress<ValueType>(cmd);
 847   }
 848
 849   gpu::CommandHeader header;
 850   uint32_t shader;
 851 };
 852
 853 COMPILE_ASSERT(sizeof(CompileShader) == 8, Sizeof_CompileShader_is_not_8);
 854 COMPILE_ASSERT(offsetof(CompileShader, header) == 0,
 855                OffsetOf_CompileShader_header_not_0);
 856 COMPILE_ASSERT(offsetof(CompileShader, shader) == 4,
 857                OffsetOf_CompileShader_shader_not_4);
 858
 859 struct CompressedTexImage2DBucket {
 860   typedef CompressedTexImage2DBucket ValueType;
 861   static const CommandId kCmdId = kCompressedTexImage2DBucket;
 862   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 863   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 864
 865   static uint32_t ComputeSize() {
 866     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 867   }
 868
 869   void SetHeader() { header.SetCmd<ValueType>(); }
 870
 871   void Init(GLenum _target,
 872             GLint _level,
 873             GLenum _internalformat,
 874             GLsizei _width,
 875             GLsizei _height,
 876             GLuint _bucket_id) {
 877     SetHeader();
 878     target = _target;
 879     level = _level;
 880     internalformat = _internalformat;
 881     width = _width;
 882     height = _height;
 883     bucket_id = _bucket_id;
 884   }
 885
 886   void* Set(void* cmd,
 887             GLenum _target,
 888             GLint _level,
 889             GLenum _internalformat,
 890             GLsizei _width,
 891             GLsizei _height,
 892             GLuint _bucket_id) {
 893     static_cast<ValueType*>(cmd)
 894         ->Init(_target, _level, _internalformat, _width, _height, _bucket_id);
 895     return NextCmdAddress<ValueType>(cmd);
 896   }
 897
 898   gpu::CommandHeader header;
 899   uint32_t target;
 900   int32_t level;
 901   uint32_t internalformat;
 902   int32_t width;
 903   int32_t height;
 904   uint32_t bucket_id;
 905   static const int32_t border = 0;
 906 };
 907
 908 COMPILE_ASSERT(sizeof(CompressedTexImage2DBucket) == 28,
 909                Sizeof_CompressedTexImage2DBucket_is_not_28);
 910 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, header) == 0,
 911                OffsetOf_CompressedTexImage2DBucket_header_not_0);
 912 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, target) == 4,
 913                OffsetOf_CompressedTexImage2DBucket_target_not_4);
 914 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, level) == 8,
 915                OffsetOf_CompressedTexImage2DBucket_level_not_8);
 916 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, internalformat) == 12,
 917                OffsetOf_CompressedTexImage2DBucket_internalformat_not_12);
 918 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, width) == 16,
 919                OffsetOf_CompressedTexImage2DBucket_width_not_16);
 920 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, height) == 20,
 921                OffsetOf_CompressedTexImage2DBucket_height_not_20);
 922 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, bucket_id) == 24,
 923                OffsetOf_CompressedTexImage2DBucket_bucket_id_not_24);
 924
 925 struct CompressedTexImage2D {
 926   typedef CompressedTexImage2D ValueType;
 927   static const CommandId kCmdId = kCompressedTexImage2D;
 928   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 929   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 930
 931   static uint32_t ComputeSize() {
 932     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
 933   }
 934
 935   void SetHeader() { header.SetCmd<ValueType>(); }
 936
 937   void Init(GLenum _target,
 938             GLint _level,
 939             GLenum _internalformat,
 940             GLsizei _width,
 941             GLsizei _height,
 942             GLsizei _imageSize,
 943             uint32_t _data_shm_id,
 944             uint32_t _data_shm_offset) {
 945     SetHeader();
 946     target = _target;
 947     level = _level;
 948     internalformat = _internalformat;
 949     width = _width;
 950     height = _height;
 951     imageSize = _imageSize;
 952     data_shm_id = _data_shm_id;
 953     data_shm_offset = _data_shm_offset;
 954   }
 955
 956   void* Set(void* cmd,
 957             GLenum _target,
 958             GLint _level,
 959             GLenum _internalformat,
 960             GLsizei _width,
 961             GLsizei _height,
 962             GLsizei _imageSize,
 963             uint32_t _data_shm_id,
 964             uint32_t _data_shm_offset) {
 965     static_cast<ValueType*>(cmd)->Init(_target, _level, _internalformat, _width,
 966                                        _height, _imageSize, _data_shm_id,
 967                                        _data_shm_offset);
 968     return NextCmdAddress<ValueType>(cmd);
 969   }
 970
 971   gpu::CommandHeader header;
 972   uint32_t target;
 973   int32_t level;
 974   uint32_t internalformat;
 975   int32_t width;
 976   int32_t height;
 977   int32_t imageSize;
 978   uint32_t data_shm_id;
 979   uint32_t data_shm_offset;
 980   static const int32_t border = 0;
 981 };
 982
 983 COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 36,
 984                Sizeof_CompressedTexImage2D_is_not_36);
 985 COMPILE_ASSERT(offsetof(CompressedTexImage2D, header) == 0,
 986                OffsetOf_CompressedTexImage2D_header_not_0);
 987 COMPILE_ASSERT(offsetof(CompressedTexImage2D, target) == 4,
 988                OffsetOf_CompressedTexImage2D_target_not_4);
 989 COMPILE_ASSERT(offsetof(CompressedTexImage2D, level) == 8,
 990                OffsetOf_CompressedTexImage2D_level_not_8);
 991 COMPILE_ASSERT(offsetof(CompressedTexImage2D, internalformat) == 12,
 992                OffsetOf_CompressedTexImage2D_internalformat_not_12);
 993 COMPILE_ASSERT(offsetof(CompressedTexImage2D, width) == 16,
 994                OffsetOf_CompressedTexImage2D_width_not_16);
 995 COMPILE_ASSERT(offsetof(CompressedTexImage2D, height) == 20,
 996                OffsetOf_CompressedTexImage2D_height_not_20);
 997 COMPILE_ASSERT(offsetof(CompressedTexImage2D, imageSize) == 24,
 998                OffsetOf_CompressedTexImage2D_imageSize_not_24);
 999 COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 28,
1000                OffsetOf_CompressedTexImage2D_data_shm_id_not_28);
1001 COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 32,
1002                OffsetOf_CompressedTexImage2D_data_shm_offset_not_32);
1003
1004 struct CompressedTexSubImage2DBucket {
1005   typedef CompressedTexSubImage2DBucket ValueType;
1006   static const CommandId kCmdId = kCompressedTexSubImage2DBucket;
1007   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1008   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1009
1010   static uint32_t ComputeSize() {
1011     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1012   }
1013
1014   void SetHeader() { header.SetCmd<ValueType>(); }
1015
1016   void Init(GLenum _target,
1017             GLint _level,
1018             GLint _xoffset,
1019             GLint _yoffset,
1020             GLsizei _width,
1021             GLsizei _height,
1022             GLenum _format,
1023             GLuint _bucket_id) {
1024     SetHeader();
1025     target = _target;
1026     level = _level;
1027     xoffset = _xoffset;
1028     yoffset = _yoffset;
1029     width = _width;
1030     height = _height;
1031     format = _format;
1032     bucket_id = _bucket_id;
1033   }
1034
1035   void* Set(void* cmd,
1036             GLenum _target,
1037             GLint _level,
1038             GLint _xoffset,
1039             GLint _yoffset,
1040             GLsizei _width,
1041             GLsizei _height,
1042             GLenum _format,
1043             GLuint _bucket_id) {
1044     static_cast<ValueType*>(cmd)->Init(_target, _level, _xoffset, _yoffset,
1045                                        _width, _height, _format, _bucket_id);
1046     return NextCmdAddress<ValueType>(cmd);
1047   }
1048
1049   gpu::CommandHeader header;
1050   uint32_t target;
1051   int32_t level;
1052   int32_t xoffset;
1053   int32_t yoffset;
1054   int32_t width;
1055   int32_t height;
1056   uint32_t format;
1057   uint32_t bucket_id;
1058 };
1059
1060 COMPILE_ASSERT(sizeof(CompressedTexSubImage2DBucket) == 36,
1061                Sizeof_CompressedTexSubImage2DBucket_is_not_36);
1062 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, header) == 0,
1063                OffsetOf_CompressedTexSubImage2DBucket_header_not_0);
1064 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, target) == 4,
1065                OffsetOf_CompressedTexSubImage2DBucket_target_not_4);
1066 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, level) == 8,
1067                OffsetOf_CompressedTexSubImage2DBucket_level_not_8);
1068 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, xoffset) == 12,
1069                OffsetOf_CompressedTexSubImage2DBucket_xoffset_not_12);
1070 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, yoffset) == 16,
1071                OffsetOf_CompressedTexSubImage2DBucket_yoffset_not_16);
1072 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, width) == 20,
1073                OffsetOf_CompressedTexSubImage2DBucket_width_not_20);
1074 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, height) == 24,
1075                OffsetOf_CompressedTexSubImage2DBucket_height_not_24);
1076 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, format) == 28,
1077                OffsetOf_CompressedTexSubImage2DBucket_format_not_28);
1078 COMPILE_ASSERT(offsetof(CompressedTexSubImage2DBucket, bucket_id) == 32,
1079                OffsetOf_CompressedTexSubImage2DBucket_bucket_id_not_32);
1080
1081 struct CompressedTexSubImage2D {
1082   typedef CompressedTexSubImage2D ValueType;
1083   static const CommandId kCmdId = kCompressedTexSubImage2D;
1084   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1085   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1086
1087   static uint32_t ComputeSize() {
1088     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1089   }
1090
1091   void SetHeader() { header.SetCmd<ValueType>(); }
1092
1093   void Init(GLenum _target,
1094             GLint _level,
1095             GLint _xoffset,
1096             GLint _yoffset,
1097             GLsizei _width,
1098             GLsizei _height,
1099             GLenum _format,
1100             GLsizei _imageSize,
1101             uint32_t _data_shm_id,
1102             uint32_t _data_shm_offset) {
1103     SetHeader();
1104     target = _target;
1105     level = _level;
1106     xoffset = _xoffset;
1107     yoffset = _yoffset;
1108     width = _width;
1109     height = _height;
1110     format = _format;
1111     imageSize = _imageSize;
1112     data_shm_id = _data_shm_id;
1113     data_shm_offset = _data_shm_offset;
1114   }
1115
1116   void* Set(void* cmd,
1117             GLenum _target,
1118             GLint _level,
1119             GLint _xoffset,
1120             GLint _yoffset,
1121             GLsizei _width,
1122             GLsizei _height,
1123             GLenum _format,
1124             GLsizei _imageSize,
1125             uint32_t _data_shm_id,
1126             uint32_t _data_shm_offset) {
1127     static_cast<ValueType*>(cmd)->Init(_target, _level, _xoffset, _yoffset,
1128                                        _width, _height, _format, _imageSize,
1129                                        _data_shm_id, _data_shm_offset);
1130     return NextCmdAddress<ValueType>(cmd);
1131   }
1132
1133   gpu::CommandHeader header;
1134   uint32_t target;
1135   int32_t level;
1136   int32_t xoffset;
1137   int32_t yoffset;
1138   int32_t width;
1139   int32_t height;
1140   uint32_t format;
1141   int32_t imageSize;
1142   uint32_t data_shm_id;
1143   uint32_t data_shm_offset;
1144 };
1145
1146 COMPILE_ASSERT(sizeof(CompressedTexSubImage2D) == 44,
1147                Sizeof_CompressedTexSubImage2D_is_not_44);
1148 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, header) == 0,
1149                OffsetOf_CompressedTexSubImage2D_header_not_0);
1150 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, target) == 4,
1151                OffsetOf_CompressedTexSubImage2D_target_not_4);
1152 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, level) == 8,
1153                OffsetOf_CompressedTexSubImage2D_level_not_8);
1154 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, xoffset) == 12,
1155                OffsetOf_CompressedTexSubImage2D_xoffset_not_12);
1156 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, yoffset) == 16,
1157                OffsetOf_CompressedTexSubImage2D_yoffset_not_16);
1158 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, width) == 20,
1159                OffsetOf_CompressedTexSubImage2D_width_not_20);
1160 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, height) == 24,
1161                OffsetOf_CompressedTexSubImage2D_height_not_24);
1162 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, format) == 28,
1163                OffsetOf_CompressedTexSubImage2D_format_not_28);
1164 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, imageSize) == 32,
1165                OffsetOf_CompressedTexSubImage2D_imageSize_not_32);
1166 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_id) == 36,
1167                OffsetOf_CompressedTexSubImage2D_data_shm_id_not_36);
1168 COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40,
1169                OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40);
1170
1171 struct CopyTexImage2D {
1172   typedef CopyTexImage2D ValueType;
1173   static const CommandId kCmdId = kCopyTexImage2D;
1174   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1175   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1176
1177   static uint32_t ComputeSize() {
1178     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1179   }
1180
1181   void SetHeader() { header.SetCmd<ValueType>(); }
1182
1183   void Init(GLenum _target,
1184             GLint _level,
1185             GLenum _internalformat,
1186             GLint _x,
1187             GLint _y,
1188             GLsizei _width,
1189             GLsizei _height) {
1190     SetHeader();
1191     target = _target;
1192     level = _level;
1193     internalformat = _internalformat;
1194     x = _x;
1195     y = _y;
1196     width = _width;
1197     height = _height;
1198   }
1199
1200   void* Set(void* cmd,
1201             GLenum _target,
1202             GLint _level,
1203             GLenum _internalformat,
1204             GLint _x,
1205             GLint _y,
1206             GLsizei _width,
1207             GLsizei _height) {
1208     static_cast<ValueType*>(cmd)
1209         ->Init(_target, _level, _internalformat, _x, _y, _width, _height);
1210     return NextCmdAddress<ValueType>(cmd);
1211   }
1212
1213   gpu::CommandHeader header;
1214   uint32_t target;
1215   int32_t level;
1216   uint32_t internalformat;
1217   int32_t x;
1218   int32_t y;
1219   int32_t width;
1220   int32_t height;
1221   static const int32_t border = 0;
1222 };
1223
1224 COMPILE_ASSERT(sizeof(CopyTexImage2D) == 32, Sizeof_CopyTexImage2D_is_not_32);
1225 COMPILE_ASSERT(offsetof(CopyTexImage2D, header) == 0,
1226                OffsetOf_CopyTexImage2D_header_not_0);
1227 COMPILE_ASSERT(offsetof(CopyTexImage2D, target) == 4,
1228                OffsetOf_CopyTexImage2D_target_not_4);
1229 COMPILE_ASSERT(offsetof(CopyTexImage2D, level) == 8,
1230                OffsetOf_CopyTexImage2D_level_not_8);
1231 COMPILE_ASSERT(offsetof(CopyTexImage2D, internalformat) == 12,
1232                OffsetOf_CopyTexImage2D_internalformat_not_12);
1233 COMPILE_ASSERT(offsetof(CopyTexImage2D, x) == 16,
1234                OffsetOf_CopyTexImage2D_x_not_16);
1235 COMPILE_ASSERT(offsetof(CopyTexImage2D, y) == 20,
1236                OffsetOf_CopyTexImage2D_y_not_20);
1237 COMPILE_ASSERT(offsetof(CopyTexImage2D, width) == 24,
1238                OffsetOf_CopyTexImage2D_width_not_24);
1239 COMPILE_ASSERT(offsetof(CopyTexImage2D, height) == 28,
1240                OffsetOf_CopyTexImage2D_height_not_28);
1241
1242 struct CopyTexSubImage2D {
1243   typedef CopyTexSubImage2D ValueType;
1244   static const CommandId kCmdId = kCopyTexSubImage2D;
1245   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1246   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1247
1248   static uint32_t ComputeSize() {
1249     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1250   }
1251
1252   void SetHeader() { header.SetCmd<ValueType>(); }
1253
1254   void Init(GLenum _target,
1255             GLint _level,
1256             GLint _xoffset,
1257             GLint _yoffset,
1258             GLint _x,
1259             GLint _y,
1260             GLsizei _width,
1261             GLsizei _height) {
1262     SetHeader();
1263     target = _target;
1264     level = _level;
1265     xoffset = _xoffset;
1266     yoffset = _yoffset;
1267     x = _x;
1268     y = _y;
1269     width = _width;
1270     height = _height;
1271   }
1272
1273   void* Set(void* cmd,
1274             GLenum _target,
1275             GLint _level,
1276             GLint _xoffset,
1277             GLint _yoffset,
1278             GLint _x,
1279             GLint _y,
1280             GLsizei _width,
1281             GLsizei _height) {
1282     static_cast<ValueType*>(cmd)
1283         ->Init(_target, _level, _xoffset, _yoffset, _x, _y, _width, _height);
1284     return NextCmdAddress<ValueType>(cmd);
1285   }
1286
1287   gpu::CommandHeader header;
1288   uint32_t target;
1289   int32_t level;
1290   int32_t xoffset;
1291   int32_t yoffset;
1292   int32_t x;
1293   int32_t y;
1294   int32_t width;
1295   int32_t height;
1296 };
1297
1298 COMPILE_ASSERT(sizeof(CopyTexSubImage2D) == 36,
1299                Sizeof_CopyTexSubImage2D_is_not_36);
1300 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, header) == 0,
1301                OffsetOf_CopyTexSubImage2D_header_not_0);
1302 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, target) == 4,
1303                OffsetOf_CopyTexSubImage2D_target_not_4);
1304 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, level) == 8,
1305                OffsetOf_CopyTexSubImage2D_level_not_8);
1306 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, xoffset) == 12,
1307                OffsetOf_CopyTexSubImage2D_xoffset_not_12);
1308 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, yoffset) == 16,
1309                OffsetOf_CopyTexSubImage2D_yoffset_not_16);
1310 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, x) == 20,
1311                OffsetOf_CopyTexSubImage2D_x_not_20);
1312 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, y) == 24,
1313                OffsetOf_CopyTexSubImage2D_y_not_24);
1314 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, width) == 28,
1315                OffsetOf_CopyTexSubImage2D_width_not_28);
1316 COMPILE_ASSERT(offsetof(CopyTexSubImage2D, height) == 32,
1317                OffsetOf_CopyTexSubImage2D_height_not_32);
1318
1319 struct CreateProgram {
1320   typedef CreateProgram ValueType;
1321   static const CommandId kCmdId = kCreateProgram;
1322   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1323   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1324
1325   static uint32_t ComputeSize() {
1326     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1327   }
1328
1329   void SetHeader() { header.SetCmd<ValueType>(); }
1330
1331   void Init(uint32_t _client_id) {
1332     SetHeader();
1333     client_id = _client_id;
1334   }
1335
1336   void* Set(void* cmd, uint32_t _client_id) {
1337     static_cast<ValueType*>(cmd)->Init(_client_id);
1338     return NextCmdAddress<ValueType>(cmd);
1339   }
1340
1341   gpu::CommandHeader header;
1342   uint32_t client_id;
1343 };
1344
1345 COMPILE_ASSERT(sizeof(CreateProgram) == 8, Sizeof_CreateProgram_is_not_8);
1346 COMPILE_ASSERT(offsetof(CreateProgram, header) == 0,
1347                OffsetOf_CreateProgram_header_not_0);
1348 COMPILE_ASSERT(offsetof(CreateProgram, client_id) == 4,
1349                OffsetOf_CreateProgram_client_id_not_4);
1350
1351 struct CreateShader {
1352   typedef CreateShader ValueType;
1353   static const CommandId kCmdId = kCreateShader;
1354   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1355   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1356
1357   static uint32_t ComputeSize() {
1358     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1359   }
1360
1361   void SetHeader() { header.SetCmd<ValueType>(); }
1362
1363   void Init(GLenum _type, uint32_t _client_id) {
1364     SetHeader();
1365     type = _type;
1366     client_id = _client_id;
1367   }
1368
1369   void* Set(void* cmd, GLenum _type, uint32_t _client_id) {
1370     static_cast<ValueType*>(cmd)->Init(_type, _client_id);
1371     return NextCmdAddress<ValueType>(cmd);
1372   }
1373
1374   gpu::CommandHeader header;
1375   uint32_t type;
1376   uint32_t client_id;
1377 };
1378
1379 COMPILE_ASSERT(sizeof(CreateShader) == 12, Sizeof_CreateShader_is_not_12);
1380 COMPILE_ASSERT(offsetof(CreateShader, header) == 0,
1381                OffsetOf_CreateShader_header_not_0);
1382 COMPILE_ASSERT(offsetof(CreateShader, type) == 4,
1383                OffsetOf_CreateShader_type_not_4);
1384 COMPILE_ASSERT(offsetof(CreateShader, client_id) == 8,
1385                OffsetOf_CreateShader_client_id_not_8);
1386
1387 struct CullFace {
1388   typedef CullFace ValueType;
1389   static const CommandId kCmdId = kCullFace;
1390   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1391   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1392
1393   static uint32_t ComputeSize() {
1394     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1395   }
1396
1397   void SetHeader() { header.SetCmd<ValueType>(); }
1398
1399   void Init(GLenum _mode) {
1400     SetHeader();
1401     mode = _mode;
1402   }
1403
1404   void* Set(void* cmd, GLenum _mode) {
1405     static_cast<ValueType*>(cmd)->Init(_mode);
1406     return NextCmdAddress<ValueType>(cmd);
1407   }
1408
1409   gpu::CommandHeader header;
1410   uint32_t mode;
1411 };
1412
1413 COMPILE_ASSERT(sizeof(CullFace) == 8, Sizeof_CullFace_is_not_8);
1414 COMPILE_ASSERT(offsetof(CullFace, header) == 0, OffsetOf_CullFace_header_not_0);
1415 COMPILE_ASSERT(offsetof(CullFace, mode) == 4, OffsetOf_CullFace_mode_not_4);
1416
1417 struct DeleteBuffersImmediate {
1418   typedef DeleteBuffersImmediate ValueType;
1419   static const CommandId kCmdId = kDeleteBuffersImmediate;
1420   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
1421   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1422
1423   static uint32_t ComputeDataSize(GLsizei n) {
1424     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
1425   }
1426
1427   static uint32_t ComputeSize(GLsizei n) {
1428     return static_cast<uint32_t>(sizeof(ValueType) +
1429                                  ComputeDataSize(n));  // NOLINT
1430   }
1431
1432   void SetHeader(GLsizei n) {
1433     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
1434   }
1435
1436   void Init(GLsizei _n, const GLuint* _buffers) {
1437     SetHeader(_n);
1438     n = _n;
1439     memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n));
1440   }
1441
1442   void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) {
1443     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
1444     const uint32_t size = ComputeSize(_n);
1445     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
1446   }
1447
1448   gpu::CommandHeader header;
1449   int32_t n;
1450 };
1451
1452 COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8,
1453                Sizeof_DeleteBuffersImmediate_is_not_8);
1454 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0,
1455                OffsetOf_DeleteBuffersImmediate_header_not_0);
1456 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4,
1457                OffsetOf_DeleteBuffersImmediate_n_not_4);
1458
1459 struct DeleteFramebuffersImmediate {
1460   typedef DeleteFramebuffersImmediate ValueType;
1461   static const CommandId kCmdId = kDeleteFramebuffersImmediate;
1462   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
1463   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1464
1465   static uint32_t ComputeDataSize(GLsizei n) {
1466     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
1467   }
1468
1469   static uint32_t ComputeSize(GLsizei n) {
1470     return static_cast<uint32_t>(sizeof(ValueType) +
1471                                  ComputeDataSize(n));  // NOLINT
1472   }
1473
1474   void SetHeader(GLsizei n) {
1475     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
1476   }
1477
1478   void Init(GLsizei _n, const GLuint* _framebuffers) {
1479     SetHeader(_n);
1480     n = _n;
1481     memcpy(ImmediateDataAddress(this), _framebuffers, ComputeDataSize(_n));
1482   }
1483
1484   void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) {
1485     static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
1486     const uint32_t size = ComputeSize(_n);
1487     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
1488   }
1489
1490   gpu::CommandHeader header;
1491   int32_t n;
1492 };
1493
1494 COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8,
1495                Sizeof_DeleteFramebuffersImmediate_is_not_8);
1496 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, header) == 0,
1497                OffsetOf_DeleteFramebuffersImmediate_header_not_0);
1498 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, n) == 4,
1499                OffsetOf_DeleteFramebuffersImmediate_n_not_4);
1500
1501 struct DeleteProgram {
1502   typedef DeleteProgram ValueType;
1503   static const CommandId kCmdId = kDeleteProgram;
1504   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1505   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1506
1507   static uint32_t ComputeSize() {
1508     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1509   }
1510
1511   void SetHeader() { header.SetCmd<ValueType>(); }
1512
1513   void Init(GLuint _program) {
1514     SetHeader();
1515     program = _program;
1516   }
1517
1518   void* Set(void* cmd, GLuint _program) {
1519     static_cast<ValueType*>(cmd)->Init(_program);
1520     return NextCmdAddress<ValueType>(cmd);
1521   }
1522
1523   gpu::CommandHeader header;
1524   uint32_t program;
1525 };
1526
1527 COMPILE_ASSERT(sizeof(DeleteProgram) == 8, Sizeof_DeleteProgram_is_not_8);
1528 COMPILE_ASSERT(offsetof(DeleteProgram, header) == 0,
1529                OffsetOf_DeleteProgram_header_not_0);
1530 COMPILE_ASSERT(offsetof(DeleteProgram, program) == 4,
1531                OffsetOf_DeleteProgram_program_not_4);
1532
1533 struct DeleteRenderbuffersImmediate {
1534   typedef DeleteRenderbuffersImmediate ValueType;
1535   static const CommandId kCmdId = kDeleteRenderbuffersImmediate;
1536   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
1537   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1538
1539   static uint32_t ComputeDataSize(GLsizei n) {
1540     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
1541   }
1542
1543   static uint32_t ComputeSize(GLsizei n) {
1544     return static_cast<uint32_t>(sizeof(ValueType) +
1545                                  ComputeDataSize(n));  // NOLINT
1546   }
1547
1548   void SetHeader(GLsizei n) {
1549     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
1550   }
1551
1552   void Init(GLsizei _n, const GLuint* _renderbuffers) {
1553     SetHeader(_n);
1554     n = _n;
1555     memcpy(ImmediateDataAddress(this), _renderbuffers, ComputeDataSize(_n));
1556   }
1557
1558   void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) {
1559     static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
1560     const uint32_t size = ComputeSize(_n);
1561     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
1562   }
1563
1564   gpu::CommandHeader header;
1565   int32_t n;
1566 };
1567
1568 COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8,
1569                Sizeof_DeleteRenderbuffersImmediate_is_not_8);
1570 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, header) == 0,
1571                OffsetOf_DeleteRenderbuffersImmediate_header_not_0);
1572 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, n) == 4,
1573                OffsetOf_DeleteRenderbuffersImmediate_n_not_4);
1574
1575 struct DeleteShader {
1576   typedef DeleteShader ValueType;
1577   static const CommandId kCmdId = kDeleteShader;
1578   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1579   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1580
1581   static uint32_t ComputeSize() {
1582     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1583   }
1584
1585   void SetHeader() { header.SetCmd<ValueType>(); }
1586
1587   void Init(GLuint _shader) {
1588     SetHeader();
1589     shader = _shader;
1590   }
1591
1592   void* Set(void* cmd, GLuint _shader) {
1593     static_cast<ValueType*>(cmd)->Init(_shader);
1594     return NextCmdAddress<ValueType>(cmd);
1595   }
1596
1597   gpu::CommandHeader header;
1598   uint32_t shader;
1599 };
1600
1601 COMPILE_ASSERT(sizeof(DeleteShader) == 8, Sizeof_DeleteShader_is_not_8);
1602 COMPILE_ASSERT(offsetof(DeleteShader, header) == 0,
1603                OffsetOf_DeleteShader_header_not_0);
1604 COMPILE_ASSERT(offsetof(DeleteShader, shader) == 4,
1605                OffsetOf_DeleteShader_shader_not_4);
1606
1607 struct DeleteTexturesImmediate {
1608   typedef DeleteTexturesImmediate ValueType;
1609   static const CommandId kCmdId = kDeleteTexturesImmediate;
1610   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
1611   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1612
1613   static uint32_t ComputeDataSize(GLsizei n) {
1614     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
1615   }
1616
1617   static uint32_t ComputeSize(GLsizei n) {
1618     return static_cast<uint32_t>(sizeof(ValueType) +
1619                                  ComputeDataSize(n));  // NOLINT
1620   }
1621
1622   void SetHeader(GLsizei n) {
1623     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
1624   }
1625
1626   void Init(GLsizei _n, const GLuint* _textures) {
1627     SetHeader(_n);
1628     n = _n;
1629     memcpy(ImmediateDataAddress(this), _textures, ComputeDataSize(_n));
1630   }
1631
1632   void* Set(void* cmd, GLsizei _n, const GLuint* _textures) {
1633     static_cast<ValueType*>(cmd)->Init(_n, _textures);
1634     const uint32_t size = ComputeSize(_n);
1635     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
1636   }
1637
1638   gpu::CommandHeader header;
1639   int32_t n;
1640 };
1641
1642 COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8,
1643                Sizeof_DeleteTexturesImmediate_is_not_8);
1644 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, header) == 0,
1645                OffsetOf_DeleteTexturesImmediate_header_not_0);
1646 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, n) == 4,
1647                OffsetOf_DeleteTexturesImmediate_n_not_4);
1648
1649 struct DepthFunc {
1650   typedef DepthFunc ValueType;
1651   static const CommandId kCmdId = kDepthFunc;
1652   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1653   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1654
1655   static uint32_t ComputeSize() {
1656     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1657   }
1658
1659   void SetHeader() { header.SetCmd<ValueType>(); }
1660
1661   void Init(GLenum _func) {
1662     SetHeader();
1663     func = _func;
1664   }
1665
1666   void* Set(void* cmd, GLenum _func) {
1667     static_cast<ValueType*>(cmd)->Init(_func);
1668     return NextCmdAddress<ValueType>(cmd);
1669   }
1670
1671   gpu::CommandHeader header;
1672   uint32_t func;
1673 };
1674
1675 COMPILE_ASSERT(sizeof(DepthFunc) == 8, Sizeof_DepthFunc_is_not_8);
1676 COMPILE_ASSERT(offsetof(DepthFunc, header) == 0,
1677                OffsetOf_DepthFunc_header_not_0);
1678 COMPILE_ASSERT(offsetof(DepthFunc, func) == 4, OffsetOf_DepthFunc_func_not_4);
1679
1680 struct DepthMask {
1681   typedef DepthMask ValueType;
1682   static const CommandId kCmdId = kDepthMask;
1683   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1684   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1685
1686   static uint32_t ComputeSize() {
1687     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1688   }
1689
1690   void SetHeader() { header.SetCmd<ValueType>(); }
1691
1692   void Init(GLboolean _flag) {
1693     SetHeader();
1694     flag = _flag;
1695   }
1696
1697   void* Set(void* cmd, GLboolean _flag) {
1698     static_cast<ValueType*>(cmd)->Init(_flag);
1699     return NextCmdAddress<ValueType>(cmd);
1700   }
1701
1702   gpu::CommandHeader header;
1703   uint32_t flag;
1704 };
1705
1706 COMPILE_ASSERT(sizeof(DepthMask) == 8, Sizeof_DepthMask_is_not_8);
1707 COMPILE_ASSERT(offsetof(DepthMask, header) == 0,
1708                OffsetOf_DepthMask_header_not_0);
1709 COMPILE_ASSERT(offsetof(DepthMask, flag) == 4, OffsetOf_DepthMask_flag_not_4);
1710
1711 struct DepthRangef {
1712   typedef DepthRangef ValueType;
1713   static const CommandId kCmdId = kDepthRangef;
1714   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1715   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1716
1717   static uint32_t ComputeSize() {
1718     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1719   }
1720
1721   void SetHeader() { header.SetCmd<ValueType>(); }
1722
1723   void Init(GLclampf _zNear, GLclampf _zFar) {
1724     SetHeader();
1725     zNear = _zNear;
1726     zFar = _zFar;
1727   }
1728
1729   void* Set(void* cmd, GLclampf _zNear, GLclampf _zFar) {
1730     static_cast<ValueType*>(cmd)->Init(_zNear, _zFar);
1731     return NextCmdAddress<ValueType>(cmd);
1732   }
1733
1734   gpu::CommandHeader header;
1735   float zNear;
1736   float zFar;
1737 };
1738
1739 COMPILE_ASSERT(sizeof(DepthRangef) == 12, Sizeof_DepthRangef_is_not_12);
1740 COMPILE_ASSERT(offsetof(DepthRangef, header) == 0,
1741                OffsetOf_DepthRangef_header_not_0);
1742 COMPILE_ASSERT(offsetof(DepthRangef, zNear) == 4,
1743                OffsetOf_DepthRangef_zNear_not_4);
1744 COMPILE_ASSERT(offsetof(DepthRangef, zFar) == 8,
1745                OffsetOf_DepthRangef_zFar_not_8);
1746
1747 struct DetachShader {
1748   typedef DetachShader ValueType;
1749   static const CommandId kCmdId = kDetachShader;
1750   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1751   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1752
1753   static uint32_t ComputeSize() {
1754     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1755   }
1756
1757   void SetHeader() { header.SetCmd<ValueType>(); }
1758
1759   void Init(GLuint _program, GLuint _shader) {
1760     SetHeader();
1761     program = _program;
1762     shader = _shader;
1763   }
1764
1765   void* Set(void* cmd, GLuint _program, GLuint _shader) {
1766     static_cast<ValueType*>(cmd)->Init(_program, _shader);
1767     return NextCmdAddress<ValueType>(cmd);
1768   }
1769
1770   gpu::CommandHeader header;
1771   uint32_t program;
1772   uint32_t shader;
1773 };
1774
1775 COMPILE_ASSERT(sizeof(DetachShader) == 12, Sizeof_DetachShader_is_not_12);
1776 COMPILE_ASSERT(offsetof(DetachShader, header) == 0,
1777                OffsetOf_DetachShader_header_not_0);
1778 COMPILE_ASSERT(offsetof(DetachShader, program) == 4,
1779                OffsetOf_DetachShader_program_not_4);
1780 COMPILE_ASSERT(offsetof(DetachShader, shader) == 8,
1781                OffsetOf_DetachShader_shader_not_8);
1782
1783 struct Disable {
1784   typedef Disable ValueType;
1785   static const CommandId kCmdId = kDisable;
1786   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1787   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1788
1789   static uint32_t ComputeSize() {
1790     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1791   }
1792
1793   void SetHeader() { header.SetCmd<ValueType>(); }
1794
1795   void Init(GLenum _cap) {
1796     SetHeader();
1797     cap = _cap;
1798   }
1799
1800   void* Set(void* cmd, GLenum _cap) {
1801     static_cast<ValueType*>(cmd)->Init(_cap);
1802     return NextCmdAddress<ValueType>(cmd);
1803   }
1804
1805   gpu::CommandHeader header;
1806   uint32_t cap;
1807 };
1808
1809 COMPILE_ASSERT(sizeof(Disable) == 8, Sizeof_Disable_is_not_8);
1810 COMPILE_ASSERT(offsetof(Disable, header) == 0, OffsetOf_Disable_header_not_0);
1811 COMPILE_ASSERT(offsetof(Disable, cap) == 4, OffsetOf_Disable_cap_not_4);
1812
1813 struct DisableVertexAttribArray {
1814   typedef DisableVertexAttribArray ValueType;
1815   static const CommandId kCmdId = kDisableVertexAttribArray;
1816   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1817   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1818
1819   static uint32_t ComputeSize() {
1820     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1821   }
1822
1823   void SetHeader() { header.SetCmd<ValueType>(); }
1824
1825   void Init(GLuint _index) {
1826     SetHeader();
1827     index = _index;
1828   }
1829
1830   void* Set(void* cmd, GLuint _index) {
1831     static_cast<ValueType*>(cmd)->Init(_index);
1832     return NextCmdAddress<ValueType>(cmd);
1833   }
1834
1835   gpu::CommandHeader header;
1836   uint32_t index;
1837 };
1838
1839 COMPILE_ASSERT(sizeof(DisableVertexAttribArray) == 8,
1840                Sizeof_DisableVertexAttribArray_is_not_8);
1841 COMPILE_ASSERT(offsetof(DisableVertexAttribArray, header) == 0,
1842                OffsetOf_DisableVertexAttribArray_header_not_0);
1843 COMPILE_ASSERT(offsetof(DisableVertexAttribArray, index) == 4,
1844                OffsetOf_DisableVertexAttribArray_index_not_4);
1845
1846 struct DrawArrays {
1847   typedef DrawArrays ValueType;
1848   static const CommandId kCmdId = kDrawArrays;
1849   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1850   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
1851
1852   static uint32_t ComputeSize() {
1853     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1854   }
1855
1856   void SetHeader() { header.SetCmd<ValueType>(); }
1857
1858   void Init(GLenum _mode, GLint _first, GLsizei _count) {
1859     SetHeader();
1860     mode = _mode;
1861     first = _first;
1862     count = _count;
1863   }
1864
1865   void* Set(void* cmd, GLenum _mode, GLint _first, GLsizei _count) {
1866     static_cast<ValueType*>(cmd)->Init(_mode, _first, _count);
1867     return NextCmdAddress<ValueType>(cmd);
1868   }
1869
1870   gpu::CommandHeader header;
1871   uint32_t mode;
1872   int32_t first;
1873   int32_t count;
1874 };
1875
1876 COMPILE_ASSERT(sizeof(DrawArrays) == 16, Sizeof_DrawArrays_is_not_16);
1877 COMPILE_ASSERT(offsetof(DrawArrays, header) == 0,
1878                OffsetOf_DrawArrays_header_not_0);
1879 COMPILE_ASSERT(offsetof(DrawArrays, mode) == 4, OffsetOf_DrawArrays_mode_not_4);
1880 COMPILE_ASSERT(offsetof(DrawArrays, first) == 8,
1881                OffsetOf_DrawArrays_first_not_8);
1882 COMPILE_ASSERT(offsetof(DrawArrays, count) == 12,
1883                OffsetOf_DrawArrays_count_not_12);
1884
1885 struct DrawElements {
1886   typedef DrawElements ValueType;
1887   static const CommandId kCmdId = kDrawElements;
1888   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1889   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
1890
1891   static uint32_t ComputeSize() {
1892     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1893   }
1894
1895   void SetHeader() { header.SetCmd<ValueType>(); }
1896
1897   void Init(GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset) {
1898     SetHeader();
1899     mode = _mode;
1900     count = _count;
1901     type = _type;
1902     index_offset = _index_offset;
1903   }
1904
1905   void* Set(void* cmd,
1906             GLenum _mode,
1907             GLsizei _count,
1908             GLenum _type,
1909             GLuint _index_offset) {
1910     static_cast<ValueType*>(cmd)->Init(_mode, _count, _type, _index_offset);
1911     return NextCmdAddress<ValueType>(cmd);
1912   }
1913
1914   gpu::CommandHeader header;
1915   uint32_t mode;
1916   int32_t count;
1917   uint32_t type;
1918   uint32_t index_offset;
1919 };
1920
1921 COMPILE_ASSERT(sizeof(DrawElements) == 20, Sizeof_DrawElements_is_not_20);
1922 COMPILE_ASSERT(offsetof(DrawElements, header) == 0,
1923                OffsetOf_DrawElements_header_not_0);
1924 COMPILE_ASSERT(offsetof(DrawElements, mode) == 4,
1925                OffsetOf_DrawElements_mode_not_4);
1926 COMPILE_ASSERT(offsetof(DrawElements, count) == 8,
1927                OffsetOf_DrawElements_count_not_8);
1928 COMPILE_ASSERT(offsetof(DrawElements, type) == 12,
1929                OffsetOf_DrawElements_type_not_12);
1930 COMPILE_ASSERT(offsetof(DrawElements, index_offset) == 16,
1931                OffsetOf_DrawElements_index_offset_not_16);
1932
1933 struct Enable {
1934   typedef Enable ValueType;
1935   static const CommandId kCmdId = kEnable;
1936   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1937   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1938
1939   static uint32_t ComputeSize() {
1940     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1941   }
1942
1943   void SetHeader() { header.SetCmd<ValueType>(); }
1944
1945   void Init(GLenum _cap) {
1946     SetHeader();
1947     cap = _cap;
1948   }
1949
1950   void* Set(void* cmd, GLenum _cap) {
1951     static_cast<ValueType*>(cmd)->Init(_cap);
1952     return NextCmdAddress<ValueType>(cmd);
1953   }
1954
1955   gpu::CommandHeader header;
1956   uint32_t cap;
1957 };
1958
1959 COMPILE_ASSERT(sizeof(Enable) == 8, Sizeof_Enable_is_not_8);
1960 COMPILE_ASSERT(offsetof(Enable, header) == 0, OffsetOf_Enable_header_not_0);
1961 COMPILE_ASSERT(offsetof(Enable, cap) == 4, OffsetOf_Enable_cap_not_4);
1962
1963 struct EnableVertexAttribArray {
1964   typedef EnableVertexAttribArray ValueType;
1965   static const CommandId kCmdId = kEnableVertexAttribArray;
1966   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
1967   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
1968
1969   static uint32_t ComputeSize() {
1970     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
1971   }
1972
1973   void SetHeader() { header.SetCmd<ValueType>(); }
1974
1975   void Init(GLuint _index) {
1976     SetHeader();
1977     index = _index;
1978   }
1979
1980   void* Set(void* cmd, GLuint _index) {
1981     static_cast<ValueType*>(cmd)->Init(_index);
1982     return NextCmdAddress<ValueType>(cmd);
1983   }
1984
1985   gpu::CommandHeader header;
1986   uint32_t index;
1987 };
1988
1989 COMPILE_ASSERT(sizeof(EnableVertexAttribArray) == 8,
1990                Sizeof_EnableVertexAttribArray_is_not_8);
1991 COMPILE_ASSERT(offsetof(EnableVertexAttribArray, header) == 0,
1992                OffsetOf_EnableVertexAttribArray_header_not_0);
1993 COMPILE_ASSERT(offsetof(EnableVertexAttribArray, index) == 4,
1994                OffsetOf_EnableVertexAttribArray_index_not_4);
1995
1996 struct Finish {
1997   typedef Finish ValueType;
1998   static const CommandId kCmdId = kFinish;
1999   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2000   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2001
2002   static uint32_t ComputeSize() {
2003     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2004   }
2005
2006   void SetHeader() { header.SetCmd<ValueType>(); }
2007
2008   void Init() { SetHeader(); }
2009
2010   void* Set(void* cmd) {
2011     static_cast<ValueType*>(cmd)->Init();
2012     return NextCmdAddress<ValueType>(cmd);
2013   }
2014
2015   gpu::CommandHeader header;
2016 };
2017
2018 COMPILE_ASSERT(sizeof(Finish) == 4, Sizeof_Finish_is_not_4);
2019 COMPILE_ASSERT(offsetof(Finish, header) == 0, OffsetOf_Finish_header_not_0);
2020
2021 struct Flush {
2022   typedef Flush ValueType;
2023   static const CommandId kCmdId = kFlush;
2024   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2025   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2026
2027   static uint32_t ComputeSize() {
2028     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2029   }
2030
2031   void SetHeader() { header.SetCmd<ValueType>(); }
2032
2033   void Init() { SetHeader(); }
2034
2035   void* Set(void* cmd) {
2036     static_cast<ValueType*>(cmd)->Init();
2037     return NextCmdAddress<ValueType>(cmd);
2038   }
2039
2040   gpu::CommandHeader header;
2041 };
2042
2043 COMPILE_ASSERT(sizeof(Flush) == 4, Sizeof_Flush_is_not_4);
2044 COMPILE_ASSERT(offsetof(Flush, header) == 0, OffsetOf_Flush_header_not_0);
2045
2046 struct FramebufferRenderbuffer {
2047   typedef FramebufferRenderbuffer ValueType;
2048   static const CommandId kCmdId = kFramebufferRenderbuffer;
2049   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2050   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2051
2052   static uint32_t ComputeSize() {
2053     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2054   }
2055
2056   void SetHeader() { header.SetCmd<ValueType>(); }
2057
2058   void Init(GLenum _target,
2059             GLenum _attachment,
2060             GLenum _renderbuffertarget,
2061             GLuint _renderbuffer) {
2062     SetHeader();
2063     target = _target;
2064     attachment = _attachment;
2065     renderbuffertarget = _renderbuffertarget;
2066     renderbuffer = _renderbuffer;
2067   }
2068
2069   void* Set(void* cmd,
2070             GLenum _target,
2071             GLenum _attachment,
2072             GLenum _renderbuffertarget,
2073             GLuint _renderbuffer) {
2074     static_cast<ValueType*>(cmd)
2075         ->Init(_target, _attachment, _renderbuffertarget, _renderbuffer);
2076     return NextCmdAddress<ValueType>(cmd);
2077   }
2078
2079   gpu::CommandHeader header;
2080   uint32_t target;
2081   uint32_t attachment;
2082   uint32_t renderbuffertarget;
2083   uint32_t renderbuffer;
2084 };
2085
2086 COMPILE_ASSERT(sizeof(FramebufferRenderbuffer) == 20,
2087                Sizeof_FramebufferRenderbuffer_is_not_20);
2088 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, header) == 0,
2089                OffsetOf_FramebufferRenderbuffer_header_not_0);
2090 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, target) == 4,
2091                OffsetOf_FramebufferRenderbuffer_target_not_4);
2092 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, attachment) == 8,
2093                OffsetOf_FramebufferRenderbuffer_attachment_not_8);
2094 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffertarget) == 12,
2095                OffsetOf_FramebufferRenderbuffer_renderbuffertarget_not_12);
2096 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffer) == 16,
2097                OffsetOf_FramebufferRenderbuffer_renderbuffer_not_16);
2098
2099 struct FramebufferTexture2D {
2100   typedef FramebufferTexture2D ValueType;
2101   static const CommandId kCmdId = kFramebufferTexture2D;
2102   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2103   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
2104
2105   static uint32_t ComputeSize() {
2106     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2107   }
2108
2109   void SetHeader() { header.SetCmd<ValueType>(); }
2110
2111   void Init(GLenum _target,
2112             GLenum _attachment,
2113             GLenum _textarget,
2114             GLuint _texture) {
2115     SetHeader();
2116     target = _target;
2117     attachment = _attachment;
2118     textarget = _textarget;
2119     texture = _texture;
2120   }
2121
2122   void* Set(void* cmd,
2123             GLenum _target,
2124             GLenum _attachment,
2125             GLenum _textarget,
2126             GLuint _texture) {
2127     static_cast<ValueType*>(cmd)
2128         ->Init(_target, _attachment, _textarget, _texture);
2129     return NextCmdAddress<ValueType>(cmd);
2130   }
2131
2132   gpu::CommandHeader header;
2133   uint32_t target;
2134   uint32_t attachment;
2135   uint32_t textarget;
2136   uint32_t texture;
2137   static const int32_t level = 0;
2138 };
2139
2140 COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 20,
2141                Sizeof_FramebufferTexture2D_is_not_20);
2142 COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0,
2143                OffsetOf_FramebufferTexture2D_header_not_0);
2144 COMPILE_ASSERT(offsetof(FramebufferTexture2D, target) == 4,
2145                OffsetOf_FramebufferTexture2D_target_not_4);
2146 COMPILE_ASSERT(offsetof(FramebufferTexture2D, attachment) == 8,
2147                OffsetOf_FramebufferTexture2D_attachment_not_8);
2148 COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12,
2149                OffsetOf_FramebufferTexture2D_textarget_not_12);
2150 COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16,
2151                OffsetOf_FramebufferTexture2D_texture_not_16);
2152
2153 struct FrontFace {
2154   typedef FrontFace ValueType;
2155   static const CommandId kCmdId = kFrontFace;
2156   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2157   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2158
2159   static uint32_t ComputeSize() {
2160     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2161   }
2162
2163   void SetHeader() { header.SetCmd<ValueType>(); }
2164
2165   void Init(GLenum _mode) {
2166     SetHeader();
2167     mode = _mode;
2168   }
2169
2170   void* Set(void* cmd, GLenum _mode) {
2171     static_cast<ValueType*>(cmd)->Init(_mode);
2172     return NextCmdAddress<ValueType>(cmd);
2173   }
2174
2175   gpu::CommandHeader header;
2176   uint32_t mode;
2177 };
2178
2179 COMPILE_ASSERT(sizeof(FrontFace) == 8, Sizeof_FrontFace_is_not_8);
2180 COMPILE_ASSERT(offsetof(FrontFace, header) == 0,
2181                OffsetOf_FrontFace_header_not_0);
2182 COMPILE_ASSERT(offsetof(FrontFace, mode) == 4, OffsetOf_FrontFace_mode_not_4);
2183
2184 struct GenBuffersImmediate {
2185   typedef GenBuffersImmediate ValueType;
2186   static const CommandId kCmdId = kGenBuffersImmediate;
2187   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
2188   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2189
2190   static uint32_t ComputeDataSize(GLsizei n) {
2191     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
2192   }
2193
2194   static uint32_t ComputeSize(GLsizei n) {
2195     return static_cast<uint32_t>(sizeof(ValueType) +
2196                                  ComputeDataSize(n));  // NOLINT
2197   }
2198
2199   void SetHeader(GLsizei n) {
2200     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
2201   }
2202
2203   void Init(GLsizei _n, GLuint* _buffers) {
2204     SetHeader(_n);
2205     n = _n;
2206     memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n));
2207   }
2208
2209   void* Set(void* cmd, GLsizei _n, GLuint* _buffers) {
2210     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
2211     const uint32_t size = ComputeSize(_n);
2212     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
2213   }
2214
2215   gpu::CommandHeader header;
2216   int32_t n;
2217 };
2218
2219 COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8,
2220                Sizeof_GenBuffersImmediate_is_not_8);
2221 COMPILE_ASSERT(offsetof(GenBuffersImmediate, header) == 0,
2222                OffsetOf_GenBuffersImmediate_header_not_0);
2223 COMPILE_ASSERT(offsetof(GenBuffersImmediate, n) == 4,
2224                OffsetOf_GenBuffersImmediate_n_not_4);
2225
2226 struct GenerateMipmap {
2227   typedef GenerateMipmap ValueType;
2228   static const CommandId kCmdId = kGenerateMipmap;
2229   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2230   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2231
2232   static uint32_t ComputeSize() {
2233     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2234   }
2235
2236   void SetHeader() { header.SetCmd<ValueType>(); }
2237
2238   void Init(GLenum _target) {
2239     SetHeader();
2240     target = _target;
2241   }
2242
2243   void* Set(void* cmd, GLenum _target) {
2244     static_cast<ValueType*>(cmd)->Init(_target);
2245     return NextCmdAddress<ValueType>(cmd);
2246   }
2247
2248   gpu::CommandHeader header;
2249   uint32_t target;
2250 };
2251
2252 COMPILE_ASSERT(sizeof(GenerateMipmap) == 8, Sizeof_GenerateMipmap_is_not_8);
2253 COMPILE_ASSERT(offsetof(GenerateMipmap, header) == 0,
2254                OffsetOf_GenerateMipmap_header_not_0);
2255 COMPILE_ASSERT(offsetof(GenerateMipmap, target) == 4,
2256                OffsetOf_GenerateMipmap_target_not_4);
2257
2258 struct GenFramebuffersImmediate {
2259   typedef GenFramebuffersImmediate ValueType;
2260   static const CommandId kCmdId = kGenFramebuffersImmediate;
2261   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
2262   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2263
2264   static uint32_t ComputeDataSize(GLsizei n) {
2265     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
2266   }
2267
2268   static uint32_t ComputeSize(GLsizei n) {
2269     return static_cast<uint32_t>(sizeof(ValueType) +
2270                                  ComputeDataSize(n));  // NOLINT
2271   }
2272
2273   void SetHeader(GLsizei n) {
2274     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
2275   }
2276
2277   void Init(GLsizei _n, GLuint* _framebuffers) {
2278     SetHeader(_n);
2279     n = _n;
2280     memcpy(ImmediateDataAddress(this), _framebuffers, ComputeDataSize(_n));
2281   }
2282
2283   void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) {
2284     static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
2285     const uint32_t size = ComputeSize(_n);
2286     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
2287   }
2288
2289   gpu::CommandHeader header;
2290   int32_t n;
2291 };
2292
2293 COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8,
2294                Sizeof_GenFramebuffersImmediate_is_not_8);
2295 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0,
2296                OffsetOf_GenFramebuffersImmediate_header_not_0);
2297 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4,
2298                OffsetOf_GenFramebuffersImmediate_n_not_4);
2299
2300 struct GenRenderbuffersImmediate {
2301   typedef GenRenderbuffersImmediate ValueType;
2302   static const CommandId kCmdId = kGenRenderbuffersImmediate;
2303   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
2304   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2305
2306   static uint32_t ComputeDataSize(GLsizei n) {
2307     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
2308   }
2309
2310   static uint32_t ComputeSize(GLsizei n) {
2311     return static_cast<uint32_t>(sizeof(ValueType) +
2312                                  ComputeDataSize(n));  // NOLINT
2313   }
2314
2315   void SetHeader(GLsizei n) {
2316     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
2317   }
2318
2319   void Init(GLsizei _n, GLuint* _renderbuffers) {
2320     SetHeader(_n);
2321     n = _n;
2322     memcpy(ImmediateDataAddress(this), _renderbuffers, ComputeDataSize(_n));
2323   }
2324
2325   void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) {
2326     static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
2327     const uint32_t size = ComputeSize(_n);
2328     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
2329   }
2330
2331   gpu::CommandHeader header;
2332   int32_t n;
2333 };
2334
2335 COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8,
2336                Sizeof_GenRenderbuffersImmediate_is_not_8);
2337 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0,
2338                OffsetOf_GenRenderbuffersImmediate_header_not_0);
2339 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4,
2340                OffsetOf_GenRenderbuffersImmediate_n_not_4);
2341
2342 struct GenTexturesImmediate {
2343   typedef GenTexturesImmediate ValueType;
2344   static const CommandId kCmdId = kGenTexturesImmediate;
2345   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
2346   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2347
2348   static uint32_t ComputeDataSize(GLsizei n) {
2349     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
2350   }
2351
2352   static uint32_t ComputeSize(GLsizei n) {
2353     return static_cast<uint32_t>(sizeof(ValueType) +
2354                                  ComputeDataSize(n));  // NOLINT
2355   }
2356
2357   void SetHeader(GLsizei n) {
2358     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
2359   }
2360
2361   void Init(GLsizei _n, GLuint* _textures) {
2362     SetHeader(_n);
2363     n = _n;
2364     memcpy(ImmediateDataAddress(this), _textures, ComputeDataSize(_n));
2365   }
2366
2367   void* Set(void* cmd, GLsizei _n, GLuint* _textures) {
2368     static_cast<ValueType*>(cmd)->Init(_n, _textures);
2369     const uint32_t size = ComputeSize(_n);
2370     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
2371   }
2372
2373   gpu::CommandHeader header;
2374   int32_t n;
2375 };
2376
2377 COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8,
2378                Sizeof_GenTexturesImmediate_is_not_8);
2379 COMPILE_ASSERT(offsetof(GenTexturesImmediate, header) == 0,
2380                OffsetOf_GenTexturesImmediate_header_not_0);
2381 COMPILE_ASSERT(offsetof(GenTexturesImmediate, n) == 4,
2382                OffsetOf_GenTexturesImmediate_n_not_4);
2383
2384 struct GetActiveAttrib {
2385   typedef GetActiveAttrib ValueType;
2386   static const CommandId kCmdId = kGetActiveAttrib;
2387   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2388   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2389
2390   struct Result {
2391     int32_t success;
2392     int32_t size;
2393     uint32_t type;
2394   };
2395
2396   static uint32_t ComputeSize() {
2397     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2398   }
2399
2400   void SetHeader() { header.SetCmd<ValueType>(); }
2401
2402   void Init(GLuint _program,
2403             GLuint _index,
2404             uint32_t _name_bucket_id,
2405             uint32_t _result_shm_id,
2406             uint32_t _result_shm_offset) {
2407     SetHeader();
2408     program = _program;
2409     index = _index;
2410     name_bucket_id = _name_bucket_id;
2411     result_shm_id = _result_shm_id;
2412     result_shm_offset = _result_shm_offset;
2413   }
2414
2415   void* Set(void* cmd,
2416             GLuint _program,
2417             GLuint _index,
2418             uint32_t _name_bucket_id,
2419             uint32_t _result_shm_id,
2420             uint32_t _result_shm_offset) {
2421     static_cast<ValueType*>(cmd)->Init(_program, _index, _name_bucket_id,
2422                                        _result_shm_id, _result_shm_offset);
2423     return NextCmdAddress<ValueType>(cmd);
2424   }
2425
2426   gpu::CommandHeader header;
2427   uint32_t program;
2428   uint32_t index;
2429   uint32_t name_bucket_id;
2430   uint32_t result_shm_id;
2431   uint32_t result_shm_offset;
2432 };
2433
2434 COMPILE_ASSERT(sizeof(GetActiveAttrib) == 24, Sizeof_GetActiveAttrib_is_not_24);
2435 COMPILE_ASSERT(offsetof(GetActiveAttrib, header) == 0,
2436                OffsetOf_GetActiveAttrib_header_not_0);
2437 COMPILE_ASSERT(offsetof(GetActiveAttrib, program) == 4,
2438                OffsetOf_GetActiveAttrib_program_not_4);
2439 COMPILE_ASSERT(offsetof(GetActiveAttrib, index) == 8,
2440                OffsetOf_GetActiveAttrib_index_not_8);
2441 COMPILE_ASSERT(offsetof(GetActiveAttrib, name_bucket_id) == 12,
2442                OffsetOf_GetActiveAttrib_name_bucket_id_not_12);
2443 COMPILE_ASSERT(offsetof(GetActiveAttrib, result_shm_id) == 16,
2444                OffsetOf_GetActiveAttrib_result_shm_id_not_16);
2445 COMPILE_ASSERT(offsetof(GetActiveAttrib, result_shm_offset) == 20,
2446                OffsetOf_GetActiveAttrib_result_shm_offset_not_20);
2447 COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, success) == 0,
2448                OffsetOf_GetActiveAttrib_Result_success_not_0);
2449 COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, size) == 4,
2450                OffsetOf_GetActiveAttrib_Result_size_not_4);
2451 COMPILE_ASSERT(offsetof(GetActiveAttrib::Result, type) == 8,
2452                OffsetOf_GetActiveAttrib_Result_type_not_8);
2453
2454 struct GetActiveUniform {
2455   typedef GetActiveUniform ValueType;
2456   static const CommandId kCmdId = kGetActiveUniform;
2457   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2458   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2459
2460   struct Result {
2461     int32_t success;
2462     int32_t size;
2463     uint32_t type;
2464   };
2465
2466   static uint32_t ComputeSize() {
2467     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2468   }
2469
2470   void SetHeader() { header.SetCmd<ValueType>(); }
2471
2472   void Init(GLuint _program,
2473             GLuint _index,
2474             uint32_t _name_bucket_id,
2475             uint32_t _result_shm_id,
2476             uint32_t _result_shm_offset) {
2477     SetHeader();
2478     program = _program;
2479     index = _index;
2480     name_bucket_id = _name_bucket_id;
2481     result_shm_id = _result_shm_id;
2482     result_shm_offset = _result_shm_offset;
2483   }
2484
2485   void* Set(void* cmd,
2486             GLuint _program,
2487             GLuint _index,
2488             uint32_t _name_bucket_id,
2489             uint32_t _result_shm_id,
2490             uint32_t _result_shm_offset) {
2491     static_cast<ValueType*>(cmd)->Init(_program, _index, _name_bucket_id,
2492                                        _result_shm_id, _result_shm_offset);
2493     return NextCmdAddress<ValueType>(cmd);
2494   }
2495
2496   gpu::CommandHeader header;
2497   uint32_t program;
2498   uint32_t index;
2499   uint32_t name_bucket_id;
2500   uint32_t result_shm_id;
2501   uint32_t result_shm_offset;
2502 };
2503
2504 COMPILE_ASSERT(sizeof(GetActiveUniform) == 24,
2505                Sizeof_GetActiveUniform_is_not_24);
2506 COMPILE_ASSERT(offsetof(GetActiveUniform, header) == 0,
2507                OffsetOf_GetActiveUniform_header_not_0);
2508 COMPILE_ASSERT(offsetof(GetActiveUniform, program) == 4,
2509                OffsetOf_GetActiveUniform_program_not_4);
2510 COMPILE_ASSERT(offsetof(GetActiveUniform, index) == 8,
2511                OffsetOf_GetActiveUniform_index_not_8);
2512 COMPILE_ASSERT(offsetof(GetActiveUniform, name_bucket_id) == 12,
2513                OffsetOf_GetActiveUniform_name_bucket_id_not_12);
2514 COMPILE_ASSERT(offsetof(GetActiveUniform, result_shm_id) == 16,
2515                OffsetOf_GetActiveUniform_result_shm_id_not_16);
2516 COMPILE_ASSERT(offsetof(GetActiveUniform, result_shm_offset) == 20,
2517                OffsetOf_GetActiveUniform_result_shm_offset_not_20);
2518 COMPILE_ASSERT(offsetof(GetActiveUniform::Result, success) == 0,
2519                OffsetOf_GetActiveUniform_Result_success_not_0);
2520 COMPILE_ASSERT(offsetof(GetActiveUniform::Result, size) == 4,
2521                OffsetOf_GetActiveUniform_Result_size_not_4);
2522 COMPILE_ASSERT(offsetof(GetActiveUniform::Result, type) == 8,
2523                OffsetOf_GetActiveUniform_Result_type_not_8);
2524
2525 struct GetAttachedShaders {
2526   typedef GetAttachedShaders ValueType;
2527   static const CommandId kCmdId = kGetAttachedShaders;
2528   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2529   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2530
2531   typedef SizedResult<GLuint> Result;
2532
2533   static uint32_t ComputeSize() {
2534     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2535   }
2536
2537   void SetHeader() { header.SetCmd<ValueType>(); }
2538
2539   void Init(GLuint _program,
2540             uint32_t _result_shm_id,
2541             uint32_t _result_shm_offset,
2542             uint32_t _result_size) {
2543     SetHeader();
2544     program = _program;
2545     result_shm_id = _result_shm_id;
2546     result_shm_offset = _result_shm_offset;
2547     result_size = _result_size;
2548   }
2549
2550   void* Set(void* cmd,
2551             GLuint _program,
2552             uint32_t _result_shm_id,
2553             uint32_t _result_shm_offset,
2554             uint32_t _result_size) {
2555     static_cast<ValueType*>(cmd)
2556         ->Init(_program, _result_shm_id, _result_shm_offset, _result_size);
2557     return NextCmdAddress<ValueType>(cmd);
2558   }
2559
2560   gpu::CommandHeader header;
2561   uint32_t program;
2562   uint32_t result_shm_id;
2563   uint32_t result_shm_offset;
2564   uint32_t result_size;
2565 };
2566
2567 COMPILE_ASSERT(sizeof(GetAttachedShaders) == 20,
2568                Sizeof_GetAttachedShaders_is_not_20);
2569 COMPILE_ASSERT(offsetof(GetAttachedShaders, header) == 0,
2570                OffsetOf_GetAttachedShaders_header_not_0);
2571 COMPILE_ASSERT(offsetof(GetAttachedShaders, program) == 4,
2572                OffsetOf_GetAttachedShaders_program_not_4);
2573 COMPILE_ASSERT(offsetof(GetAttachedShaders, result_shm_id) == 8,
2574                OffsetOf_GetAttachedShaders_result_shm_id_not_8);
2575 COMPILE_ASSERT(offsetof(GetAttachedShaders, result_shm_offset) == 12,
2576                OffsetOf_GetAttachedShaders_result_shm_offset_not_12);
2577 COMPILE_ASSERT(offsetof(GetAttachedShaders, result_size) == 16,
2578                OffsetOf_GetAttachedShaders_result_size_not_16);
2579
2580 struct GetAttribLocation {
2581   typedef GetAttribLocation ValueType;
2582   static const CommandId kCmdId = kGetAttribLocation;
2583   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2584   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2585
2586   typedef GLint Result;
2587
2588   static uint32_t ComputeSize() {
2589     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2590   }
2591
2592   void SetHeader() { header.SetCmd<ValueType>(); }
2593
2594   void Init(GLuint _program,
2595             uint32_t _name_bucket_id,
2596             uint32_t _location_shm_id,
2597             uint32_t _location_shm_offset) {
2598     SetHeader();
2599     program = _program;
2600     name_bucket_id = _name_bucket_id;
2601     location_shm_id = _location_shm_id;
2602     location_shm_offset = _location_shm_offset;
2603   }
2604
2605   void* Set(void* cmd,
2606             GLuint _program,
2607             uint32_t _name_bucket_id,
2608             uint32_t _location_shm_id,
2609             uint32_t _location_shm_offset) {
2610     static_cast<ValueType*>(cmd)->Init(_program, _name_bucket_id,
2611                                        _location_shm_id, _location_shm_offset);
2612     return NextCmdAddress<ValueType>(cmd);
2613   }
2614
2615   gpu::CommandHeader header;
2616   uint32_t program;
2617   uint32_t name_bucket_id;
2618   uint32_t location_shm_id;
2619   uint32_t location_shm_offset;
2620 };
2621
2622 COMPILE_ASSERT(sizeof(GetAttribLocation) == 20,
2623                Sizeof_GetAttribLocation_is_not_20);
2624 COMPILE_ASSERT(offsetof(GetAttribLocation, header) == 0,
2625                OffsetOf_GetAttribLocation_header_not_0);
2626 COMPILE_ASSERT(offsetof(GetAttribLocation, program) == 4,
2627                OffsetOf_GetAttribLocation_program_not_4);
2628 COMPILE_ASSERT(offsetof(GetAttribLocation, name_bucket_id) == 8,
2629                OffsetOf_GetAttribLocation_name_bucket_id_not_8);
2630 COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_id) == 12,
2631                OffsetOf_GetAttribLocation_location_shm_id_not_12);
2632 COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_offset) == 16,
2633                OffsetOf_GetAttribLocation_location_shm_offset_not_16);
2634
2635 struct GetBooleanv {
2636   typedef GetBooleanv ValueType;
2637   static const CommandId kCmdId = kGetBooleanv;
2638   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2639   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2640
2641   typedef SizedResult<GLboolean> Result;
2642
2643   static uint32_t ComputeSize() {
2644     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2645   }
2646
2647   void SetHeader() { header.SetCmd<ValueType>(); }
2648
2649   void Init(GLenum _pname,
2650             uint32_t _params_shm_id,
2651             uint32_t _params_shm_offset) {
2652     SetHeader();
2653     pname = _pname;
2654     params_shm_id = _params_shm_id;
2655     params_shm_offset = _params_shm_offset;
2656   }
2657
2658   void* Set(void* cmd,
2659             GLenum _pname,
2660             uint32_t _params_shm_id,
2661             uint32_t _params_shm_offset) {
2662     static_cast<ValueType*>(cmd)
2663         ->Init(_pname, _params_shm_id, _params_shm_offset);
2664     return NextCmdAddress<ValueType>(cmd);
2665   }
2666
2667   gpu::CommandHeader header;
2668   uint32_t pname;
2669   uint32_t params_shm_id;
2670   uint32_t params_shm_offset;
2671 };
2672
2673 COMPILE_ASSERT(sizeof(GetBooleanv) == 16, Sizeof_GetBooleanv_is_not_16);
2674 COMPILE_ASSERT(offsetof(GetBooleanv, header) == 0,
2675                OffsetOf_GetBooleanv_header_not_0);
2676 COMPILE_ASSERT(offsetof(GetBooleanv, pname) == 4,
2677                OffsetOf_GetBooleanv_pname_not_4);
2678 COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_id) == 8,
2679                OffsetOf_GetBooleanv_params_shm_id_not_8);
2680 COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_offset) == 12,
2681                OffsetOf_GetBooleanv_params_shm_offset_not_12);
2682
2683 struct GetBufferParameteriv {
2684   typedef GetBufferParameteriv ValueType;
2685   static const CommandId kCmdId = kGetBufferParameteriv;
2686   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2687   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2688
2689   typedef SizedResult<GLint> Result;
2690
2691   static uint32_t ComputeSize() {
2692     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2693   }
2694
2695   void SetHeader() { header.SetCmd<ValueType>(); }
2696
2697   void Init(GLenum _target,
2698             GLenum _pname,
2699             uint32_t _params_shm_id,
2700             uint32_t _params_shm_offset) {
2701     SetHeader();
2702     target = _target;
2703     pname = _pname;
2704     params_shm_id = _params_shm_id;
2705     params_shm_offset = _params_shm_offset;
2706   }
2707
2708   void* Set(void* cmd,
2709             GLenum _target,
2710             GLenum _pname,
2711             uint32_t _params_shm_id,
2712             uint32_t _params_shm_offset) {
2713     static_cast<ValueType*>(cmd)
2714         ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
2715     return NextCmdAddress<ValueType>(cmd);
2716   }
2717
2718   gpu::CommandHeader header;
2719   uint32_t target;
2720   uint32_t pname;
2721   uint32_t params_shm_id;
2722   uint32_t params_shm_offset;
2723 };
2724
2725 COMPILE_ASSERT(sizeof(GetBufferParameteriv) == 20,
2726                Sizeof_GetBufferParameteriv_is_not_20);
2727 COMPILE_ASSERT(offsetof(GetBufferParameteriv, header) == 0,
2728                OffsetOf_GetBufferParameteriv_header_not_0);
2729 COMPILE_ASSERT(offsetof(GetBufferParameteriv, target) == 4,
2730                OffsetOf_GetBufferParameteriv_target_not_4);
2731 COMPILE_ASSERT(offsetof(GetBufferParameteriv, pname) == 8,
2732                OffsetOf_GetBufferParameteriv_pname_not_8);
2733 COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_id) == 12,
2734                OffsetOf_GetBufferParameteriv_params_shm_id_not_12);
2735 COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_offset) == 16,
2736                OffsetOf_GetBufferParameteriv_params_shm_offset_not_16);
2737
2738 struct GetError {
2739   typedef GetError ValueType;
2740   static const CommandId kCmdId = kGetError;
2741   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2742   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2743
2744   typedef GLenum Result;
2745
2746   static uint32_t ComputeSize() {
2747     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2748   }
2749
2750   void SetHeader() { header.SetCmd<ValueType>(); }
2751
2752   void Init(uint32_t _result_shm_id, uint32_t _result_shm_offset) {
2753     SetHeader();
2754     result_shm_id = _result_shm_id;
2755     result_shm_offset = _result_shm_offset;
2756   }
2757
2758   void* Set(void* cmd, uint32_t _result_shm_id, uint32_t _result_shm_offset) {
2759     static_cast<ValueType*>(cmd)->Init(_result_shm_id, _result_shm_offset);
2760     return NextCmdAddress<ValueType>(cmd);
2761   }
2762
2763   gpu::CommandHeader header;
2764   uint32_t result_shm_id;
2765   uint32_t result_shm_offset;
2766 };
2767
2768 COMPILE_ASSERT(sizeof(GetError) == 12, Sizeof_GetError_is_not_12);
2769 COMPILE_ASSERT(offsetof(GetError, header) == 0, OffsetOf_GetError_header_not_0);
2770 COMPILE_ASSERT(offsetof(GetError, result_shm_id) == 4,
2771                OffsetOf_GetError_result_shm_id_not_4);
2772 COMPILE_ASSERT(offsetof(GetError, result_shm_offset) == 8,
2773                OffsetOf_GetError_result_shm_offset_not_8);
2774
2775 struct GetFloatv {
2776   typedef GetFloatv ValueType;
2777   static const CommandId kCmdId = kGetFloatv;
2778   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2779   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2780
2781   typedef SizedResult<GLfloat> Result;
2782
2783   static uint32_t ComputeSize() {
2784     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2785   }
2786
2787   void SetHeader() { header.SetCmd<ValueType>(); }
2788
2789   void Init(GLenum _pname,
2790             uint32_t _params_shm_id,
2791             uint32_t _params_shm_offset) {
2792     SetHeader();
2793     pname = _pname;
2794     params_shm_id = _params_shm_id;
2795     params_shm_offset = _params_shm_offset;
2796   }
2797
2798   void* Set(void* cmd,
2799             GLenum _pname,
2800             uint32_t _params_shm_id,
2801             uint32_t _params_shm_offset) {
2802     static_cast<ValueType*>(cmd)
2803         ->Init(_pname, _params_shm_id, _params_shm_offset);
2804     return NextCmdAddress<ValueType>(cmd);
2805   }
2806
2807   gpu::CommandHeader header;
2808   uint32_t pname;
2809   uint32_t params_shm_id;
2810   uint32_t params_shm_offset;
2811 };
2812
2813 COMPILE_ASSERT(sizeof(GetFloatv) == 16, Sizeof_GetFloatv_is_not_16);
2814 COMPILE_ASSERT(offsetof(GetFloatv, header) == 0,
2815                OffsetOf_GetFloatv_header_not_0);
2816 COMPILE_ASSERT(offsetof(GetFloatv, pname) == 4, OffsetOf_GetFloatv_pname_not_4);
2817 COMPILE_ASSERT(offsetof(GetFloatv, params_shm_id) == 8,
2818                OffsetOf_GetFloatv_params_shm_id_not_8);
2819 COMPILE_ASSERT(offsetof(GetFloatv, params_shm_offset) == 12,
2820                OffsetOf_GetFloatv_params_shm_offset_not_12);
2821
2822 struct GetFramebufferAttachmentParameteriv {
2823   typedef GetFramebufferAttachmentParameteriv ValueType;
2824   static const CommandId kCmdId = kGetFramebufferAttachmentParameteriv;
2825   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2826   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2827
2828   typedef SizedResult<GLint> Result;
2829
2830   static uint32_t ComputeSize() {
2831     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2832   }
2833
2834   void SetHeader() { header.SetCmd<ValueType>(); }
2835
2836   void Init(GLenum _target,
2837             GLenum _attachment,
2838             GLenum _pname,
2839             uint32_t _params_shm_id,
2840             uint32_t _params_shm_offset) {
2841     SetHeader();
2842     target = _target;
2843     attachment = _attachment;
2844     pname = _pname;
2845     params_shm_id = _params_shm_id;
2846     params_shm_offset = _params_shm_offset;
2847   }
2848
2849   void* Set(void* cmd,
2850             GLenum _target,
2851             GLenum _attachment,
2852             GLenum _pname,
2853             uint32_t _params_shm_id,
2854             uint32_t _params_shm_offset) {
2855     static_cast<ValueType*>(cmd)->Init(_target, _attachment, _pname,
2856                                        _params_shm_id, _params_shm_offset);
2857     return NextCmdAddress<ValueType>(cmd);
2858   }
2859
2860   gpu::CommandHeader header;
2861   uint32_t target;
2862   uint32_t attachment;
2863   uint32_t pname;
2864   uint32_t params_shm_id;
2865   uint32_t params_shm_offset;
2866 };
2867
2868 COMPILE_ASSERT(sizeof(GetFramebufferAttachmentParameteriv) == 24,
2869                Sizeof_GetFramebufferAttachmentParameteriv_is_not_24);
2870 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, header) == 0,
2871                OffsetOf_GetFramebufferAttachmentParameteriv_header_not_0);
2872 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, target) == 4,
2873                OffsetOf_GetFramebufferAttachmentParameteriv_target_not_4);
2874 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, attachment) == 8,
2875                OffsetOf_GetFramebufferAttachmentParameteriv_attachment_not_8);
2876 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, pname) == 12,
2877                OffsetOf_GetFramebufferAttachmentParameteriv_pname_not_12);
2878 COMPILE_ASSERT(
2879     offsetof(GetFramebufferAttachmentParameteriv, params_shm_id) == 16,
2880     OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_id_not_16);
2881 COMPILE_ASSERT(
2882     offsetof(GetFramebufferAttachmentParameteriv, params_shm_offset) == 20,
2883     OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_offset_not_20);
2884
2885 struct GetIntegerv {
2886   typedef GetIntegerv ValueType;
2887   static const CommandId kCmdId = kGetIntegerv;
2888   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2889   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2890
2891   typedef SizedResult<GLint> Result;
2892
2893   static uint32_t ComputeSize() {
2894     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2895   }
2896
2897   void SetHeader() { header.SetCmd<ValueType>(); }
2898
2899   void Init(GLenum _pname,
2900             uint32_t _params_shm_id,
2901             uint32_t _params_shm_offset) {
2902     SetHeader();
2903     pname = _pname;
2904     params_shm_id = _params_shm_id;
2905     params_shm_offset = _params_shm_offset;
2906   }
2907
2908   void* Set(void* cmd,
2909             GLenum _pname,
2910             uint32_t _params_shm_id,
2911             uint32_t _params_shm_offset) {
2912     static_cast<ValueType*>(cmd)
2913         ->Init(_pname, _params_shm_id, _params_shm_offset);
2914     return NextCmdAddress<ValueType>(cmd);
2915   }
2916
2917   gpu::CommandHeader header;
2918   uint32_t pname;
2919   uint32_t params_shm_id;
2920   uint32_t params_shm_offset;
2921 };
2922
2923 COMPILE_ASSERT(sizeof(GetIntegerv) == 16, Sizeof_GetIntegerv_is_not_16);
2924 COMPILE_ASSERT(offsetof(GetIntegerv, header) == 0,
2925                OffsetOf_GetIntegerv_header_not_0);
2926 COMPILE_ASSERT(offsetof(GetIntegerv, pname) == 4,
2927                OffsetOf_GetIntegerv_pname_not_4);
2928 COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_id) == 8,
2929                OffsetOf_GetIntegerv_params_shm_id_not_8);
2930 COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_offset) == 12,
2931                OffsetOf_GetIntegerv_params_shm_offset_not_12);
2932
2933 struct GetProgramiv {
2934   typedef GetProgramiv ValueType;
2935   static const CommandId kCmdId = kGetProgramiv;
2936   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2937   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2938
2939   typedef SizedResult<GLint> Result;
2940
2941   static uint32_t ComputeSize() {
2942     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2943   }
2944
2945   void SetHeader() { header.SetCmd<ValueType>(); }
2946
2947   void Init(GLuint _program,
2948             GLenum _pname,
2949             uint32_t _params_shm_id,
2950             uint32_t _params_shm_offset) {
2951     SetHeader();
2952     program = _program;
2953     pname = _pname;
2954     params_shm_id = _params_shm_id;
2955     params_shm_offset = _params_shm_offset;
2956   }
2957
2958   void* Set(void* cmd,
2959             GLuint _program,
2960             GLenum _pname,
2961             uint32_t _params_shm_id,
2962             uint32_t _params_shm_offset) {
2963     static_cast<ValueType*>(cmd)
2964         ->Init(_program, _pname, _params_shm_id, _params_shm_offset);
2965     return NextCmdAddress<ValueType>(cmd);
2966   }
2967
2968   gpu::CommandHeader header;
2969   uint32_t program;
2970   uint32_t pname;
2971   uint32_t params_shm_id;
2972   uint32_t params_shm_offset;
2973 };
2974
2975 COMPILE_ASSERT(sizeof(GetProgramiv) == 20, Sizeof_GetProgramiv_is_not_20);
2976 COMPILE_ASSERT(offsetof(GetProgramiv, header) == 0,
2977                OffsetOf_GetProgramiv_header_not_0);
2978 COMPILE_ASSERT(offsetof(GetProgramiv, program) == 4,
2979                OffsetOf_GetProgramiv_program_not_4);
2980 COMPILE_ASSERT(offsetof(GetProgramiv, pname) == 8,
2981                OffsetOf_GetProgramiv_pname_not_8);
2982 COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_id) == 12,
2983                OffsetOf_GetProgramiv_params_shm_id_not_12);
2984 COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_offset) == 16,
2985                OffsetOf_GetProgramiv_params_shm_offset_not_16);
2986
2987 struct GetProgramInfoLog {
2988   typedef GetProgramInfoLog ValueType;
2989   static const CommandId kCmdId = kGetProgramInfoLog;
2990   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
2991   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
2992
2993   static uint32_t ComputeSize() {
2994     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
2995   }
2996
2997   void SetHeader() { header.SetCmd<ValueType>(); }
2998
2999   void Init(GLuint _program, uint32_t _bucket_id) {
3000     SetHeader();
3001     program = _program;
3002     bucket_id = _bucket_id;
3003   }
3004
3005   void* Set(void* cmd, GLuint _program, uint32_t _bucket_id) {
3006     static_cast<ValueType*>(cmd)->Init(_program, _bucket_id);
3007     return NextCmdAddress<ValueType>(cmd);
3008   }
3009
3010   gpu::CommandHeader header;
3011   uint32_t program;
3012   uint32_t bucket_id;
3013 };
3014
3015 COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 12,
3016                Sizeof_GetProgramInfoLog_is_not_12);
3017 COMPILE_ASSERT(offsetof(GetProgramInfoLog, header) == 0,
3018                OffsetOf_GetProgramInfoLog_header_not_0);
3019 COMPILE_ASSERT(offsetof(GetProgramInfoLog, program) == 4,
3020                OffsetOf_GetProgramInfoLog_program_not_4);
3021 COMPILE_ASSERT(offsetof(GetProgramInfoLog, bucket_id) == 8,
3022                OffsetOf_GetProgramInfoLog_bucket_id_not_8);
3023
3024 struct GetRenderbufferParameteriv {
3025   typedef GetRenderbufferParameteriv ValueType;
3026   static const CommandId kCmdId = kGetRenderbufferParameteriv;
3027   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3028   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3029
3030   typedef SizedResult<GLint> Result;
3031
3032   static uint32_t ComputeSize() {
3033     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3034   }
3035
3036   void SetHeader() { header.SetCmd<ValueType>(); }
3037
3038   void Init(GLenum _target,
3039             GLenum _pname,
3040             uint32_t _params_shm_id,
3041             uint32_t _params_shm_offset) {
3042     SetHeader();
3043     target = _target;
3044     pname = _pname;
3045     params_shm_id = _params_shm_id;
3046     params_shm_offset = _params_shm_offset;
3047   }
3048
3049   void* Set(void* cmd,
3050             GLenum _target,
3051             GLenum _pname,
3052             uint32_t _params_shm_id,
3053             uint32_t _params_shm_offset) {
3054     static_cast<ValueType*>(cmd)
3055         ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
3056     return NextCmdAddress<ValueType>(cmd);
3057   }
3058
3059   gpu::CommandHeader header;
3060   uint32_t target;
3061   uint32_t pname;
3062   uint32_t params_shm_id;
3063   uint32_t params_shm_offset;
3064 };
3065
3066 COMPILE_ASSERT(sizeof(GetRenderbufferParameteriv) == 20,
3067                Sizeof_GetRenderbufferParameteriv_is_not_20);
3068 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, header) == 0,
3069                OffsetOf_GetRenderbufferParameteriv_header_not_0);
3070 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, target) == 4,
3071                OffsetOf_GetRenderbufferParameteriv_target_not_4);
3072 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, pname) == 8,
3073                OffsetOf_GetRenderbufferParameteriv_pname_not_8);
3074 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_id) == 12,
3075                OffsetOf_GetRenderbufferParameteriv_params_shm_id_not_12);
3076 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_offset) == 16,
3077                OffsetOf_GetRenderbufferParameteriv_params_shm_offset_not_16);
3078
3079 struct GetShaderiv {
3080   typedef GetShaderiv ValueType;
3081   static const CommandId kCmdId = kGetShaderiv;
3082   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3083   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3084
3085   typedef SizedResult<GLint> Result;
3086
3087   static uint32_t ComputeSize() {
3088     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3089   }
3090
3091   void SetHeader() { header.SetCmd<ValueType>(); }
3092
3093   void Init(GLuint _shader,
3094             GLenum _pname,
3095             uint32_t _params_shm_id,
3096             uint32_t _params_shm_offset) {
3097     SetHeader();
3098     shader = _shader;
3099     pname = _pname;
3100     params_shm_id = _params_shm_id;
3101     params_shm_offset = _params_shm_offset;
3102   }
3103
3104   void* Set(void* cmd,
3105             GLuint _shader,
3106             GLenum _pname,
3107             uint32_t _params_shm_id,
3108             uint32_t _params_shm_offset) {
3109     static_cast<ValueType*>(cmd)
3110         ->Init(_shader, _pname, _params_shm_id, _params_shm_offset);
3111     return NextCmdAddress<ValueType>(cmd);
3112   }
3113
3114   gpu::CommandHeader header;
3115   uint32_t shader;
3116   uint32_t pname;
3117   uint32_t params_shm_id;
3118   uint32_t params_shm_offset;
3119 };
3120
3121 COMPILE_ASSERT(sizeof(GetShaderiv) == 20, Sizeof_GetShaderiv_is_not_20);
3122 COMPILE_ASSERT(offsetof(GetShaderiv, header) == 0,
3123                OffsetOf_GetShaderiv_header_not_0);
3124 COMPILE_ASSERT(offsetof(GetShaderiv, shader) == 4,
3125                OffsetOf_GetShaderiv_shader_not_4);
3126 COMPILE_ASSERT(offsetof(GetShaderiv, pname) == 8,
3127                OffsetOf_GetShaderiv_pname_not_8);
3128 COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_id) == 12,
3129                OffsetOf_GetShaderiv_params_shm_id_not_12);
3130 COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_offset) == 16,
3131                OffsetOf_GetShaderiv_params_shm_offset_not_16);
3132
3133 struct GetShaderInfoLog {
3134   typedef GetShaderInfoLog ValueType;
3135   static const CommandId kCmdId = kGetShaderInfoLog;
3136   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3137   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3138
3139   static uint32_t ComputeSize() {
3140     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3141   }
3142
3143   void SetHeader() { header.SetCmd<ValueType>(); }
3144
3145   void Init(GLuint _shader, uint32_t _bucket_id) {
3146     SetHeader();
3147     shader = _shader;
3148     bucket_id = _bucket_id;
3149   }
3150
3151   void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) {
3152     static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id);
3153     return NextCmdAddress<ValueType>(cmd);
3154   }
3155
3156   gpu::CommandHeader header;
3157   uint32_t shader;
3158   uint32_t bucket_id;
3159 };
3160
3161 COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 12,
3162                Sizeof_GetShaderInfoLog_is_not_12);
3163 COMPILE_ASSERT(offsetof(GetShaderInfoLog, header) == 0,
3164                OffsetOf_GetShaderInfoLog_header_not_0);
3165 COMPILE_ASSERT(offsetof(GetShaderInfoLog, shader) == 4,
3166                OffsetOf_GetShaderInfoLog_shader_not_4);
3167 COMPILE_ASSERT(offsetof(GetShaderInfoLog, bucket_id) == 8,
3168                OffsetOf_GetShaderInfoLog_bucket_id_not_8);
3169
3170 struct GetShaderPrecisionFormat {
3171   typedef GetShaderPrecisionFormat ValueType;
3172   static const CommandId kCmdId = kGetShaderPrecisionFormat;
3173   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3174   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3175
3176   struct Result {
3177     int32_t success;
3178     int32_t min_range;
3179     int32_t max_range;
3180     int32_t precision;
3181   };
3182
3183   static uint32_t ComputeSize() {
3184     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3185   }
3186
3187   void SetHeader() { header.SetCmd<ValueType>(); }
3188
3189   void Init(GLenum _shadertype,
3190             GLenum _precisiontype,
3191             uint32_t _result_shm_id,
3192             uint32_t _result_shm_offset) {
3193     SetHeader();
3194     shadertype = _shadertype;
3195     precisiontype = _precisiontype;
3196     result_shm_id = _result_shm_id;
3197     result_shm_offset = _result_shm_offset;
3198   }
3199
3200   void* Set(void* cmd,
3201             GLenum _shadertype,
3202             GLenum _precisiontype,
3203             uint32_t _result_shm_id,
3204             uint32_t _result_shm_offset) {
3205     static_cast<ValueType*>(cmd)
3206         ->Init(_shadertype, _precisiontype, _result_shm_id, _result_shm_offset);
3207     return NextCmdAddress<ValueType>(cmd);
3208   }
3209
3210   gpu::CommandHeader header;
3211   uint32_t shadertype;
3212   uint32_t precisiontype;
3213   uint32_t result_shm_id;
3214   uint32_t result_shm_offset;
3215 };
3216
3217 COMPILE_ASSERT(sizeof(GetShaderPrecisionFormat) == 20,
3218                Sizeof_GetShaderPrecisionFormat_is_not_20);
3219 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, header) == 0,
3220                OffsetOf_GetShaderPrecisionFormat_header_not_0);
3221 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, shadertype) == 4,
3222                OffsetOf_GetShaderPrecisionFormat_shadertype_not_4);
3223 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, precisiontype) == 8,
3224                OffsetOf_GetShaderPrecisionFormat_precisiontype_not_8);
3225 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, result_shm_id) == 12,
3226                OffsetOf_GetShaderPrecisionFormat_result_shm_id_not_12);
3227 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, result_shm_offset) == 16,
3228                OffsetOf_GetShaderPrecisionFormat_result_shm_offset_not_16);
3229 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, success) == 0,
3230                OffsetOf_GetShaderPrecisionFormat_Result_success_not_0);
3231 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, min_range) == 4,
3232                OffsetOf_GetShaderPrecisionFormat_Result_min_range_not_4);
3233 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, max_range) == 8,
3234                OffsetOf_GetShaderPrecisionFormat_Result_max_range_not_8);
3235 COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat::Result, precision) == 12,
3236                OffsetOf_GetShaderPrecisionFormat_Result_precision_not_12);
3237
3238 struct GetShaderSource {
3239   typedef GetShaderSource ValueType;
3240   static const CommandId kCmdId = kGetShaderSource;
3241   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3242   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3243
3244   static uint32_t ComputeSize() {
3245     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3246   }
3247
3248   void SetHeader() { header.SetCmd<ValueType>(); }
3249
3250   void Init(GLuint _shader, uint32_t _bucket_id) {
3251     SetHeader();
3252     shader = _shader;
3253     bucket_id = _bucket_id;
3254   }
3255
3256   void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) {
3257     static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id);
3258     return NextCmdAddress<ValueType>(cmd);
3259   }
3260
3261   gpu::CommandHeader header;
3262   uint32_t shader;
3263   uint32_t bucket_id;
3264 };
3265
3266 COMPILE_ASSERT(sizeof(GetShaderSource) == 12, Sizeof_GetShaderSource_is_not_12);
3267 COMPILE_ASSERT(offsetof(GetShaderSource, header) == 0,
3268                OffsetOf_GetShaderSource_header_not_0);
3269 COMPILE_ASSERT(offsetof(GetShaderSource, shader) == 4,
3270                OffsetOf_GetShaderSource_shader_not_4);
3271 COMPILE_ASSERT(offsetof(GetShaderSource, bucket_id) == 8,
3272                OffsetOf_GetShaderSource_bucket_id_not_8);
3273
3274 struct GetString {
3275   typedef GetString ValueType;
3276   static const CommandId kCmdId = kGetString;
3277   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3278   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3279
3280   static uint32_t ComputeSize() {
3281     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3282   }
3283
3284   void SetHeader() { header.SetCmd<ValueType>(); }
3285
3286   void Init(GLenum _name, uint32_t _bucket_id) {
3287     SetHeader();
3288     name = _name;
3289     bucket_id = _bucket_id;
3290   }
3291
3292   void* Set(void* cmd, GLenum _name, uint32_t _bucket_id) {
3293     static_cast<ValueType*>(cmd)->Init(_name, _bucket_id);
3294     return NextCmdAddress<ValueType>(cmd);
3295   }
3296
3297   gpu::CommandHeader header;
3298   uint32_t name;
3299   uint32_t bucket_id;
3300 };
3301
3302 COMPILE_ASSERT(sizeof(GetString) == 12, Sizeof_GetString_is_not_12);
3303 COMPILE_ASSERT(offsetof(GetString, header) == 0,
3304                OffsetOf_GetString_header_not_0);
3305 COMPILE_ASSERT(offsetof(GetString, name) == 4, OffsetOf_GetString_name_not_4);
3306 COMPILE_ASSERT(offsetof(GetString, bucket_id) == 8,
3307                OffsetOf_GetString_bucket_id_not_8);
3308
3309 struct GetTexParameterfv {
3310   typedef GetTexParameterfv ValueType;
3311   static const CommandId kCmdId = kGetTexParameterfv;
3312   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3313   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3314
3315   typedef SizedResult<GLfloat> Result;
3316
3317   static uint32_t ComputeSize() {
3318     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3319   }
3320
3321   void SetHeader() { header.SetCmd<ValueType>(); }
3322
3323   void Init(GLenum _target,
3324             GLenum _pname,
3325             uint32_t _params_shm_id,
3326             uint32_t _params_shm_offset) {
3327     SetHeader();
3328     target = _target;
3329     pname = _pname;
3330     params_shm_id = _params_shm_id;
3331     params_shm_offset = _params_shm_offset;
3332   }
3333
3334   void* Set(void* cmd,
3335             GLenum _target,
3336             GLenum _pname,
3337             uint32_t _params_shm_id,
3338             uint32_t _params_shm_offset) {
3339     static_cast<ValueType*>(cmd)
3340         ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
3341     return NextCmdAddress<ValueType>(cmd);
3342   }
3343
3344   gpu::CommandHeader header;
3345   uint32_t target;
3346   uint32_t pname;
3347   uint32_t params_shm_id;
3348   uint32_t params_shm_offset;
3349 };
3350
3351 COMPILE_ASSERT(sizeof(GetTexParameterfv) == 20,
3352                Sizeof_GetTexParameterfv_is_not_20);
3353 COMPILE_ASSERT(offsetof(GetTexParameterfv, header) == 0,
3354                OffsetOf_GetTexParameterfv_header_not_0);
3355 COMPILE_ASSERT(offsetof(GetTexParameterfv, target) == 4,
3356                OffsetOf_GetTexParameterfv_target_not_4);
3357 COMPILE_ASSERT(offsetof(GetTexParameterfv, pname) == 8,
3358                OffsetOf_GetTexParameterfv_pname_not_8);
3359 COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_id) == 12,
3360                OffsetOf_GetTexParameterfv_params_shm_id_not_12);
3361 COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_offset) == 16,
3362                OffsetOf_GetTexParameterfv_params_shm_offset_not_16);
3363
3364 struct GetTexParameteriv {
3365   typedef GetTexParameteriv ValueType;
3366   static const CommandId kCmdId = kGetTexParameteriv;
3367   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3368   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3369
3370   typedef SizedResult<GLint> Result;
3371
3372   static uint32_t ComputeSize() {
3373     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3374   }
3375
3376   void SetHeader() { header.SetCmd<ValueType>(); }
3377
3378   void Init(GLenum _target,
3379             GLenum _pname,
3380             uint32_t _params_shm_id,
3381             uint32_t _params_shm_offset) {
3382     SetHeader();
3383     target = _target;
3384     pname = _pname;
3385     params_shm_id = _params_shm_id;
3386     params_shm_offset = _params_shm_offset;
3387   }
3388
3389   void* Set(void* cmd,
3390             GLenum _target,
3391             GLenum _pname,
3392             uint32_t _params_shm_id,
3393             uint32_t _params_shm_offset) {
3394     static_cast<ValueType*>(cmd)
3395         ->Init(_target, _pname, _params_shm_id, _params_shm_offset);
3396     return NextCmdAddress<ValueType>(cmd);
3397   }
3398
3399   gpu::CommandHeader header;
3400   uint32_t target;
3401   uint32_t pname;
3402   uint32_t params_shm_id;
3403   uint32_t params_shm_offset;
3404 };
3405
3406 COMPILE_ASSERT(sizeof(GetTexParameteriv) == 20,
3407                Sizeof_GetTexParameteriv_is_not_20);
3408 COMPILE_ASSERT(offsetof(GetTexParameteriv, header) == 0,
3409                OffsetOf_GetTexParameteriv_header_not_0);
3410 COMPILE_ASSERT(offsetof(GetTexParameteriv, target) == 4,
3411                OffsetOf_GetTexParameteriv_target_not_4);
3412 COMPILE_ASSERT(offsetof(GetTexParameteriv, pname) == 8,
3413                OffsetOf_GetTexParameteriv_pname_not_8);
3414 COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_id) == 12,
3415                OffsetOf_GetTexParameteriv_params_shm_id_not_12);
3416 COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_offset) == 16,
3417                OffsetOf_GetTexParameteriv_params_shm_offset_not_16);
3418
3419 struct GetUniformfv {
3420   typedef GetUniformfv ValueType;
3421   static const CommandId kCmdId = kGetUniformfv;
3422   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3423   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3424
3425   typedef SizedResult<GLfloat> Result;
3426
3427   static uint32_t ComputeSize() {
3428     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3429   }
3430
3431   void SetHeader() { header.SetCmd<ValueType>(); }
3432
3433   void Init(GLuint _program,
3434             GLint _location,
3435             uint32_t _params_shm_id,
3436             uint32_t _params_shm_offset) {
3437     SetHeader();
3438     program = _program;
3439     location = _location;
3440     params_shm_id = _params_shm_id;
3441     params_shm_offset = _params_shm_offset;
3442   }
3443
3444   void* Set(void* cmd,
3445             GLuint _program,
3446             GLint _location,
3447             uint32_t _params_shm_id,
3448             uint32_t _params_shm_offset) {
3449     static_cast<ValueType*>(cmd)
3450         ->Init(_program, _location, _params_shm_id, _params_shm_offset);
3451     return NextCmdAddress<ValueType>(cmd);
3452   }
3453
3454   gpu::CommandHeader header;
3455   uint32_t program;
3456   int32_t location;
3457   uint32_t params_shm_id;
3458   uint32_t params_shm_offset;
3459 };
3460
3461 COMPILE_ASSERT(sizeof(GetUniformfv) == 20, Sizeof_GetUniformfv_is_not_20);
3462 COMPILE_ASSERT(offsetof(GetUniformfv, header) == 0,
3463                OffsetOf_GetUniformfv_header_not_0);
3464 COMPILE_ASSERT(offsetof(GetUniformfv, program) == 4,
3465                OffsetOf_GetUniformfv_program_not_4);
3466 COMPILE_ASSERT(offsetof(GetUniformfv, location) == 8,
3467                OffsetOf_GetUniformfv_location_not_8);
3468 COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_id) == 12,
3469                OffsetOf_GetUniformfv_params_shm_id_not_12);
3470 COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_offset) == 16,
3471                OffsetOf_GetUniformfv_params_shm_offset_not_16);
3472
3473 struct GetUniformiv {
3474   typedef GetUniformiv ValueType;
3475   static const CommandId kCmdId = kGetUniformiv;
3476   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3477   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3478
3479   typedef SizedResult<GLint> Result;
3480
3481   static uint32_t ComputeSize() {
3482     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3483   }
3484
3485   void SetHeader() { header.SetCmd<ValueType>(); }
3486
3487   void Init(GLuint _program,
3488             GLint _location,
3489             uint32_t _params_shm_id,
3490             uint32_t _params_shm_offset) {
3491     SetHeader();
3492     program = _program;
3493     location = _location;
3494     params_shm_id = _params_shm_id;
3495     params_shm_offset = _params_shm_offset;
3496   }
3497
3498   void* Set(void* cmd,
3499             GLuint _program,
3500             GLint _location,
3501             uint32_t _params_shm_id,
3502             uint32_t _params_shm_offset) {
3503     static_cast<ValueType*>(cmd)
3504         ->Init(_program, _location, _params_shm_id, _params_shm_offset);
3505     return NextCmdAddress<ValueType>(cmd);
3506   }
3507
3508   gpu::CommandHeader header;
3509   uint32_t program;
3510   int32_t location;
3511   uint32_t params_shm_id;
3512   uint32_t params_shm_offset;
3513 };
3514
3515 COMPILE_ASSERT(sizeof(GetUniformiv) == 20, Sizeof_GetUniformiv_is_not_20);
3516 COMPILE_ASSERT(offsetof(GetUniformiv, header) == 0,
3517                OffsetOf_GetUniformiv_header_not_0);
3518 COMPILE_ASSERT(offsetof(GetUniformiv, program) == 4,
3519                OffsetOf_GetUniformiv_program_not_4);
3520 COMPILE_ASSERT(offsetof(GetUniformiv, location) == 8,
3521                OffsetOf_GetUniformiv_location_not_8);
3522 COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_id) == 12,
3523                OffsetOf_GetUniformiv_params_shm_id_not_12);
3524 COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_offset) == 16,
3525                OffsetOf_GetUniformiv_params_shm_offset_not_16);
3526
3527 struct GetUniformLocation {
3528   typedef GetUniformLocation ValueType;
3529   static const CommandId kCmdId = kGetUniformLocation;
3530   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3531   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3532
3533   typedef GLint Result;
3534
3535   static uint32_t ComputeSize() {
3536     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3537   }
3538
3539   void SetHeader() { header.SetCmd<ValueType>(); }
3540
3541   void Init(GLuint _program,
3542             uint32_t _name_bucket_id,
3543             uint32_t _location_shm_id,
3544             uint32_t _location_shm_offset) {
3545     SetHeader();
3546     program = _program;
3547     name_bucket_id = _name_bucket_id;
3548     location_shm_id = _location_shm_id;
3549     location_shm_offset = _location_shm_offset;
3550   }
3551
3552   void* Set(void* cmd,
3553             GLuint _program,
3554             uint32_t _name_bucket_id,
3555             uint32_t _location_shm_id,
3556             uint32_t _location_shm_offset) {
3557     static_cast<ValueType*>(cmd)->Init(_program, _name_bucket_id,
3558                                        _location_shm_id, _location_shm_offset);
3559     return NextCmdAddress<ValueType>(cmd);
3560   }
3561
3562   gpu::CommandHeader header;
3563   uint32_t program;
3564   uint32_t name_bucket_id;
3565   uint32_t location_shm_id;
3566   uint32_t location_shm_offset;
3567 };
3568
3569 COMPILE_ASSERT(sizeof(GetUniformLocation) == 20,
3570                Sizeof_GetUniformLocation_is_not_20);
3571 COMPILE_ASSERT(offsetof(GetUniformLocation, header) == 0,
3572                OffsetOf_GetUniformLocation_header_not_0);
3573 COMPILE_ASSERT(offsetof(GetUniformLocation, program) == 4,
3574                OffsetOf_GetUniformLocation_program_not_4);
3575 COMPILE_ASSERT(offsetof(GetUniformLocation, name_bucket_id) == 8,
3576                OffsetOf_GetUniformLocation_name_bucket_id_not_8);
3577 COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_id) == 12,
3578                OffsetOf_GetUniformLocation_location_shm_id_not_12);
3579 COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_offset) == 16,
3580                OffsetOf_GetUniformLocation_location_shm_offset_not_16);
3581
3582 struct GetVertexAttribfv {
3583   typedef GetVertexAttribfv ValueType;
3584   static const CommandId kCmdId = kGetVertexAttribfv;
3585   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3586   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3587
3588   typedef SizedResult<GLfloat> Result;
3589
3590   static uint32_t ComputeSize() {
3591     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3592   }
3593
3594   void SetHeader() { header.SetCmd<ValueType>(); }
3595
3596   void Init(GLuint _index,
3597             GLenum _pname,
3598             uint32_t _params_shm_id,
3599             uint32_t _params_shm_offset) {
3600     SetHeader();
3601     index = _index;
3602     pname = _pname;
3603     params_shm_id = _params_shm_id;
3604     params_shm_offset = _params_shm_offset;
3605   }
3606
3607   void* Set(void* cmd,
3608             GLuint _index,
3609             GLenum _pname,
3610             uint32_t _params_shm_id,
3611             uint32_t _params_shm_offset) {
3612     static_cast<ValueType*>(cmd)
3613         ->Init(_index, _pname, _params_shm_id, _params_shm_offset);
3614     return NextCmdAddress<ValueType>(cmd);
3615   }
3616
3617   gpu::CommandHeader header;
3618   uint32_t index;
3619   uint32_t pname;
3620   uint32_t params_shm_id;
3621   uint32_t params_shm_offset;
3622 };
3623
3624 COMPILE_ASSERT(sizeof(GetVertexAttribfv) == 20,
3625                Sizeof_GetVertexAttribfv_is_not_20);
3626 COMPILE_ASSERT(offsetof(GetVertexAttribfv, header) == 0,
3627                OffsetOf_GetVertexAttribfv_header_not_0);
3628 COMPILE_ASSERT(offsetof(GetVertexAttribfv, index) == 4,
3629                OffsetOf_GetVertexAttribfv_index_not_4);
3630 COMPILE_ASSERT(offsetof(GetVertexAttribfv, pname) == 8,
3631                OffsetOf_GetVertexAttribfv_pname_not_8);
3632 COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_id) == 12,
3633                OffsetOf_GetVertexAttribfv_params_shm_id_not_12);
3634 COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_offset) == 16,
3635                OffsetOf_GetVertexAttribfv_params_shm_offset_not_16);
3636
3637 struct GetVertexAttribiv {
3638   typedef GetVertexAttribiv ValueType;
3639   static const CommandId kCmdId = kGetVertexAttribiv;
3640   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3641   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3642
3643   typedef SizedResult<GLint> Result;
3644
3645   static uint32_t ComputeSize() {
3646     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3647   }
3648
3649   void SetHeader() { header.SetCmd<ValueType>(); }
3650
3651   void Init(GLuint _index,
3652             GLenum _pname,
3653             uint32_t _params_shm_id,
3654             uint32_t _params_shm_offset) {
3655     SetHeader();
3656     index = _index;
3657     pname = _pname;
3658     params_shm_id = _params_shm_id;
3659     params_shm_offset = _params_shm_offset;
3660   }
3661
3662   void* Set(void* cmd,
3663             GLuint _index,
3664             GLenum _pname,
3665             uint32_t _params_shm_id,
3666             uint32_t _params_shm_offset) {
3667     static_cast<ValueType*>(cmd)
3668         ->Init(_index, _pname, _params_shm_id, _params_shm_offset);
3669     return NextCmdAddress<ValueType>(cmd);
3670   }
3671
3672   gpu::CommandHeader header;
3673   uint32_t index;
3674   uint32_t pname;
3675   uint32_t params_shm_id;
3676   uint32_t params_shm_offset;
3677 };
3678
3679 COMPILE_ASSERT(sizeof(GetVertexAttribiv) == 20,
3680                Sizeof_GetVertexAttribiv_is_not_20);
3681 COMPILE_ASSERT(offsetof(GetVertexAttribiv, header) == 0,
3682                OffsetOf_GetVertexAttribiv_header_not_0);
3683 COMPILE_ASSERT(offsetof(GetVertexAttribiv, index) == 4,
3684                OffsetOf_GetVertexAttribiv_index_not_4);
3685 COMPILE_ASSERT(offsetof(GetVertexAttribiv, pname) == 8,
3686                OffsetOf_GetVertexAttribiv_pname_not_8);
3687 COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_id) == 12,
3688                OffsetOf_GetVertexAttribiv_params_shm_id_not_12);
3689 COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_offset) == 16,
3690                OffsetOf_GetVertexAttribiv_params_shm_offset_not_16);
3691
3692 struct GetVertexAttribPointerv {
3693   typedef GetVertexAttribPointerv ValueType;
3694   static const CommandId kCmdId = kGetVertexAttribPointerv;
3695   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3696   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3697
3698   typedef SizedResult<GLuint> Result;
3699
3700   static uint32_t ComputeSize() {
3701     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3702   }
3703
3704   void SetHeader() { header.SetCmd<ValueType>(); }
3705
3706   void Init(GLuint _index,
3707             GLenum _pname,
3708             uint32_t _pointer_shm_id,
3709             uint32_t _pointer_shm_offset) {
3710     SetHeader();
3711     index = _index;
3712     pname = _pname;
3713     pointer_shm_id = _pointer_shm_id;
3714     pointer_shm_offset = _pointer_shm_offset;
3715   }
3716
3717   void* Set(void* cmd,
3718             GLuint _index,
3719             GLenum _pname,
3720             uint32_t _pointer_shm_id,
3721             uint32_t _pointer_shm_offset) {
3722     static_cast<ValueType*>(cmd)
3723         ->Init(_index, _pname, _pointer_shm_id, _pointer_shm_offset);
3724     return NextCmdAddress<ValueType>(cmd);
3725   }
3726
3727   gpu::CommandHeader header;
3728   uint32_t index;
3729   uint32_t pname;
3730   uint32_t pointer_shm_id;
3731   uint32_t pointer_shm_offset;
3732 };
3733
3734 COMPILE_ASSERT(sizeof(GetVertexAttribPointerv) == 20,
3735                Sizeof_GetVertexAttribPointerv_is_not_20);
3736 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, header) == 0,
3737                OffsetOf_GetVertexAttribPointerv_header_not_0);
3738 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, index) == 4,
3739                OffsetOf_GetVertexAttribPointerv_index_not_4);
3740 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pname) == 8,
3741                OffsetOf_GetVertexAttribPointerv_pname_not_8);
3742 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_id) == 12,
3743                OffsetOf_GetVertexAttribPointerv_pointer_shm_id_not_12);
3744 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_offset) == 16,
3745                OffsetOf_GetVertexAttribPointerv_pointer_shm_offset_not_16);
3746
3747 struct Hint {
3748   typedef Hint ValueType;
3749   static const CommandId kCmdId = kHint;
3750   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3751   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3752
3753   static uint32_t ComputeSize() {
3754     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3755   }
3756
3757   void SetHeader() { header.SetCmd<ValueType>(); }
3758
3759   void Init(GLenum _target, GLenum _mode) {
3760     SetHeader();
3761     target = _target;
3762     mode = _mode;
3763   }
3764
3765   void* Set(void* cmd, GLenum _target, GLenum _mode) {
3766     static_cast<ValueType*>(cmd)->Init(_target, _mode);
3767     return NextCmdAddress<ValueType>(cmd);
3768   }
3769
3770   gpu::CommandHeader header;
3771   uint32_t target;
3772   uint32_t mode;
3773 };
3774
3775 COMPILE_ASSERT(sizeof(Hint) == 12, Sizeof_Hint_is_not_12);
3776 COMPILE_ASSERT(offsetof(Hint, header) == 0, OffsetOf_Hint_header_not_0);
3777 COMPILE_ASSERT(offsetof(Hint, target) == 4, OffsetOf_Hint_target_not_4);
3778 COMPILE_ASSERT(offsetof(Hint, mode) == 8, OffsetOf_Hint_mode_not_8);
3779
3780 struct IsBuffer {
3781   typedef IsBuffer ValueType;
3782   static const CommandId kCmdId = kIsBuffer;
3783   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3784   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3785
3786   typedef uint32_t Result;
3787
3788   static uint32_t ComputeSize() {
3789     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3790   }
3791
3792   void SetHeader() { header.SetCmd<ValueType>(); }
3793
3794   void Init(GLuint _buffer,
3795             uint32_t _result_shm_id,
3796             uint32_t _result_shm_offset) {
3797     SetHeader();
3798     buffer = _buffer;
3799     result_shm_id = _result_shm_id;
3800     result_shm_offset = _result_shm_offset;
3801   }
3802
3803   void* Set(void* cmd,
3804             GLuint _buffer,
3805             uint32_t _result_shm_id,
3806             uint32_t _result_shm_offset) {
3807     static_cast<ValueType*>(cmd)
3808         ->Init(_buffer, _result_shm_id, _result_shm_offset);
3809     return NextCmdAddress<ValueType>(cmd);
3810   }
3811
3812   gpu::CommandHeader header;
3813   uint32_t buffer;
3814   uint32_t result_shm_id;
3815   uint32_t result_shm_offset;
3816 };
3817
3818 COMPILE_ASSERT(sizeof(IsBuffer) == 16, Sizeof_IsBuffer_is_not_16);
3819 COMPILE_ASSERT(offsetof(IsBuffer, header) == 0, OffsetOf_IsBuffer_header_not_0);
3820 COMPILE_ASSERT(offsetof(IsBuffer, buffer) == 4, OffsetOf_IsBuffer_buffer_not_4);
3821 COMPILE_ASSERT(offsetof(IsBuffer, result_shm_id) == 8,
3822                OffsetOf_IsBuffer_result_shm_id_not_8);
3823 COMPILE_ASSERT(offsetof(IsBuffer, result_shm_offset) == 12,
3824                OffsetOf_IsBuffer_result_shm_offset_not_12);
3825
3826 struct IsEnabled {
3827   typedef IsEnabled ValueType;
3828   static const CommandId kCmdId = kIsEnabled;
3829   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3830   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3831
3832   typedef uint32_t Result;
3833
3834   static uint32_t ComputeSize() {
3835     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3836   }
3837
3838   void SetHeader() { header.SetCmd<ValueType>(); }
3839
3840   void Init(GLenum _cap, uint32_t _result_shm_id, uint32_t _result_shm_offset) {
3841     SetHeader();
3842     cap = _cap;
3843     result_shm_id = _result_shm_id;
3844     result_shm_offset = _result_shm_offset;
3845   }
3846
3847   void* Set(void* cmd,
3848             GLenum _cap,
3849             uint32_t _result_shm_id,
3850             uint32_t _result_shm_offset) {
3851     static_cast<ValueType*>(cmd)
3852         ->Init(_cap, _result_shm_id, _result_shm_offset);
3853     return NextCmdAddress<ValueType>(cmd);
3854   }
3855
3856   gpu::CommandHeader header;
3857   uint32_t cap;
3858   uint32_t result_shm_id;
3859   uint32_t result_shm_offset;
3860 };
3861
3862 COMPILE_ASSERT(sizeof(IsEnabled) == 16, Sizeof_IsEnabled_is_not_16);
3863 COMPILE_ASSERT(offsetof(IsEnabled, header) == 0,
3864                OffsetOf_IsEnabled_header_not_0);
3865 COMPILE_ASSERT(offsetof(IsEnabled, cap) == 4, OffsetOf_IsEnabled_cap_not_4);
3866 COMPILE_ASSERT(offsetof(IsEnabled, result_shm_id) == 8,
3867                OffsetOf_IsEnabled_result_shm_id_not_8);
3868 COMPILE_ASSERT(offsetof(IsEnabled, result_shm_offset) == 12,
3869                OffsetOf_IsEnabled_result_shm_offset_not_12);
3870
3871 struct IsFramebuffer {
3872   typedef IsFramebuffer ValueType;
3873   static const CommandId kCmdId = kIsFramebuffer;
3874   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3875   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3876
3877   typedef uint32_t Result;
3878
3879   static uint32_t ComputeSize() {
3880     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3881   }
3882
3883   void SetHeader() { header.SetCmd<ValueType>(); }
3884
3885   void Init(GLuint _framebuffer,
3886             uint32_t _result_shm_id,
3887             uint32_t _result_shm_offset) {
3888     SetHeader();
3889     framebuffer = _framebuffer;
3890     result_shm_id = _result_shm_id;
3891     result_shm_offset = _result_shm_offset;
3892   }
3893
3894   void* Set(void* cmd,
3895             GLuint _framebuffer,
3896             uint32_t _result_shm_id,
3897             uint32_t _result_shm_offset) {
3898     static_cast<ValueType*>(cmd)
3899         ->Init(_framebuffer, _result_shm_id, _result_shm_offset);
3900     return NextCmdAddress<ValueType>(cmd);
3901   }
3902
3903   gpu::CommandHeader header;
3904   uint32_t framebuffer;
3905   uint32_t result_shm_id;
3906   uint32_t result_shm_offset;
3907 };
3908
3909 COMPILE_ASSERT(sizeof(IsFramebuffer) == 16, Sizeof_IsFramebuffer_is_not_16);
3910 COMPILE_ASSERT(offsetof(IsFramebuffer, header) == 0,
3911                OffsetOf_IsFramebuffer_header_not_0);
3912 COMPILE_ASSERT(offsetof(IsFramebuffer, framebuffer) == 4,
3913                OffsetOf_IsFramebuffer_framebuffer_not_4);
3914 COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_id) == 8,
3915                OffsetOf_IsFramebuffer_result_shm_id_not_8);
3916 COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_offset) == 12,
3917                OffsetOf_IsFramebuffer_result_shm_offset_not_12);
3918
3919 struct IsProgram {
3920   typedef IsProgram ValueType;
3921   static const CommandId kCmdId = kIsProgram;
3922   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3923   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3924
3925   typedef uint32_t Result;
3926
3927   static uint32_t ComputeSize() {
3928     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3929   }
3930
3931   void SetHeader() { header.SetCmd<ValueType>(); }
3932
3933   void Init(GLuint _program,
3934             uint32_t _result_shm_id,
3935             uint32_t _result_shm_offset) {
3936     SetHeader();
3937     program = _program;
3938     result_shm_id = _result_shm_id;
3939     result_shm_offset = _result_shm_offset;
3940   }
3941
3942   void* Set(void* cmd,
3943             GLuint _program,
3944             uint32_t _result_shm_id,
3945             uint32_t _result_shm_offset) {
3946     static_cast<ValueType*>(cmd)
3947         ->Init(_program, _result_shm_id, _result_shm_offset);
3948     return NextCmdAddress<ValueType>(cmd);
3949   }
3950
3951   gpu::CommandHeader header;
3952   uint32_t program;
3953   uint32_t result_shm_id;
3954   uint32_t result_shm_offset;
3955 };
3956
3957 COMPILE_ASSERT(sizeof(IsProgram) == 16, Sizeof_IsProgram_is_not_16);
3958 COMPILE_ASSERT(offsetof(IsProgram, header) == 0,
3959                OffsetOf_IsProgram_header_not_0);
3960 COMPILE_ASSERT(offsetof(IsProgram, program) == 4,
3961                OffsetOf_IsProgram_program_not_4);
3962 COMPILE_ASSERT(offsetof(IsProgram, result_shm_id) == 8,
3963                OffsetOf_IsProgram_result_shm_id_not_8);
3964 COMPILE_ASSERT(offsetof(IsProgram, result_shm_offset) == 12,
3965                OffsetOf_IsProgram_result_shm_offset_not_12);
3966
3967 struct IsRenderbuffer {
3968   typedef IsRenderbuffer ValueType;
3969   static const CommandId kCmdId = kIsRenderbuffer;
3970   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
3971   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
3972
3973   typedef uint32_t Result;
3974
3975   static uint32_t ComputeSize() {
3976     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
3977   }
3978
3979   void SetHeader() { header.SetCmd<ValueType>(); }
3980
3981   void Init(GLuint _renderbuffer,
3982             uint32_t _result_shm_id,
3983             uint32_t _result_shm_offset) {
3984     SetHeader();
3985     renderbuffer = _renderbuffer;
3986     result_shm_id = _result_shm_id;
3987     result_shm_offset = _result_shm_offset;
3988   }
3989
3990   void* Set(void* cmd,
3991             GLuint _renderbuffer,
3992             uint32_t _result_shm_id,
3993             uint32_t _result_shm_offset) {
3994     static_cast<ValueType*>(cmd)
3995         ->Init(_renderbuffer, _result_shm_id, _result_shm_offset);
3996     return NextCmdAddress<ValueType>(cmd);
3997   }
3998
3999   gpu::CommandHeader header;
4000   uint32_t renderbuffer;
4001   uint32_t result_shm_id;
4002   uint32_t result_shm_offset;
4003 };
4004
4005 COMPILE_ASSERT(sizeof(IsRenderbuffer) == 16, Sizeof_IsRenderbuffer_is_not_16);
4006 COMPILE_ASSERT(offsetof(IsRenderbuffer, header) == 0,
4007                OffsetOf_IsRenderbuffer_header_not_0);
4008 COMPILE_ASSERT(offsetof(IsRenderbuffer, renderbuffer) == 4,
4009                OffsetOf_IsRenderbuffer_renderbuffer_not_4);
4010 COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_id) == 8,
4011                OffsetOf_IsRenderbuffer_result_shm_id_not_8);
4012 COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_offset) == 12,
4013                OffsetOf_IsRenderbuffer_result_shm_offset_not_12);
4014
4015 struct IsShader {
4016   typedef IsShader ValueType;
4017   static const CommandId kCmdId = kIsShader;
4018   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4019   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4020
4021   typedef uint32_t Result;
4022
4023   static uint32_t ComputeSize() {
4024     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4025   }
4026
4027   void SetHeader() { header.SetCmd<ValueType>(); }
4028
4029   void Init(GLuint _shader,
4030             uint32_t _result_shm_id,
4031             uint32_t _result_shm_offset) {
4032     SetHeader();
4033     shader = _shader;
4034     result_shm_id = _result_shm_id;
4035     result_shm_offset = _result_shm_offset;
4036   }
4037
4038   void* Set(void* cmd,
4039             GLuint _shader,
4040             uint32_t _result_shm_id,
4041             uint32_t _result_shm_offset) {
4042     static_cast<ValueType*>(cmd)
4043         ->Init(_shader, _result_shm_id, _result_shm_offset);
4044     return NextCmdAddress<ValueType>(cmd);
4045   }
4046
4047   gpu::CommandHeader header;
4048   uint32_t shader;
4049   uint32_t result_shm_id;
4050   uint32_t result_shm_offset;
4051 };
4052
4053 COMPILE_ASSERT(sizeof(IsShader) == 16, Sizeof_IsShader_is_not_16);
4054 COMPILE_ASSERT(offsetof(IsShader, header) == 0, OffsetOf_IsShader_header_not_0);
4055 COMPILE_ASSERT(offsetof(IsShader, shader) == 4, OffsetOf_IsShader_shader_not_4);
4056 COMPILE_ASSERT(offsetof(IsShader, result_shm_id) == 8,
4057                OffsetOf_IsShader_result_shm_id_not_8);
4058 COMPILE_ASSERT(offsetof(IsShader, result_shm_offset) == 12,
4059                OffsetOf_IsShader_result_shm_offset_not_12);
4060
4061 struct IsTexture {
4062   typedef IsTexture ValueType;
4063   static const CommandId kCmdId = kIsTexture;
4064   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4065   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4066
4067   typedef uint32_t Result;
4068
4069   static uint32_t ComputeSize() {
4070     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4071   }
4072
4073   void SetHeader() { header.SetCmd<ValueType>(); }
4074
4075   void Init(GLuint _texture,
4076             uint32_t _result_shm_id,
4077             uint32_t _result_shm_offset) {
4078     SetHeader();
4079     texture = _texture;
4080     result_shm_id = _result_shm_id;
4081     result_shm_offset = _result_shm_offset;
4082   }
4083
4084   void* Set(void* cmd,
4085             GLuint _texture,
4086             uint32_t _result_shm_id,
4087             uint32_t _result_shm_offset) {
4088     static_cast<ValueType*>(cmd)
4089         ->Init(_texture, _result_shm_id, _result_shm_offset);
4090     return NextCmdAddress<ValueType>(cmd);
4091   }
4092
4093   gpu::CommandHeader header;
4094   uint32_t texture;
4095   uint32_t result_shm_id;
4096   uint32_t result_shm_offset;
4097 };
4098
4099 COMPILE_ASSERT(sizeof(IsTexture) == 16, Sizeof_IsTexture_is_not_16);
4100 COMPILE_ASSERT(offsetof(IsTexture, header) == 0,
4101                OffsetOf_IsTexture_header_not_0);
4102 COMPILE_ASSERT(offsetof(IsTexture, texture) == 4,
4103                OffsetOf_IsTexture_texture_not_4);
4104 COMPILE_ASSERT(offsetof(IsTexture, result_shm_id) == 8,
4105                OffsetOf_IsTexture_result_shm_id_not_8);
4106 COMPILE_ASSERT(offsetof(IsTexture, result_shm_offset) == 12,
4107                OffsetOf_IsTexture_result_shm_offset_not_12);
4108
4109 struct LineWidth {
4110   typedef LineWidth ValueType;
4111   static const CommandId kCmdId = kLineWidth;
4112   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4113   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4114
4115   static uint32_t ComputeSize() {
4116     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4117   }
4118
4119   void SetHeader() { header.SetCmd<ValueType>(); }
4120
4121   void Init(GLfloat _width) {
4122     SetHeader();
4123     width = _width;
4124   }
4125
4126   void* Set(void* cmd, GLfloat _width) {
4127     static_cast<ValueType*>(cmd)->Init(_width);
4128     return NextCmdAddress<ValueType>(cmd);
4129   }
4130
4131   gpu::CommandHeader header;
4132   float width;
4133 };
4134
4135 COMPILE_ASSERT(sizeof(LineWidth) == 8, Sizeof_LineWidth_is_not_8);
4136 COMPILE_ASSERT(offsetof(LineWidth, header) == 0,
4137                OffsetOf_LineWidth_header_not_0);
4138 COMPILE_ASSERT(offsetof(LineWidth, width) == 4, OffsetOf_LineWidth_width_not_4);
4139
4140 struct LinkProgram {
4141   typedef LinkProgram ValueType;
4142   static const CommandId kCmdId = kLinkProgram;
4143   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4144   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4145
4146   static uint32_t ComputeSize() {
4147     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4148   }
4149
4150   void SetHeader() { header.SetCmd<ValueType>(); }
4151
4152   void Init(GLuint _program) {
4153     SetHeader();
4154     program = _program;
4155   }
4156
4157   void* Set(void* cmd, GLuint _program) {
4158     static_cast<ValueType*>(cmd)->Init(_program);
4159     return NextCmdAddress<ValueType>(cmd);
4160   }
4161
4162   gpu::CommandHeader header;
4163   uint32_t program;
4164 };
4165
4166 COMPILE_ASSERT(sizeof(LinkProgram) == 8, Sizeof_LinkProgram_is_not_8);
4167 COMPILE_ASSERT(offsetof(LinkProgram, header) == 0,
4168                OffsetOf_LinkProgram_header_not_0);
4169 COMPILE_ASSERT(offsetof(LinkProgram, program) == 4,
4170                OffsetOf_LinkProgram_program_not_4);
4171
4172 struct PixelStorei {
4173   typedef PixelStorei ValueType;
4174   static const CommandId kCmdId = kPixelStorei;
4175   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4176   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4177
4178   static uint32_t ComputeSize() {
4179     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4180   }
4181
4182   void SetHeader() { header.SetCmd<ValueType>(); }
4183
4184   void Init(GLenum _pname, GLint _param) {
4185     SetHeader();
4186     pname = _pname;
4187     param = _param;
4188   }
4189
4190   void* Set(void* cmd, GLenum _pname, GLint _param) {
4191     static_cast<ValueType*>(cmd)->Init(_pname, _param);
4192     return NextCmdAddress<ValueType>(cmd);
4193   }
4194
4195   gpu::CommandHeader header;
4196   uint32_t pname;
4197   int32_t param;
4198 };
4199
4200 COMPILE_ASSERT(sizeof(PixelStorei) == 12, Sizeof_PixelStorei_is_not_12);
4201 COMPILE_ASSERT(offsetof(PixelStorei, header) == 0,
4202                OffsetOf_PixelStorei_header_not_0);
4203 COMPILE_ASSERT(offsetof(PixelStorei, pname) == 4,
4204                OffsetOf_PixelStorei_pname_not_4);
4205 COMPILE_ASSERT(offsetof(PixelStorei, param) == 8,
4206                OffsetOf_PixelStorei_param_not_8);
4207
4208 struct PolygonOffset {
4209   typedef PolygonOffset ValueType;
4210   static const CommandId kCmdId = kPolygonOffset;
4211   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4212   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4213
4214   static uint32_t ComputeSize() {
4215     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4216   }
4217
4218   void SetHeader() { header.SetCmd<ValueType>(); }
4219
4220   void Init(GLfloat _factor, GLfloat _units) {
4221     SetHeader();
4222     factor = _factor;
4223     units = _units;
4224   }
4225
4226   void* Set(void* cmd, GLfloat _factor, GLfloat _units) {
4227     static_cast<ValueType*>(cmd)->Init(_factor, _units);
4228     return NextCmdAddress<ValueType>(cmd);
4229   }
4230
4231   gpu::CommandHeader header;
4232   float factor;
4233   float units;
4234 };
4235
4236 COMPILE_ASSERT(sizeof(PolygonOffset) == 12, Sizeof_PolygonOffset_is_not_12);
4237 COMPILE_ASSERT(offsetof(PolygonOffset, header) == 0,
4238                OffsetOf_PolygonOffset_header_not_0);
4239 COMPILE_ASSERT(offsetof(PolygonOffset, factor) == 4,
4240                OffsetOf_PolygonOffset_factor_not_4);
4241 COMPILE_ASSERT(offsetof(PolygonOffset, units) == 8,
4242                OffsetOf_PolygonOffset_units_not_8);
4243
4244 // ReadPixels has the result separated from the pixel buffer so that
4245 // it is easier to specify the result going to some specific place
4246 // that exactly fits the rectangle of pixels.
4247 struct ReadPixels {
4248   typedef ReadPixels ValueType;
4249   static const CommandId kCmdId = kReadPixels;
4250   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4251   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4252
4253   typedef uint32_t Result;
4254
4255   static uint32_t ComputeSize() {
4256     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4257   }
4258
4259   void SetHeader() { header.SetCmd<ValueType>(); }
4260
4261   void Init(GLint _x,
4262             GLint _y,
4263             GLsizei _width,
4264             GLsizei _height,
4265             GLenum _format,
4266             GLenum _type,
4267             uint32_t _pixels_shm_id,
4268             uint32_t _pixels_shm_offset,
4269             uint32_t _result_shm_id,
4270             uint32_t _result_shm_offset,
4271             GLboolean _async) {
4272     SetHeader();
4273     x = _x;
4274     y = _y;
4275     width = _width;
4276     height = _height;
4277     format = _format;
4278     type = _type;
4279     pixels_shm_id = _pixels_shm_id;
4280     pixels_shm_offset = _pixels_shm_offset;
4281     result_shm_id = _result_shm_id;
4282     result_shm_offset = _result_shm_offset;
4283     async = _async;
4284   }
4285
4286   void* Set(void* cmd,
4287             GLint _x,
4288             GLint _y,
4289             GLsizei _width,
4290             GLsizei _height,
4291             GLenum _format,
4292             GLenum _type,
4293             uint32_t _pixels_shm_id,
4294             uint32_t _pixels_shm_offset,
4295             uint32_t _result_shm_id,
4296             uint32_t _result_shm_offset,
4297             GLboolean _async) {
4298     static_cast<ValueType*>(cmd)
4299         ->Init(_x, _y, _width, _height, _format, _type, _pixels_shm_id,
4300                _pixels_shm_offset, _result_shm_id, _result_shm_offset, _async);
4301     return NextCmdAddress<ValueType>(cmd);
4302   }
4303
4304   gpu::CommandHeader header;
4305   int32_t x;
4306   int32_t y;
4307   int32_t width;
4308   int32_t height;
4309   uint32_t format;
4310   uint32_t type;
4311   uint32_t pixels_shm_id;
4312   uint32_t pixels_shm_offset;
4313   uint32_t result_shm_id;
4314   uint32_t result_shm_offset;
4315   uint32_t async;
4316 };
4317
4318 COMPILE_ASSERT(sizeof(ReadPixels) == 48, Sizeof_ReadPixels_is_not_48);
4319 COMPILE_ASSERT(offsetof(ReadPixels, header) == 0,
4320                OffsetOf_ReadPixels_header_not_0);
4321 COMPILE_ASSERT(offsetof(ReadPixels, x) == 4, OffsetOf_ReadPixels_x_not_4);
4322 COMPILE_ASSERT(offsetof(ReadPixels, y) == 8, OffsetOf_ReadPixels_y_not_8);
4323 COMPILE_ASSERT(offsetof(ReadPixels, width) == 12,
4324                OffsetOf_ReadPixels_width_not_12);
4325 COMPILE_ASSERT(offsetof(ReadPixels, height) == 16,
4326                OffsetOf_ReadPixels_height_not_16);
4327 COMPILE_ASSERT(offsetof(ReadPixels, format) == 20,
4328                OffsetOf_ReadPixels_format_not_20);
4329 COMPILE_ASSERT(offsetof(ReadPixels, type) == 24,
4330                OffsetOf_ReadPixels_type_not_24);
4331 COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_id) == 28,
4332                OffsetOf_ReadPixels_pixels_shm_id_not_28);
4333 COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_offset) == 32,
4334                OffsetOf_ReadPixels_pixels_shm_offset_not_32);
4335 COMPILE_ASSERT(offsetof(ReadPixels, result_shm_id) == 36,
4336                OffsetOf_ReadPixels_result_shm_id_not_36);
4337 COMPILE_ASSERT(offsetof(ReadPixels, result_shm_offset) == 40,
4338                OffsetOf_ReadPixels_result_shm_offset_not_40);
4339 COMPILE_ASSERT(offsetof(ReadPixels, async) == 44,
4340                OffsetOf_ReadPixels_async_not_44);
4341
4342 struct ReleaseShaderCompiler {
4343   typedef ReleaseShaderCompiler ValueType;
4344   static const CommandId kCmdId = kReleaseShaderCompiler;
4345   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4346   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4347
4348   static uint32_t ComputeSize() {
4349     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4350   }
4351
4352   void SetHeader() { header.SetCmd<ValueType>(); }
4353
4354   void Init() { SetHeader(); }
4355
4356   void* Set(void* cmd) {
4357     static_cast<ValueType*>(cmd)->Init();
4358     return NextCmdAddress<ValueType>(cmd);
4359   }
4360
4361   gpu::CommandHeader header;
4362 };
4363
4364 COMPILE_ASSERT(sizeof(ReleaseShaderCompiler) == 4,
4365                Sizeof_ReleaseShaderCompiler_is_not_4);
4366 COMPILE_ASSERT(offsetof(ReleaseShaderCompiler, header) == 0,
4367                OffsetOf_ReleaseShaderCompiler_header_not_0);
4368
4369 struct RenderbufferStorage {
4370   typedef RenderbufferStorage ValueType;
4371   static const CommandId kCmdId = kRenderbufferStorage;
4372   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4373   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4374
4375   static uint32_t ComputeSize() {
4376     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4377   }
4378
4379   void SetHeader() { header.SetCmd<ValueType>(); }
4380
4381   void Init(GLenum _target,
4382             GLenum _internalformat,
4383             GLsizei _width,
4384             GLsizei _height) {
4385     SetHeader();
4386     target = _target;
4387     internalformat = _internalformat;
4388     width = _width;
4389     height = _height;
4390   }
4391
4392   void* Set(void* cmd,
4393             GLenum _target,
4394             GLenum _internalformat,
4395             GLsizei _width,
4396             GLsizei _height) {
4397     static_cast<ValueType*>(cmd)
4398         ->Init(_target, _internalformat, _width, _height);
4399     return NextCmdAddress<ValueType>(cmd);
4400   }
4401
4402   gpu::CommandHeader header;
4403   uint32_t target;
4404   uint32_t internalformat;
4405   int32_t width;
4406   int32_t height;
4407 };
4408
4409 COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20,
4410                Sizeof_RenderbufferStorage_is_not_20);
4411 COMPILE_ASSERT(offsetof(RenderbufferStorage, header) == 0,
4412                OffsetOf_RenderbufferStorage_header_not_0);
4413 COMPILE_ASSERT(offsetof(RenderbufferStorage, target) == 4,
4414                OffsetOf_RenderbufferStorage_target_not_4);
4415 COMPILE_ASSERT(offsetof(RenderbufferStorage, internalformat) == 8,
4416                OffsetOf_RenderbufferStorage_internalformat_not_8);
4417 COMPILE_ASSERT(offsetof(RenderbufferStorage, width) == 12,
4418                OffsetOf_RenderbufferStorage_width_not_12);
4419 COMPILE_ASSERT(offsetof(RenderbufferStorage, height) == 16,
4420                OffsetOf_RenderbufferStorage_height_not_16);
4421
4422 struct SampleCoverage {
4423   typedef SampleCoverage ValueType;
4424   static const CommandId kCmdId = kSampleCoverage;
4425   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4426   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4427
4428   static uint32_t ComputeSize() {
4429     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4430   }
4431
4432   void SetHeader() { header.SetCmd<ValueType>(); }
4433
4434   void Init(GLclampf _value, GLboolean _invert) {
4435     SetHeader();
4436     value = _value;
4437     invert = _invert;
4438   }
4439
4440   void* Set(void* cmd, GLclampf _value, GLboolean _invert) {
4441     static_cast<ValueType*>(cmd)->Init(_value, _invert);
4442     return NextCmdAddress<ValueType>(cmd);
4443   }
4444
4445   gpu::CommandHeader header;
4446   float value;
4447   uint32_t invert;
4448 };
4449
4450 COMPILE_ASSERT(sizeof(SampleCoverage) == 12, Sizeof_SampleCoverage_is_not_12);
4451 COMPILE_ASSERT(offsetof(SampleCoverage, header) == 0,
4452                OffsetOf_SampleCoverage_header_not_0);
4453 COMPILE_ASSERT(offsetof(SampleCoverage, value) == 4,
4454                OffsetOf_SampleCoverage_value_not_4);
4455 COMPILE_ASSERT(offsetof(SampleCoverage, invert) == 8,
4456                OffsetOf_SampleCoverage_invert_not_8);
4457
4458 struct Scissor {
4459   typedef Scissor ValueType;
4460   static const CommandId kCmdId = kScissor;
4461   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4462   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4463
4464   static uint32_t ComputeSize() {
4465     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4466   }
4467
4468   void SetHeader() { header.SetCmd<ValueType>(); }
4469
4470   void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
4471     SetHeader();
4472     x = _x;
4473     y = _y;
4474     width = _width;
4475     height = _height;
4476   }
4477
4478   void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
4479     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
4480     return NextCmdAddress<ValueType>(cmd);
4481   }
4482
4483   gpu::CommandHeader header;
4484   int32_t x;
4485   int32_t y;
4486   int32_t width;
4487   int32_t height;
4488 };
4489
4490 COMPILE_ASSERT(sizeof(Scissor) == 20, Sizeof_Scissor_is_not_20);
4491 COMPILE_ASSERT(offsetof(Scissor, header) == 0, OffsetOf_Scissor_header_not_0);
4492 COMPILE_ASSERT(offsetof(Scissor, x) == 4, OffsetOf_Scissor_x_not_4);
4493 COMPILE_ASSERT(offsetof(Scissor, y) == 8, OffsetOf_Scissor_y_not_8);
4494 COMPILE_ASSERT(offsetof(Scissor, width) == 12, OffsetOf_Scissor_width_not_12);
4495 COMPILE_ASSERT(offsetof(Scissor, height) == 16, OffsetOf_Scissor_height_not_16);
4496
4497 struct ShaderBinary {
4498   typedef ShaderBinary ValueType;
4499   static const CommandId kCmdId = kShaderBinary;
4500   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4501   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4502
4503   static uint32_t ComputeSize() {
4504     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4505   }
4506
4507   void SetHeader() { header.SetCmd<ValueType>(); }
4508
4509   void Init(GLsizei _n,
4510             uint32_t _shaders_shm_id,
4511             uint32_t _shaders_shm_offset,
4512             GLenum _binaryformat,
4513             uint32_t _binary_shm_id,
4514             uint32_t _binary_shm_offset,
4515             GLsizei _length) {
4516     SetHeader();
4517     n = _n;
4518     shaders_shm_id = _shaders_shm_id;
4519     shaders_shm_offset = _shaders_shm_offset;
4520     binaryformat = _binaryformat;
4521     binary_shm_id = _binary_shm_id;
4522     binary_shm_offset = _binary_shm_offset;
4523     length = _length;
4524   }
4525
4526   void* Set(void* cmd,
4527             GLsizei _n,
4528             uint32_t _shaders_shm_id,
4529             uint32_t _shaders_shm_offset,
4530             GLenum _binaryformat,
4531             uint32_t _binary_shm_id,
4532             uint32_t _binary_shm_offset,
4533             GLsizei _length) {
4534     static_cast<ValueType*>(cmd)->Init(_n, _shaders_shm_id, _shaders_shm_offset,
4535                                        _binaryformat, _binary_shm_id,
4536                                        _binary_shm_offset, _length);
4537     return NextCmdAddress<ValueType>(cmd);
4538   }
4539
4540   gpu::CommandHeader header;
4541   int32_t n;
4542   uint32_t shaders_shm_id;
4543   uint32_t shaders_shm_offset;
4544   uint32_t binaryformat;
4545   uint32_t binary_shm_id;
4546   uint32_t binary_shm_offset;
4547   int32_t length;
4548 };
4549
4550 COMPILE_ASSERT(sizeof(ShaderBinary) == 32, Sizeof_ShaderBinary_is_not_32);
4551 COMPILE_ASSERT(offsetof(ShaderBinary, header) == 0,
4552                OffsetOf_ShaderBinary_header_not_0);
4553 COMPILE_ASSERT(offsetof(ShaderBinary, n) == 4, OffsetOf_ShaderBinary_n_not_4);
4554 COMPILE_ASSERT(offsetof(ShaderBinary, shaders_shm_id) == 8,
4555                OffsetOf_ShaderBinary_shaders_shm_id_not_8);
4556 COMPILE_ASSERT(offsetof(ShaderBinary, shaders_shm_offset) == 12,
4557                OffsetOf_ShaderBinary_shaders_shm_offset_not_12);
4558 COMPILE_ASSERT(offsetof(ShaderBinary, binaryformat) == 16,
4559                OffsetOf_ShaderBinary_binaryformat_not_16);
4560 COMPILE_ASSERT(offsetof(ShaderBinary, binary_shm_id) == 20,
4561                OffsetOf_ShaderBinary_binary_shm_id_not_20);
4562 COMPILE_ASSERT(offsetof(ShaderBinary, binary_shm_offset) == 24,
4563                OffsetOf_ShaderBinary_binary_shm_offset_not_24);
4564 COMPILE_ASSERT(offsetof(ShaderBinary, length) == 28,
4565                OffsetOf_ShaderBinary_length_not_28);
4566
4567 struct ShaderSourceBucket {
4568   typedef ShaderSourceBucket ValueType;
4569   static const CommandId kCmdId = kShaderSourceBucket;
4570   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4571   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4572
4573   static uint32_t ComputeSize() {
4574     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4575   }
4576
4577   void SetHeader() { header.SetCmd<ValueType>(); }
4578
4579   void Init(GLuint _shader, uint32_t _data_bucket_id) {
4580     SetHeader();
4581     shader = _shader;
4582     data_bucket_id = _data_bucket_id;
4583   }
4584
4585   void* Set(void* cmd, GLuint _shader, uint32_t _data_bucket_id) {
4586     static_cast<ValueType*>(cmd)->Init(_shader, _data_bucket_id);
4587     return NextCmdAddress<ValueType>(cmd);
4588   }
4589
4590   gpu::CommandHeader header;
4591   uint32_t shader;
4592   uint32_t data_bucket_id;
4593 };
4594
4595 COMPILE_ASSERT(sizeof(ShaderSourceBucket) == 12,
4596                Sizeof_ShaderSourceBucket_is_not_12);
4597 COMPILE_ASSERT(offsetof(ShaderSourceBucket, header) == 0,
4598                OffsetOf_ShaderSourceBucket_header_not_0);
4599 COMPILE_ASSERT(offsetof(ShaderSourceBucket, shader) == 4,
4600                OffsetOf_ShaderSourceBucket_shader_not_4);
4601 COMPILE_ASSERT(offsetof(ShaderSourceBucket, data_bucket_id) == 8,
4602                OffsetOf_ShaderSourceBucket_data_bucket_id_not_8);
4603
4604 struct StencilFunc {
4605   typedef StencilFunc ValueType;
4606   static const CommandId kCmdId = kStencilFunc;
4607   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4608   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4609
4610   static uint32_t ComputeSize() {
4611     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4612   }
4613
4614   void SetHeader() { header.SetCmd<ValueType>(); }
4615
4616   void Init(GLenum _func, GLint _ref, GLuint _mask) {
4617     SetHeader();
4618     func = _func;
4619     ref = _ref;
4620     mask = _mask;
4621   }
4622
4623   void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) {
4624     static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask);
4625     return NextCmdAddress<ValueType>(cmd);
4626   }
4627
4628   gpu::CommandHeader header;
4629   uint32_t func;
4630   int32_t ref;
4631   uint32_t mask;
4632 };
4633
4634 COMPILE_ASSERT(sizeof(StencilFunc) == 16, Sizeof_StencilFunc_is_not_16);
4635 COMPILE_ASSERT(offsetof(StencilFunc, header) == 0,
4636                OffsetOf_StencilFunc_header_not_0);
4637 COMPILE_ASSERT(offsetof(StencilFunc, func) == 4,
4638                OffsetOf_StencilFunc_func_not_4);
4639 COMPILE_ASSERT(offsetof(StencilFunc, ref) == 8, OffsetOf_StencilFunc_ref_not_8);
4640 COMPILE_ASSERT(offsetof(StencilFunc, mask) == 12,
4641                OffsetOf_StencilFunc_mask_not_12);
4642
4643 struct StencilFuncSeparate {
4644   typedef StencilFuncSeparate ValueType;
4645   static const CommandId kCmdId = kStencilFuncSeparate;
4646   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4647   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4648
4649   static uint32_t ComputeSize() {
4650     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4651   }
4652
4653   void SetHeader() { header.SetCmd<ValueType>(); }
4654
4655   void Init(GLenum _face, GLenum _func, GLint _ref, GLuint _mask) {
4656     SetHeader();
4657     face = _face;
4658     func = _func;
4659     ref = _ref;
4660     mask = _mask;
4661   }
4662
4663   void* Set(void* cmd, GLenum _face, GLenum _func, GLint _ref, GLuint _mask) {
4664     static_cast<ValueType*>(cmd)->Init(_face, _func, _ref, _mask);
4665     return NextCmdAddress<ValueType>(cmd);
4666   }
4667
4668   gpu::CommandHeader header;
4669   uint32_t face;
4670   uint32_t func;
4671   int32_t ref;
4672   uint32_t mask;
4673 };
4674
4675 COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20,
4676                Sizeof_StencilFuncSeparate_is_not_20);
4677 COMPILE_ASSERT(offsetof(StencilFuncSeparate, header) == 0,
4678                OffsetOf_StencilFuncSeparate_header_not_0);
4679 COMPILE_ASSERT(offsetof(StencilFuncSeparate, face) == 4,
4680                OffsetOf_StencilFuncSeparate_face_not_4);
4681 COMPILE_ASSERT(offsetof(StencilFuncSeparate, func) == 8,
4682                OffsetOf_StencilFuncSeparate_func_not_8);
4683 COMPILE_ASSERT(offsetof(StencilFuncSeparate, ref) == 12,
4684                OffsetOf_StencilFuncSeparate_ref_not_12);
4685 COMPILE_ASSERT(offsetof(StencilFuncSeparate, mask) == 16,
4686                OffsetOf_StencilFuncSeparate_mask_not_16);
4687
4688 struct StencilMask {
4689   typedef StencilMask ValueType;
4690   static const CommandId kCmdId = kStencilMask;
4691   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4692   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4693
4694   static uint32_t ComputeSize() {
4695     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4696   }
4697
4698   void SetHeader() { header.SetCmd<ValueType>(); }
4699
4700   void Init(GLuint _mask) {
4701     SetHeader();
4702     mask = _mask;
4703   }
4704
4705   void* Set(void* cmd, GLuint _mask) {
4706     static_cast<ValueType*>(cmd)->Init(_mask);
4707     return NextCmdAddress<ValueType>(cmd);
4708   }
4709
4710   gpu::CommandHeader header;
4711   uint32_t mask;
4712 };
4713
4714 COMPILE_ASSERT(sizeof(StencilMask) == 8, Sizeof_StencilMask_is_not_8);
4715 COMPILE_ASSERT(offsetof(StencilMask, header) == 0,
4716                OffsetOf_StencilMask_header_not_0);
4717 COMPILE_ASSERT(offsetof(StencilMask, mask) == 4,
4718                OffsetOf_StencilMask_mask_not_4);
4719
4720 struct StencilMaskSeparate {
4721   typedef StencilMaskSeparate ValueType;
4722   static const CommandId kCmdId = kStencilMaskSeparate;
4723   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4724   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4725
4726   static uint32_t ComputeSize() {
4727     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4728   }
4729
4730   void SetHeader() { header.SetCmd<ValueType>(); }
4731
4732   void Init(GLenum _face, GLuint _mask) {
4733     SetHeader();
4734     face = _face;
4735     mask = _mask;
4736   }
4737
4738   void* Set(void* cmd, GLenum _face, GLuint _mask) {
4739     static_cast<ValueType*>(cmd)->Init(_face, _mask);
4740     return NextCmdAddress<ValueType>(cmd);
4741   }
4742
4743   gpu::CommandHeader header;
4744   uint32_t face;
4745   uint32_t mask;
4746 };
4747
4748 COMPILE_ASSERT(sizeof(StencilMaskSeparate) == 12,
4749                Sizeof_StencilMaskSeparate_is_not_12);
4750 COMPILE_ASSERT(offsetof(StencilMaskSeparate, header) == 0,
4751                OffsetOf_StencilMaskSeparate_header_not_0);
4752 COMPILE_ASSERT(offsetof(StencilMaskSeparate, face) == 4,
4753                OffsetOf_StencilMaskSeparate_face_not_4);
4754 COMPILE_ASSERT(offsetof(StencilMaskSeparate, mask) == 8,
4755                OffsetOf_StencilMaskSeparate_mask_not_8);
4756
4757 struct StencilOp {
4758   typedef StencilOp ValueType;
4759   static const CommandId kCmdId = kStencilOp;
4760   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4761   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4762
4763   static uint32_t ComputeSize() {
4764     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4765   }
4766
4767   void SetHeader() { header.SetCmd<ValueType>(); }
4768
4769   void Init(GLenum _fail, GLenum _zfail, GLenum _zpass) {
4770     SetHeader();
4771     fail = _fail;
4772     zfail = _zfail;
4773     zpass = _zpass;
4774   }
4775
4776   void* Set(void* cmd, GLenum _fail, GLenum _zfail, GLenum _zpass) {
4777     static_cast<ValueType*>(cmd)->Init(_fail, _zfail, _zpass);
4778     return NextCmdAddress<ValueType>(cmd);
4779   }
4780
4781   gpu::CommandHeader header;
4782   uint32_t fail;
4783   uint32_t zfail;
4784   uint32_t zpass;
4785 };
4786
4787 COMPILE_ASSERT(sizeof(StencilOp) == 16, Sizeof_StencilOp_is_not_16);
4788 COMPILE_ASSERT(offsetof(StencilOp, header) == 0,
4789                OffsetOf_StencilOp_header_not_0);
4790 COMPILE_ASSERT(offsetof(StencilOp, fail) == 4, OffsetOf_StencilOp_fail_not_4);
4791 COMPILE_ASSERT(offsetof(StencilOp, zfail) == 8, OffsetOf_StencilOp_zfail_not_8);
4792 COMPILE_ASSERT(offsetof(StencilOp, zpass) == 12,
4793                OffsetOf_StencilOp_zpass_not_12);
4794
4795 struct StencilOpSeparate {
4796   typedef StencilOpSeparate ValueType;
4797   static const CommandId kCmdId = kStencilOpSeparate;
4798   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4799   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4800
4801   static uint32_t ComputeSize() {
4802     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4803   }
4804
4805   void SetHeader() { header.SetCmd<ValueType>(); }
4806
4807   void Init(GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) {
4808     SetHeader();
4809     face = _face;
4810     fail = _fail;
4811     zfail = _zfail;
4812     zpass = _zpass;
4813   }
4814
4815   void* Set(void* cmd,
4816             GLenum _face,
4817             GLenum _fail,
4818             GLenum _zfail,
4819             GLenum _zpass) {
4820     static_cast<ValueType*>(cmd)->Init(_face, _fail, _zfail, _zpass);
4821     return NextCmdAddress<ValueType>(cmd);
4822   }
4823
4824   gpu::CommandHeader header;
4825   uint32_t face;
4826   uint32_t fail;
4827   uint32_t zfail;
4828   uint32_t zpass;
4829 };
4830
4831 COMPILE_ASSERT(sizeof(StencilOpSeparate) == 20,
4832                Sizeof_StencilOpSeparate_is_not_20);
4833 COMPILE_ASSERT(offsetof(StencilOpSeparate, header) == 0,
4834                OffsetOf_StencilOpSeparate_header_not_0);
4835 COMPILE_ASSERT(offsetof(StencilOpSeparate, face) == 4,
4836                OffsetOf_StencilOpSeparate_face_not_4);
4837 COMPILE_ASSERT(offsetof(StencilOpSeparate, fail) == 8,
4838                OffsetOf_StencilOpSeparate_fail_not_8);
4839 COMPILE_ASSERT(offsetof(StencilOpSeparate, zfail) == 12,
4840                OffsetOf_StencilOpSeparate_zfail_not_12);
4841 COMPILE_ASSERT(offsetof(StencilOpSeparate, zpass) == 16,
4842                OffsetOf_StencilOpSeparate_zpass_not_16);
4843
4844 struct TexImage2D {
4845   typedef TexImage2D ValueType;
4846   static const CommandId kCmdId = kTexImage2D;
4847   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4848   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4849
4850   static uint32_t ComputeSize() {
4851     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4852   }
4853
4854   void SetHeader() { header.SetCmd<ValueType>(); }
4855
4856   void Init(GLenum _target,
4857             GLint _level,
4858             GLint _internalformat,
4859             GLsizei _width,
4860             GLsizei _height,
4861             GLenum _format,
4862             GLenum _type,
4863             uint32_t _pixels_shm_id,
4864             uint32_t _pixels_shm_offset) {
4865     SetHeader();
4866     target = _target;
4867     level = _level;
4868     internalformat = _internalformat;
4869     width = _width;
4870     height = _height;
4871     format = _format;
4872     type = _type;
4873     pixels_shm_id = _pixels_shm_id;
4874     pixels_shm_offset = _pixels_shm_offset;
4875   }
4876
4877   void* Set(void* cmd,
4878             GLenum _target,
4879             GLint _level,
4880             GLint _internalformat,
4881             GLsizei _width,
4882             GLsizei _height,
4883             GLenum _format,
4884             GLenum _type,
4885             uint32_t _pixels_shm_id,
4886             uint32_t _pixels_shm_offset) {
4887     static_cast<ValueType*>(cmd)->Init(_target, _level, _internalformat, _width,
4888                                        _height, _format, _type, _pixels_shm_id,
4889                                        _pixels_shm_offset);
4890     return NextCmdAddress<ValueType>(cmd);
4891   }
4892
4893   gpu::CommandHeader header;
4894   uint32_t target;
4895   int32_t level;
4896   int32_t internalformat;
4897   int32_t width;
4898   int32_t height;
4899   uint32_t format;
4900   uint32_t type;
4901   uint32_t pixels_shm_id;
4902   uint32_t pixels_shm_offset;
4903   static const int32_t border = 0;
4904 };
4905
4906 COMPILE_ASSERT(sizeof(TexImage2D) == 40, Sizeof_TexImage2D_is_not_40);
4907 COMPILE_ASSERT(offsetof(TexImage2D, header) == 0,
4908                OffsetOf_TexImage2D_header_not_0);
4909 COMPILE_ASSERT(offsetof(TexImage2D, target) == 4,
4910                OffsetOf_TexImage2D_target_not_4);
4911 COMPILE_ASSERT(offsetof(TexImage2D, level) == 8,
4912                OffsetOf_TexImage2D_level_not_8);
4913 COMPILE_ASSERT(offsetof(TexImage2D, internalformat) == 12,
4914                OffsetOf_TexImage2D_internalformat_not_12);
4915 COMPILE_ASSERT(offsetof(TexImage2D, width) == 16,
4916                OffsetOf_TexImage2D_width_not_16);
4917 COMPILE_ASSERT(offsetof(TexImage2D, height) == 20,
4918                OffsetOf_TexImage2D_height_not_20);
4919 COMPILE_ASSERT(offsetof(TexImage2D, format) == 24,
4920                OffsetOf_TexImage2D_format_not_24);
4921 COMPILE_ASSERT(offsetof(TexImage2D, type) == 28,
4922                OffsetOf_TexImage2D_type_not_28);
4923 COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 32,
4924                OffsetOf_TexImage2D_pixels_shm_id_not_32);
4925 COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 36,
4926                OffsetOf_TexImage2D_pixels_shm_offset_not_36);
4927
4928 struct TexParameterf {
4929   typedef TexParameterf ValueType;
4930   static const CommandId kCmdId = kTexParameterf;
4931   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
4932   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4933
4934   static uint32_t ComputeSize() {
4935     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
4936   }
4937
4938   void SetHeader() { header.SetCmd<ValueType>(); }
4939
4940   void Init(GLenum _target, GLenum _pname, GLfloat _param) {
4941     SetHeader();
4942     target = _target;
4943     pname = _pname;
4944     param = _param;
4945   }
4946
4947   void* Set(void* cmd, GLenum _target, GLenum _pname, GLfloat _param) {
4948     static_cast<ValueType*>(cmd)->Init(_target, _pname, _param);
4949     return NextCmdAddress<ValueType>(cmd);
4950   }
4951
4952   gpu::CommandHeader header;
4953   uint32_t target;
4954   uint32_t pname;
4955   float param;
4956 };
4957
4958 COMPILE_ASSERT(sizeof(TexParameterf) == 16, Sizeof_TexParameterf_is_not_16);
4959 COMPILE_ASSERT(offsetof(TexParameterf, header) == 0,
4960                OffsetOf_TexParameterf_header_not_0);
4961 COMPILE_ASSERT(offsetof(TexParameterf, target) == 4,
4962                OffsetOf_TexParameterf_target_not_4);
4963 COMPILE_ASSERT(offsetof(TexParameterf, pname) == 8,
4964                OffsetOf_TexParameterf_pname_not_8);
4965 COMPILE_ASSERT(offsetof(TexParameterf, param) == 12,
4966                OffsetOf_TexParameterf_param_not_12);
4967
4968 struct TexParameterfvImmediate {
4969   typedef TexParameterfvImmediate ValueType;
4970   static const CommandId kCmdId = kTexParameterfvImmediate;
4971   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
4972   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
4973
4974   static uint32_t ComputeDataSize() {
4975     return static_cast<uint32_t>(sizeof(GLfloat) * 1);  // NOLINT
4976   }
4977
4978   static uint32_t ComputeSize() {
4979     return static_cast<uint32_t>(sizeof(ValueType) +
4980                                  ComputeDataSize());  // NOLINT
4981   }
4982
4983   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
4984
4985   void Init(GLenum _target, GLenum _pname, const GLfloat* _params) {
4986     SetHeader();
4987     target = _target;
4988     pname = _pname;
4989     memcpy(ImmediateDataAddress(this), _params, ComputeDataSize());
4990   }
4991
4992   void* Set(void* cmd, GLenum _target, GLenum _pname, const GLfloat* _params) {
4993     static_cast<ValueType*>(cmd)->Init(_target, _pname, _params);
4994     const uint32_t size = ComputeSize();
4995     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
4996   }
4997
4998   gpu::CommandHeader header;
4999   uint32_t target;
5000   uint32_t pname;
5001 };
5002
5003 COMPILE_ASSERT(sizeof(TexParameterfvImmediate) == 12,
5004                Sizeof_TexParameterfvImmediate_is_not_12);
5005 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, header) == 0,
5006                OffsetOf_TexParameterfvImmediate_header_not_0);
5007 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, target) == 4,
5008                OffsetOf_TexParameterfvImmediate_target_not_4);
5009 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, pname) == 8,
5010                OffsetOf_TexParameterfvImmediate_pname_not_8);
5011
5012 struct TexParameteri {
5013   typedef TexParameteri ValueType;
5014   static const CommandId kCmdId = kTexParameteri;
5015   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5016   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5017
5018   static uint32_t ComputeSize() {
5019     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5020   }
5021
5022   void SetHeader() { header.SetCmd<ValueType>(); }
5023
5024   void Init(GLenum _target, GLenum _pname, GLint _param) {
5025     SetHeader();
5026     target = _target;
5027     pname = _pname;
5028     param = _param;
5029   }
5030
5031   void* Set(void* cmd, GLenum _target, GLenum _pname, GLint _param) {
5032     static_cast<ValueType*>(cmd)->Init(_target, _pname, _param);
5033     return NextCmdAddress<ValueType>(cmd);
5034   }
5035
5036   gpu::CommandHeader header;
5037   uint32_t target;
5038   uint32_t pname;
5039   int32_t param;
5040 };
5041
5042 COMPILE_ASSERT(sizeof(TexParameteri) == 16, Sizeof_TexParameteri_is_not_16);
5043 COMPILE_ASSERT(offsetof(TexParameteri, header) == 0,
5044                OffsetOf_TexParameteri_header_not_0);
5045 COMPILE_ASSERT(offsetof(TexParameteri, target) == 4,
5046                OffsetOf_TexParameteri_target_not_4);
5047 COMPILE_ASSERT(offsetof(TexParameteri, pname) == 8,
5048                OffsetOf_TexParameteri_pname_not_8);
5049 COMPILE_ASSERT(offsetof(TexParameteri, param) == 12,
5050                OffsetOf_TexParameteri_param_not_12);
5051
5052 struct TexParameterivImmediate {
5053   typedef TexParameterivImmediate ValueType;
5054   static const CommandId kCmdId = kTexParameterivImmediate;
5055   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5056   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5057
5058   static uint32_t ComputeDataSize() {
5059     return static_cast<uint32_t>(sizeof(GLint) * 1);  // NOLINT
5060   }
5061
5062   static uint32_t ComputeSize() {
5063     return static_cast<uint32_t>(sizeof(ValueType) +
5064                                  ComputeDataSize());  // NOLINT
5065   }
5066
5067   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
5068
5069   void Init(GLenum _target, GLenum _pname, const GLint* _params) {
5070     SetHeader();
5071     target = _target;
5072     pname = _pname;
5073     memcpy(ImmediateDataAddress(this), _params, ComputeDataSize());
5074   }
5075
5076   void* Set(void* cmd, GLenum _target, GLenum _pname, const GLint* _params) {
5077     static_cast<ValueType*>(cmd)->Init(_target, _pname, _params);
5078     const uint32_t size = ComputeSize();
5079     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5080   }
5081
5082   gpu::CommandHeader header;
5083   uint32_t target;
5084   uint32_t pname;
5085 };
5086
5087 COMPILE_ASSERT(sizeof(TexParameterivImmediate) == 12,
5088                Sizeof_TexParameterivImmediate_is_not_12);
5089 COMPILE_ASSERT(offsetof(TexParameterivImmediate, header) == 0,
5090                OffsetOf_TexParameterivImmediate_header_not_0);
5091 COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4,
5092                OffsetOf_TexParameterivImmediate_target_not_4);
5093 COMPILE_ASSERT(offsetof(TexParameterivImmediate, pname) == 8,
5094                OffsetOf_TexParameterivImmediate_pname_not_8);
5095
5096 struct TexSubImage2D {
5097   typedef TexSubImage2D ValueType;
5098   static const CommandId kCmdId = kTexSubImage2D;
5099   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5100   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5101
5102   static uint32_t ComputeSize() {
5103     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5104   }
5105
5106   void SetHeader() { header.SetCmd<ValueType>(); }
5107
5108   void Init(GLenum _target,
5109             GLint _level,
5110             GLint _xoffset,
5111             GLint _yoffset,
5112             GLsizei _width,
5113             GLsizei _height,
5114             GLenum _format,
5115             GLenum _type,
5116             uint32_t _pixels_shm_id,
5117             uint32_t _pixels_shm_offset,
5118             GLboolean _internal) {
5119     SetHeader();
5120     target = _target;
5121     level = _level;
5122     xoffset = _xoffset;
5123     yoffset = _yoffset;
5124     width = _width;
5125     height = _height;
5126     format = _format;
5127     type = _type;
5128     pixels_shm_id = _pixels_shm_id;
5129     pixels_shm_offset = _pixels_shm_offset;
5130     internal = _internal;
5131   }
5132
5133   void* Set(void* cmd,
5134             GLenum _target,
5135             GLint _level,
5136             GLint _xoffset,
5137             GLint _yoffset,
5138             GLsizei _width,
5139             GLsizei _height,
5140             GLenum _format,
5141             GLenum _type,
5142             uint32_t _pixels_shm_id,
5143             uint32_t _pixels_shm_offset,
5144             GLboolean _internal) {
5145     static_cast<ValueType*>(cmd)
5146         ->Init(_target, _level, _xoffset, _yoffset, _width, _height, _format,
5147                _type, _pixels_shm_id, _pixels_shm_offset, _internal);
5148     return NextCmdAddress<ValueType>(cmd);
5149   }
5150
5151   gpu::CommandHeader header;
5152   uint32_t target;
5153   int32_t level;
5154   int32_t xoffset;
5155   int32_t yoffset;
5156   int32_t width;
5157   int32_t height;
5158   uint32_t format;
5159   uint32_t type;
5160   uint32_t pixels_shm_id;
5161   uint32_t pixels_shm_offset;
5162   uint32_t internal;
5163 };
5164
5165 COMPILE_ASSERT(sizeof(TexSubImage2D) == 48, Sizeof_TexSubImage2D_is_not_48);
5166 COMPILE_ASSERT(offsetof(TexSubImage2D, header) == 0,
5167                OffsetOf_TexSubImage2D_header_not_0);
5168 COMPILE_ASSERT(offsetof(TexSubImage2D, target) == 4,
5169                OffsetOf_TexSubImage2D_target_not_4);
5170 COMPILE_ASSERT(offsetof(TexSubImage2D, level) == 8,
5171                OffsetOf_TexSubImage2D_level_not_8);
5172 COMPILE_ASSERT(offsetof(TexSubImage2D, xoffset) == 12,
5173                OffsetOf_TexSubImage2D_xoffset_not_12);
5174 COMPILE_ASSERT(offsetof(TexSubImage2D, yoffset) == 16,
5175                OffsetOf_TexSubImage2D_yoffset_not_16);
5176 COMPILE_ASSERT(offsetof(TexSubImage2D, width) == 20,
5177                OffsetOf_TexSubImage2D_width_not_20);
5178 COMPILE_ASSERT(offsetof(TexSubImage2D, height) == 24,
5179                OffsetOf_TexSubImage2D_height_not_24);
5180 COMPILE_ASSERT(offsetof(TexSubImage2D, format) == 28,
5181                OffsetOf_TexSubImage2D_format_not_28);
5182 COMPILE_ASSERT(offsetof(TexSubImage2D, type) == 32,
5183                OffsetOf_TexSubImage2D_type_not_32);
5184 COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_id) == 36,
5185                OffsetOf_TexSubImage2D_pixels_shm_id_not_36);
5186 COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_offset) == 40,
5187                OffsetOf_TexSubImage2D_pixels_shm_offset_not_40);
5188 COMPILE_ASSERT(offsetof(TexSubImage2D, internal) == 44,
5189                OffsetOf_TexSubImage2D_internal_not_44);
5190
5191 struct Uniform1f {
5192   typedef Uniform1f ValueType;
5193   static const CommandId kCmdId = kUniform1f;
5194   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5195   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5196
5197   static uint32_t ComputeSize() {
5198     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5199   }
5200
5201   void SetHeader() { header.SetCmd<ValueType>(); }
5202
5203   void Init(GLint _location, GLfloat _x) {
5204     SetHeader();
5205     location = _location;
5206     x = _x;
5207   }
5208
5209   void* Set(void* cmd, GLint _location, GLfloat _x) {
5210     static_cast<ValueType*>(cmd)->Init(_location, _x);
5211     return NextCmdAddress<ValueType>(cmd);
5212   }
5213
5214   gpu::CommandHeader header;
5215   int32_t location;
5216   float x;
5217 };
5218
5219 COMPILE_ASSERT(sizeof(Uniform1f) == 12, Sizeof_Uniform1f_is_not_12);
5220 COMPILE_ASSERT(offsetof(Uniform1f, header) == 0,
5221                OffsetOf_Uniform1f_header_not_0);
5222 COMPILE_ASSERT(offsetof(Uniform1f, location) == 4,
5223                OffsetOf_Uniform1f_location_not_4);
5224 COMPILE_ASSERT(offsetof(Uniform1f, x) == 8, OffsetOf_Uniform1f_x_not_8);
5225
5226 struct Uniform1fvImmediate {
5227   typedef Uniform1fvImmediate ValueType;
5228   static const CommandId kCmdId = kUniform1fvImmediate;
5229   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5230   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5231
5232   static uint32_t ComputeDataSize(GLsizei count) {
5233     return static_cast<uint32_t>(sizeof(GLfloat) * 1 * count);  // NOLINT
5234   }
5235
5236   static uint32_t ComputeSize(GLsizei count) {
5237     return static_cast<uint32_t>(sizeof(ValueType) +
5238                                  ComputeDataSize(count));  // NOLINT
5239   }
5240
5241   void SetHeader(GLsizei count) {
5242     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5243   }
5244
5245   void Init(GLint _location, GLsizei _count, const GLfloat* _v) {
5246     SetHeader(_count);
5247     location = _location;
5248     count = _count;
5249     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5250   }
5251
5252   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
5253     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5254     const uint32_t size = ComputeSize(_count);
5255     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5256   }
5257
5258   gpu::CommandHeader header;
5259   int32_t location;
5260   int32_t count;
5261 };
5262
5263 COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12,
5264                Sizeof_Uniform1fvImmediate_is_not_12);
5265 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, header) == 0,
5266                OffsetOf_Uniform1fvImmediate_header_not_0);
5267 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, location) == 4,
5268                OffsetOf_Uniform1fvImmediate_location_not_4);
5269 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, count) == 8,
5270                OffsetOf_Uniform1fvImmediate_count_not_8);
5271
5272 struct Uniform1i {
5273   typedef Uniform1i ValueType;
5274   static const CommandId kCmdId = kUniform1i;
5275   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5276   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5277
5278   static uint32_t ComputeSize() {
5279     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5280   }
5281
5282   void SetHeader() { header.SetCmd<ValueType>(); }
5283
5284   void Init(GLint _location, GLint _x) {
5285     SetHeader();
5286     location = _location;
5287     x = _x;
5288   }
5289
5290   void* Set(void* cmd, GLint _location, GLint _x) {
5291     static_cast<ValueType*>(cmd)->Init(_location, _x);
5292     return NextCmdAddress<ValueType>(cmd);
5293   }
5294
5295   gpu::CommandHeader header;
5296   int32_t location;
5297   int32_t x;
5298 };
5299
5300 COMPILE_ASSERT(sizeof(Uniform1i) == 12, Sizeof_Uniform1i_is_not_12);
5301 COMPILE_ASSERT(offsetof(Uniform1i, header) == 0,
5302                OffsetOf_Uniform1i_header_not_0);
5303 COMPILE_ASSERT(offsetof(Uniform1i, location) == 4,
5304                OffsetOf_Uniform1i_location_not_4);
5305 COMPILE_ASSERT(offsetof(Uniform1i, x) == 8, OffsetOf_Uniform1i_x_not_8);
5306
5307 struct Uniform1ivImmediate {
5308   typedef Uniform1ivImmediate ValueType;
5309   static const CommandId kCmdId = kUniform1ivImmediate;
5310   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5311   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5312
5313   static uint32_t ComputeDataSize(GLsizei count) {
5314     return static_cast<uint32_t>(sizeof(GLint) * 1 * count);  // NOLINT
5315   }
5316
5317   static uint32_t ComputeSize(GLsizei count) {
5318     return static_cast<uint32_t>(sizeof(ValueType) +
5319                                  ComputeDataSize(count));  // NOLINT
5320   }
5321
5322   void SetHeader(GLsizei count) {
5323     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5324   }
5325
5326   void Init(GLint _location, GLsizei _count, const GLint* _v) {
5327     SetHeader(_count);
5328     location = _location;
5329     count = _count;
5330     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5331   }
5332
5333   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
5334     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5335     const uint32_t size = ComputeSize(_count);
5336     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5337   }
5338
5339   gpu::CommandHeader header;
5340   int32_t location;
5341   int32_t count;
5342 };
5343
5344 COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12,
5345                Sizeof_Uniform1ivImmediate_is_not_12);
5346 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, header) == 0,
5347                OffsetOf_Uniform1ivImmediate_header_not_0);
5348 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4,
5349                OffsetOf_Uniform1ivImmediate_location_not_4);
5350 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8,
5351                OffsetOf_Uniform1ivImmediate_count_not_8);
5352
5353 struct Uniform2f {
5354   typedef Uniform2f ValueType;
5355   static const CommandId kCmdId = kUniform2f;
5356   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5357   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5358
5359   static uint32_t ComputeSize() {
5360     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5361   }
5362
5363   void SetHeader() { header.SetCmd<ValueType>(); }
5364
5365   void Init(GLint _location, GLfloat _x, GLfloat _y) {
5366     SetHeader();
5367     location = _location;
5368     x = _x;
5369     y = _y;
5370   }
5371
5372   void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y) {
5373     static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
5374     return NextCmdAddress<ValueType>(cmd);
5375   }
5376
5377   gpu::CommandHeader header;
5378   int32_t location;
5379   float x;
5380   float y;
5381 };
5382
5383 COMPILE_ASSERT(sizeof(Uniform2f) == 16, Sizeof_Uniform2f_is_not_16);
5384 COMPILE_ASSERT(offsetof(Uniform2f, header) == 0,
5385                OffsetOf_Uniform2f_header_not_0);
5386 COMPILE_ASSERT(offsetof(Uniform2f, location) == 4,
5387                OffsetOf_Uniform2f_location_not_4);
5388 COMPILE_ASSERT(offsetof(Uniform2f, x) == 8, OffsetOf_Uniform2f_x_not_8);
5389 COMPILE_ASSERT(offsetof(Uniform2f, y) == 12, OffsetOf_Uniform2f_y_not_12);
5390
5391 struct Uniform2fvImmediate {
5392   typedef Uniform2fvImmediate ValueType;
5393   static const CommandId kCmdId = kUniform2fvImmediate;
5394   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5395   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5396
5397   static uint32_t ComputeDataSize(GLsizei count) {
5398     return static_cast<uint32_t>(sizeof(GLfloat) * 2 * count);  // NOLINT
5399   }
5400
5401   static uint32_t ComputeSize(GLsizei count) {
5402     return static_cast<uint32_t>(sizeof(ValueType) +
5403                                  ComputeDataSize(count));  // NOLINT
5404   }
5405
5406   void SetHeader(GLsizei count) {
5407     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5408   }
5409
5410   void Init(GLint _location, GLsizei _count, const GLfloat* _v) {
5411     SetHeader(_count);
5412     location = _location;
5413     count = _count;
5414     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5415   }
5416
5417   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
5418     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5419     const uint32_t size = ComputeSize(_count);
5420     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5421   }
5422
5423   gpu::CommandHeader header;
5424   int32_t location;
5425   int32_t count;
5426 };
5427
5428 COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12,
5429                Sizeof_Uniform2fvImmediate_is_not_12);
5430 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, header) == 0,
5431                OffsetOf_Uniform2fvImmediate_header_not_0);
5432 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, location) == 4,
5433                OffsetOf_Uniform2fvImmediate_location_not_4);
5434 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, count) == 8,
5435                OffsetOf_Uniform2fvImmediate_count_not_8);
5436
5437 struct Uniform2i {
5438   typedef Uniform2i ValueType;
5439   static const CommandId kCmdId = kUniform2i;
5440   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5441   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5442
5443   static uint32_t ComputeSize() {
5444     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5445   }
5446
5447   void SetHeader() { header.SetCmd<ValueType>(); }
5448
5449   void Init(GLint _location, GLint _x, GLint _y) {
5450     SetHeader();
5451     location = _location;
5452     x = _x;
5453     y = _y;
5454   }
5455
5456   void* Set(void* cmd, GLint _location, GLint _x, GLint _y) {
5457     static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
5458     return NextCmdAddress<ValueType>(cmd);
5459   }
5460
5461   gpu::CommandHeader header;
5462   int32_t location;
5463   int32_t x;
5464   int32_t y;
5465 };
5466
5467 COMPILE_ASSERT(sizeof(Uniform2i) == 16, Sizeof_Uniform2i_is_not_16);
5468 COMPILE_ASSERT(offsetof(Uniform2i, header) == 0,
5469                OffsetOf_Uniform2i_header_not_0);
5470 COMPILE_ASSERT(offsetof(Uniform2i, location) == 4,
5471                OffsetOf_Uniform2i_location_not_4);
5472 COMPILE_ASSERT(offsetof(Uniform2i, x) == 8, OffsetOf_Uniform2i_x_not_8);
5473 COMPILE_ASSERT(offsetof(Uniform2i, y) == 12, OffsetOf_Uniform2i_y_not_12);
5474
5475 struct Uniform2ivImmediate {
5476   typedef Uniform2ivImmediate ValueType;
5477   static const CommandId kCmdId = kUniform2ivImmediate;
5478   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5479   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5480
5481   static uint32_t ComputeDataSize(GLsizei count) {
5482     return static_cast<uint32_t>(sizeof(GLint) * 2 * count);  // NOLINT
5483   }
5484
5485   static uint32_t ComputeSize(GLsizei count) {
5486     return static_cast<uint32_t>(sizeof(ValueType) +
5487                                  ComputeDataSize(count));  // NOLINT
5488   }
5489
5490   void SetHeader(GLsizei count) {
5491     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5492   }
5493
5494   void Init(GLint _location, GLsizei _count, const GLint* _v) {
5495     SetHeader(_count);
5496     location = _location;
5497     count = _count;
5498     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5499   }
5500
5501   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
5502     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5503     const uint32_t size = ComputeSize(_count);
5504     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5505   }
5506
5507   gpu::CommandHeader header;
5508   int32_t location;
5509   int32_t count;
5510 };
5511
5512 COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12,
5513                Sizeof_Uniform2ivImmediate_is_not_12);
5514 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, header) == 0,
5515                OffsetOf_Uniform2ivImmediate_header_not_0);
5516 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4,
5517                OffsetOf_Uniform2ivImmediate_location_not_4);
5518 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8,
5519                OffsetOf_Uniform2ivImmediate_count_not_8);
5520
5521 struct Uniform3f {
5522   typedef Uniform3f ValueType;
5523   static const CommandId kCmdId = kUniform3f;
5524   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5525   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5526
5527   static uint32_t ComputeSize() {
5528     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5529   }
5530
5531   void SetHeader() { header.SetCmd<ValueType>(); }
5532
5533   void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) {
5534     SetHeader();
5535     location = _location;
5536     x = _x;
5537     y = _y;
5538     z = _z;
5539   }
5540
5541   void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) {
5542     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
5543     return NextCmdAddress<ValueType>(cmd);
5544   }
5545
5546   gpu::CommandHeader header;
5547   int32_t location;
5548   float x;
5549   float y;
5550   float z;
5551 };
5552
5553 COMPILE_ASSERT(sizeof(Uniform3f) == 20, Sizeof_Uniform3f_is_not_20);
5554 COMPILE_ASSERT(offsetof(Uniform3f, header) == 0,
5555                OffsetOf_Uniform3f_header_not_0);
5556 COMPILE_ASSERT(offsetof(Uniform3f, location) == 4,
5557                OffsetOf_Uniform3f_location_not_4);
5558 COMPILE_ASSERT(offsetof(Uniform3f, x) == 8, OffsetOf_Uniform3f_x_not_8);
5559 COMPILE_ASSERT(offsetof(Uniform3f, y) == 12, OffsetOf_Uniform3f_y_not_12);
5560 COMPILE_ASSERT(offsetof(Uniform3f, z) == 16, OffsetOf_Uniform3f_z_not_16);
5561
5562 struct Uniform3fvImmediate {
5563   typedef Uniform3fvImmediate ValueType;
5564   static const CommandId kCmdId = kUniform3fvImmediate;
5565   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5566   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5567
5568   static uint32_t ComputeDataSize(GLsizei count) {
5569     return static_cast<uint32_t>(sizeof(GLfloat) * 3 * count);  // NOLINT
5570   }
5571
5572   static uint32_t ComputeSize(GLsizei count) {
5573     return static_cast<uint32_t>(sizeof(ValueType) +
5574                                  ComputeDataSize(count));  // NOLINT
5575   }
5576
5577   void SetHeader(GLsizei count) {
5578     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5579   }
5580
5581   void Init(GLint _location, GLsizei _count, const GLfloat* _v) {
5582     SetHeader(_count);
5583     location = _location;
5584     count = _count;
5585     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5586   }
5587
5588   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
5589     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5590     const uint32_t size = ComputeSize(_count);
5591     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5592   }
5593
5594   gpu::CommandHeader header;
5595   int32_t location;
5596   int32_t count;
5597 };
5598
5599 COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12,
5600                Sizeof_Uniform3fvImmediate_is_not_12);
5601 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, header) == 0,
5602                OffsetOf_Uniform3fvImmediate_header_not_0);
5603 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, location) == 4,
5604                OffsetOf_Uniform3fvImmediate_location_not_4);
5605 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, count) == 8,
5606                OffsetOf_Uniform3fvImmediate_count_not_8);
5607
5608 struct Uniform3i {
5609   typedef Uniform3i ValueType;
5610   static const CommandId kCmdId = kUniform3i;
5611   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5612   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5613
5614   static uint32_t ComputeSize() {
5615     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5616   }
5617
5618   void SetHeader() { header.SetCmd<ValueType>(); }
5619
5620   void Init(GLint _location, GLint _x, GLint _y, GLint _z) {
5621     SetHeader();
5622     location = _location;
5623     x = _x;
5624     y = _y;
5625     z = _z;
5626   }
5627
5628   void* Set(void* cmd, GLint _location, GLint _x, GLint _y, GLint _z) {
5629     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
5630     return NextCmdAddress<ValueType>(cmd);
5631   }
5632
5633   gpu::CommandHeader header;
5634   int32_t location;
5635   int32_t x;
5636   int32_t y;
5637   int32_t z;
5638 };
5639
5640 COMPILE_ASSERT(sizeof(Uniform3i) == 20, Sizeof_Uniform3i_is_not_20);
5641 COMPILE_ASSERT(offsetof(Uniform3i, header) == 0,
5642                OffsetOf_Uniform3i_header_not_0);
5643 COMPILE_ASSERT(offsetof(Uniform3i, location) == 4,
5644                OffsetOf_Uniform3i_location_not_4);
5645 COMPILE_ASSERT(offsetof(Uniform3i, x) == 8, OffsetOf_Uniform3i_x_not_8);
5646 COMPILE_ASSERT(offsetof(Uniform3i, y) == 12, OffsetOf_Uniform3i_y_not_12);
5647 COMPILE_ASSERT(offsetof(Uniform3i, z) == 16, OffsetOf_Uniform3i_z_not_16);
5648
5649 struct Uniform3ivImmediate {
5650   typedef Uniform3ivImmediate ValueType;
5651   static const CommandId kCmdId = kUniform3ivImmediate;
5652   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5653   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5654
5655   static uint32_t ComputeDataSize(GLsizei count) {
5656     return static_cast<uint32_t>(sizeof(GLint) * 3 * count);  // NOLINT
5657   }
5658
5659   static uint32_t ComputeSize(GLsizei count) {
5660     return static_cast<uint32_t>(sizeof(ValueType) +
5661                                  ComputeDataSize(count));  // NOLINT
5662   }
5663
5664   void SetHeader(GLsizei count) {
5665     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5666   }
5667
5668   void Init(GLint _location, GLsizei _count, const GLint* _v) {
5669     SetHeader(_count);
5670     location = _location;
5671     count = _count;
5672     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5673   }
5674
5675   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
5676     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5677     const uint32_t size = ComputeSize(_count);
5678     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5679   }
5680
5681   gpu::CommandHeader header;
5682   int32_t location;
5683   int32_t count;
5684 };
5685
5686 COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12,
5687                Sizeof_Uniform3ivImmediate_is_not_12);
5688 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, header) == 0,
5689                OffsetOf_Uniform3ivImmediate_header_not_0);
5690 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4,
5691                OffsetOf_Uniform3ivImmediate_location_not_4);
5692 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8,
5693                OffsetOf_Uniform3ivImmediate_count_not_8);
5694
5695 struct Uniform4f {
5696   typedef Uniform4f ValueType;
5697   static const CommandId kCmdId = kUniform4f;
5698   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5699   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5700
5701   static uint32_t ComputeSize() {
5702     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5703   }
5704
5705   void SetHeader() { header.SetCmd<ValueType>(); }
5706
5707   void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
5708     SetHeader();
5709     location = _location;
5710     x = _x;
5711     y = _y;
5712     z = _z;
5713     w = _w;
5714   }
5715
5716   void* Set(void* cmd,
5717             GLint _location,
5718             GLfloat _x,
5719             GLfloat _y,
5720             GLfloat _z,
5721             GLfloat _w) {
5722     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
5723     return NextCmdAddress<ValueType>(cmd);
5724   }
5725
5726   gpu::CommandHeader header;
5727   int32_t location;
5728   float x;
5729   float y;
5730   float z;
5731   float w;
5732 };
5733
5734 COMPILE_ASSERT(sizeof(Uniform4f) == 24, Sizeof_Uniform4f_is_not_24);
5735 COMPILE_ASSERT(offsetof(Uniform4f, header) == 0,
5736                OffsetOf_Uniform4f_header_not_0);
5737 COMPILE_ASSERT(offsetof(Uniform4f, location) == 4,
5738                OffsetOf_Uniform4f_location_not_4);
5739 COMPILE_ASSERT(offsetof(Uniform4f, x) == 8, OffsetOf_Uniform4f_x_not_8);
5740 COMPILE_ASSERT(offsetof(Uniform4f, y) == 12, OffsetOf_Uniform4f_y_not_12);
5741 COMPILE_ASSERT(offsetof(Uniform4f, z) == 16, OffsetOf_Uniform4f_z_not_16);
5742 COMPILE_ASSERT(offsetof(Uniform4f, w) == 20, OffsetOf_Uniform4f_w_not_20);
5743
5744 struct Uniform4fvImmediate {
5745   typedef Uniform4fvImmediate ValueType;
5746   static const CommandId kCmdId = kUniform4fvImmediate;
5747   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5748   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5749
5750   static uint32_t ComputeDataSize(GLsizei count) {
5751     return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count);  // NOLINT
5752   }
5753
5754   static uint32_t ComputeSize(GLsizei count) {
5755     return static_cast<uint32_t>(sizeof(ValueType) +
5756                                  ComputeDataSize(count));  // NOLINT
5757   }
5758
5759   void SetHeader(GLsizei count) {
5760     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5761   }
5762
5763   void Init(GLint _location, GLsizei _count, const GLfloat* _v) {
5764     SetHeader(_count);
5765     location = _location;
5766     count = _count;
5767     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5768   }
5769
5770   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
5771     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5772     const uint32_t size = ComputeSize(_count);
5773     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5774   }
5775
5776   gpu::CommandHeader header;
5777   int32_t location;
5778   int32_t count;
5779 };
5780
5781 COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12,
5782                Sizeof_Uniform4fvImmediate_is_not_12);
5783 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, header) == 0,
5784                OffsetOf_Uniform4fvImmediate_header_not_0);
5785 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, location) == 4,
5786                OffsetOf_Uniform4fvImmediate_location_not_4);
5787 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, count) == 8,
5788                OffsetOf_Uniform4fvImmediate_count_not_8);
5789
5790 struct Uniform4i {
5791   typedef Uniform4i ValueType;
5792   static const CommandId kCmdId = kUniform4i;
5793   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
5794   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5795
5796   static uint32_t ComputeSize() {
5797     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
5798   }
5799
5800   void SetHeader() { header.SetCmd<ValueType>(); }
5801
5802   void Init(GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) {
5803     SetHeader();
5804     location = _location;
5805     x = _x;
5806     y = _y;
5807     z = _z;
5808     w = _w;
5809   }
5810
5811   void* Set(void* cmd,
5812             GLint _location,
5813             GLint _x,
5814             GLint _y,
5815             GLint _z,
5816             GLint _w) {
5817     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
5818     return NextCmdAddress<ValueType>(cmd);
5819   }
5820
5821   gpu::CommandHeader header;
5822   int32_t location;
5823   int32_t x;
5824   int32_t y;
5825   int32_t z;
5826   int32_t w;
5827 };
5828
5829 COMPILE_ASSERT(sizeof(Uniform4i) == 24, Sizeof_Uniform4i_is_not_24);
5830 COMPILE_ASSERT(offsetof(Uniform4i, header) == 0,
5831                OffsetOf_Uniform4i_header_not_0);
5832 COMPILE_ASSERT(offsetof(Uniform4i, location) == 4,
5833                OffsetOf_Uniform4i_location_not_4);
5834 COMPILE_ASSERT(offsetof(Uniform4i, x) == 8, OffsetOf_Uniform4i_x_not_8);
5835 COMPILE_ASSERT(offsetof(Uniform4i, y) == 12, OffsetOf_Uniform4i_y_not_12);
5836 COMPILE_ASSERT(offsetof(Uniform4i, z) == 16, OffsetOf_Uniform4i_z_not_16);
5837 COMPILE_ASSERT(offsetof(Uniform4i, w) == 20, OffsetOf_Uniform4i_w_not_20);
5838
5839 struct Uniform4ivImmediate {
5840   typedef Uniform4ivImmediate ValueType;
5841   static const CommandId kCmdId = kUniform4ivImmediate;
5842   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5843   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5844
5845   static uint32_t ComputeDataSize(GLsizei count) {
5846     return static_cast<uint32_t>(sizeof(GLint) * 4 * count);  // NOLINT
5847   }
5848
5849   static uint32_t ComputeSize(GLsizei count) {
5850     return static_cast<uint32_t>(sizeof(ValueType) +
5851                                  ComputeDataSize(count));  // NOLINT
5852   }
5853
5854   void SetHeader(GLsizei count) {
5855     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5856   }
5857
5858   void Init(GLint _location, GLsizei _count, const GLint* _v) {
5859     SetHeader(_count);
5860     location = _location;
5861     count = _count;
5862     memcpy(ImmediateDataAddress(this), _v, ComputeDataSize(_count));
5863   }
5864
5865   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
5866     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
5867     const uint32_t size = ComputeSize(_count);
5868     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5869   }
5870
5871   gpu::CommandHeader header;
5872   int32_t location;
5873   int32_t count;
5874 };
5875
5876 COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12,
5877                Sizeof_Uniform4ivImmediate_is_not_12);
5878 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, header) == 0,
5879                OffsetOf_Uniform4ivImmediate_header_not_0);
5880 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4,
5881                OffsetOf_Uniform4ivImmediate_location_not_4);
5882 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8,
5883                OffsetOf_Uniform4ivImmediate_count_not_8);
5884
5885 struct UniformMatrix2fvImmediate {
5886   typedef UniformMatrix2fvImmediate ValueType;
5887   static const CommandId kCmdId = kUniformMatrix2fvImmediate;
5888   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5889   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5890
5891   static uint32_t ComputeDataSize(GLsizei count) {
5892     return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count);  // NOLINT
5893   }
5894
5895   static uint32_t ComputeSize(GLsizei count) {
5896     return static_cast<uint32_t>(sizeof(ValueType) +
5897                                  ComputeDataSize(count));  // NOLINT
5898   }
5899
5900   void SetHeader(GLsizei count) {
5901     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5902   }
5903
5904   void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
5905     SetHeader(_count);
5906     location = _location;
5907     count = _count;
5908     memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
5909   }
5910
5911   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
5912     static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
5913     const uint32_t size = ComputeSize(_count);
5914     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5915   }
5916
5917   gpu::CommandHeader header;
5918   int32_t location;
5919   int32_t count;
5920   static const uint32_t transpose = false;
5921 };
5922
5923 COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 12,
5924                Sizeof_UniformMatrix2fvImmediate_is_not_12);
5925 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0,
5926                OffsetOf_UniformMatrix2fvImmediate_header_not_0);
5927 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
5928                OffsetOf_UniformMatrix2fvImmediate_location_not_4);
5929 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8,
5930                OffsetOf_UniformMatrix2fvImmediate_count_not_8);
5931
5932 struct UniformMatrix3fvImmediate {
5933   typedef UniformMatrix3fvImmediate ValueType;
5934   static const CommandId kCmdId = kUniformMatrix3fvImmediate;
5935   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5936   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5937
5938   static uint32_t ComputeDataSize(GLsizei count) {
5939     return static_cast<uint32_t>(sizeof(GLfloat) * 9 * count);  // NOLINT
5940   }
5941
5942   static uint32_t ComputeSize(GLsizei count) {
5943     return static_cast<uint32_t>(sizeof(ValueType) +
5944                                  ComputeDataSize(count));  // NOLINT
5945   }
5946
5947   void SetHeader(GLsizei count) {
5948     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5949   }
5950
5951   void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
5952     SetHeader(_count);
5953     location = _location;
5954     count = _count;
5955     memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
5956   }
5957
5958   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
5959     static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
5960     const uint32_t size = ComputeSize(_count);
5961     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
5962   }
5963
5964   gpu::CommandHeader header;
5965   int32_t location;
5966   int32_t count;
5967   static const uint32_t transpose = false;
5968 };
5969
5970 COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 12,
5971                Sizeof_UniformMatrix3fvImmediate_is_not_12);
5972 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0,
5973                OffsetOf_UniformMatrix3fvImmediate_header_not_0);
5974 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
5975                OffsetOf_UniformMatrix3fvImmediate_location_not_4);
5976 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8,
5977                OffsetOf_UniformMatrix3fvImmediate_count_not_8);
5978
5979 struct UniformMatrix4fvImmediate {
5980   typedef UniformMatrix4fvImmediate ValueType;
5981   static const CommandId kCmdId = kUniformMatrix4fvImmediate;
5982   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
5983   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
5984
5985   static uint32_t ComputeDataSize(GLsizei count) {
5986     return static_cast<uint32_t>(sizeof(GLfloat) * 16 * count);  // NOLINT
5987   }
5988
5989   static uint32_t ComputeSize(GLsizei count) {
5990     return static_cast<uint32_t>(sizeof(ValueType) +
5991                                  ComputeDataSize(count));  // NOLINT
5992   }
5993
5994   void SetHeader(GLsizei count) {
5995     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
5996   }
5997
5998   void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
5999     SetHeader(_count);
6000     location = _location;
6001     count = _count;
6002     memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
6003   }
6004
6005   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
6006     static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
6007     const uint32_t size = ComputeSize(_count);
6008     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6009   }
6010
6011   gpu::CommandHeader header;
6012   int32_t location;
6013   int32_t count;
6014   static const uint32_t transpose = false;
6015 };
6016
6017 COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 12,
6018                Sizeof_UniformMatrix4fvImmediate_is_not_12);
6019 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0,
6020                OffsetOf_UniformMatrix4fvImmediate_header_not_0);
6021 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4,
6022                OffsetOf_UniformMatrix4fvImmediate_location_not_4);
6023 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8,
6024                OffsetOf_UniformMatrix4fvImmediate_count_not_8);
6025
6026 struct UseProgram {
6027   typedef UseProgram ValueType;
6028   static const CommandId kCmdId = kUseProgram;
6029   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6030   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6031
6032   static uint32_t ComputeSize() {
6033     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6034   }
6035
6036   void SetHeader() { header.SetCmd<ValueType>(); }
6037
6038   void Init(GLuint _program) {
6039     SetHeader();
6040     program = _program;
6041   }
6042
6043   void* Set(void* cmd, GLuint _program) {
6044     static_cast<ValueType*>(cmd)->Init(_program);
6045     return NextCmdAddress<ValueType>(cmd);
6046   }
6047
6048   gpu::CommandHeader header;
6049   uint32_t program;
6050 };
6051
6052 COMPILE_ASSERT(sizeof(UseProgram) == 8, Sizeof_UseProgram_is_not_8);
6053 COMPILE_ASSERT(offsetof(UseProgram, header) == 0,
6054                OffsetOf_UseProgram_header_not_0);
6055 COMPILE_ASSERT(offsetof(UseProgram, program) == 4,
6056                OffsetOf_UseProgram_program_not_4);
6057
6058 struct ValidateProgram {
6059   typedef ValidateProgram ValueType;
6060   static const CommandId kCmdId = kValidateProgram;
6061   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6062   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6063
6064   static uint32_t ComputeSize() {
6065     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6066   }
6067
6068   void SetHeader() { header.SetCmd<ValueType>(); }
6069
6070   void Init(GLuint _program) {
6071     SetHeader();
6072     program = _program;
6073   }
6074
6075   void* Set(void* cmd, GLuint _program) {
6076     static_cast<ValueType*>(cmd)->Init(_program);
6077     return NextCmdAddress<ValueType>(cmd);
6078   }
6079
6080   gpu::CommandHeader header;
6081   uint32_t program;
6082 };
6083
6084 COMPILE_ASSERT(sizeof(ValidateProgram) == 8, Sizeof_ValidateProgram_is_not_8);
6085 COMPILE_ASSERT(offsetof(ValidateProgram, header) == 0,
6086                OffsetOf_ValidateProgram_header_not_0);
6087 COMPILE_ASSERT(offsetof(ValidateProgram, program) == 4,
6088                OffsetOf_ValidateProgram_program_not_4);
6089
6090 struct VertexAttrib1f {
6091   typedef VertexAttrib1f ValueType;
6092   static const CommandId kCmdId = kVertexAttrib1f;
6093   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6094   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6095
6096   static uint32_t ComputeSize() {
6097     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6098   }
6099
6100   void SetHeader() { header.SetCmd<ValueType>(); }
6101
6102   void Init(GLuint _indx, GLfloat _x) {
6103     SetHeader();
6104     indx = _indx;
6105     x = _x;
6106   }
6107
6108   void* Set(void* cmd, GLuint _indx, GLfloat _x) {
6109     static_cast<ValueType*>(cmd)->Init(_indx, _x);
6110     return NextCmdAddress<ValueType>(cmd);
6111   }
6112
6113   gpu::CommandHeader header;
6114   uint32_t indx;
6115   float x;
6116 };
6117
6118 COMPILE_ASSERT(sizeof(VertexAttrib1f) == 12, Sizeof_VertexAttrib1f_is_not_12);
6119 COMPILE_ASSERT(offsetof(VertexAttrib1f, header) == 0,
6120                OffsetOf_VertexAttrib1f_header_not_0);
6121 COMPILE_ASSERT(offsetof(VertexAttrib1f, indx) == 4,
6122                OffsetOf_VertexAttrib1f_indx_not_4);
6123 COMPILE_ASSERT(offsetof(VertexAttrib1f, x) == 8,
6124                OffsetOf_VertexAttrib1f_x_not_8);
6125
6126 struct VertexAttrib1fvImmediate {
6127   typedef VertexAttrib1fvImmediate ValueType;
6128   static const CommandId kCmdId = kVertexAttrib1fvImmediate;
6129   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
6130   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6131
6132   static uint32_t ComputeDataSize() {
6133     return static_cast<uint32_t>(sizeof(GLfloat) * 1);  // NOLINT
6134   }
6135
6136   static uint32_t ComputeSize() {
6137     return static_cast<uint32_t>(sizeof(ValueType) +
6138                                  ComputeDataSize());  // NOLINT
6139   }
6140
6141   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
6142
6143   void Init(GLuint _indx, const GLfloat* _values) {
6144     SetHeader();
6145     indx = _indx;
6146     memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
6147   }
6148
6149   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
6150     static_cast<ValueType*>(cmd)->Init(_indx, _values);
6151     const uint32_t size = ComputeSize();
6152     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6153   }
6154
6155   gpu::CommandHeader header;
6156   uint32_t indx;
6157 };
6158
6159 COMPILE_ASSERT(sizeof(VertexAttrib1fvImmediate) == 8,
6160                Sizeof_VertexAttrib1fvImmediate_is_not_8);
6161 COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, header) == 0,
6162                OffsetOf_VertexAttrib1fvImmediate_header_not_0);
6163 COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, indx) == 4,
6164                OffsetOf_VertexAttrib1fvImmediate_indx_not_4);
6165
6166 struct VertexAttrib2f {
6167   typedef VertexAttrib2f ValueType;
6168   static const CommandId kCmdId = kVertexAttrib2f;
6169   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6170   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6171
6172   static uint32_t ComputeSize() {
6173     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6174   }
6175
6176   void SetHeader() { header.SetCmd<ValueType>(); }
6177
6178   void Init(GLuint _indx, GLfloat _x, GLfloat _y) {
6179     SetHeader();
6180     indx = _indx;
6181     x = _x;
6182     y = _y;
6183   }
6184
6185   void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y) {
6186     static_cast<ValueType*>(cmd)->Init(_indx, _x, _y);
6187     return NextCmdAddress<ValueType>(cmd);
6188   }
6189
6190   gpu::CommandHeader header;
6191   uint32_t indx;
6192   float x;
6193   float y;
6194 };
6195
6196 COMPILE_ASSERT(sizeof(VertexAttrib2f) == 16, Sizeof_VertexAttrib2f_is_not_16);
6197 COMPILE_ASSERT(offsetof(VertexAttrib2f, header) == 0,
6198                OffsetOf_VertexAttrib2f_header_not_0);
6199 COMPILE_ASSERT(offsetof(VertexAttrib2f, indx) == 4,
6200                OffsetOf_VertexAttrib2f_indx_not_4);
6201 COMPILE_ASSERT(offsetof(VertexAttrib2f, x) == 8,
6202                OffsetOf_VertexAttrib2f_x_not_8);
6203 COMPILE_ASSERT(offsetof(VertexAttrib2f, y) == 12,
6204                OffsetOf_VertexAttrib2f_y_not_12);
6205
6206 struct VertexAttrib2fvImmediate {
6207   typedef VertexAttrib2fvImmediate ValueType;
6208   static const CommandId kCmdId = kVertexAttrib2fvImmediate;
6209   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
6210   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6211
6212   static uint32_t ComputeDataSize() {
6213     return static_cast<uint32_t>(sizeof(GLfloat) * 2);  // NOLINT
6214   }
6215
6216   static uint32_t ComputeSize() {
6217     return static_cast<uint32_t>(sizeof(ValueType) +
6218                                  ComputeDataSize());  // NOLINT
6219   }
6220
6221   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
6222
6223   void Init(GLuint _indx, const GLfloat* _values) {
6224     SetHeader();
6225     indx = _indx;
6226     memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
6227   }
6228
6229   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
6230     static_cast<ValueType*>(cmd)->Init(_indx, _values);
6231     const uint32_t size = ComputeSize();
6232     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6233   }
6234
6235   gpu::CommandHeader header;
6236   uint32_t indx;
6237 };
6238
6239 COMPILE_ASSERT(sizeof(VertexAttrib2fvImmediate) == 8,
6240                Sizeof_VertexAttrib2fvImmediate_is_not_8);
6241 COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, header) == 0,
6242                OffsetOf_VertexAttrib2fvImmediate_header_not_0);
6243 COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, indx) == 4,
6244                OffsetOf_VertexAttrib2fvImmediate_indx_not_4);
6245
6246 struct VertexAttrib3f {
6247   typedef VertexAttrib3f ValueType;
6248   static const CommandId kCmdId = kVertexAttrib3f;
6249   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6250   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6251
6252   static uint32_t ComputeSize() {
6253     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6254   }
6255
6256   void SetHeader() { header.SetCmd<ValueType>(); }
6257
6258   void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) {
6259     SetHeader();
6260     indx = _indx;
6261     x = _x;
6262     y = _y;
6263     z = _z;
6264   }
6265
6266   void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) {
6267     static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z);
6268     return NextCmdAddress<ValueType>(cmd);
6269   }
6270
6271   gpu::CommandHeader header;
6272   uint32_t indx;
6273   float x;
6274   float y;
6275   float z;
6276 };
6277
6278 COMPILE_ASSERT(sizeof(VertexAttrib3f) == 20, Sizeof_VertexAttrib3f_is_not_20);
6279 COMPILE_ASSERT(offsetof(VertexAttrib3f, header) == 0,
6280                OffsetOf_VertexAttrib3f_header_not_0);
6281 COMPILE_ASSERT(offsetof(VertexAttrib3f, indx) == 4,
6282                OffsetOf_VertexAttrib3f_indx_not_4);
6283 COMPILE_ASSERT(offsetof(VertexAttrib3f, x) == 8,
6284                OffsetOf_VertexAttrib3f_x_not_8);
6285 COMPILE_ASSERT(offsetof(VertexAttrib3f, y) == 12,
6286                OffsetOf_VertexAttrib3f_y_not_12);
6287 COMPILE_ASSERT(offsetof(VertexAttrib3f, z) == 16,
6288                OffsetOf_VertexAttrib3f_z_not_16);
6289
6290 struct VertexAttrib3fvImmediate {
6291   typedef VertexAttrib3fvImmediate ValueType;
6292   static const CommandId kCmdId = kVertexAttrib3fvImmediate;
6293   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
6294   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6295
6296   static uint32_t ComputeDataSize() {
6297     return static_cast<uint32_t>(sizeof(GLfloat) * 3);  // NOLINT
6298   }
6299
6300   static uint32_t ComputeSize() {
6301     return static_cast<uint32_t>(sizeof(ValueType) +
6302                                  ComputeDataSize());  // NOLINT
6303   }
6304
6305   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
6306
6307   void Init(GLuint _indx, const GLfloat* _values) {
6308     SetHeader();
6309     indx = _indx;
6310     memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
6311   }
6312
6313   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
6314     static_cast<ValueType*>(cmd)->Init(_indx, _values);
6315     const uint32_t size = ComputeSize();
6316     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6317   }
6318
6319   gpu::CommandHeader header;
6320   uint32_t indx;
6321 };
6322
6323 COMPILE_ASSERT(sizeof(VertexAttrib3fvImmediate) == 8,
6324                Sizeof_VertexAttrib3fvImmediate_is_not_8);
6325 COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, header) == 0,
6326                OffsetOf_VertexAttrib3fvImmediate_header_not_0);
6327 COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, indx) == 4,
6328                OffsetOf_VertexAttrib3fvImmediate_indx_not_4);
6329
6330 struct VertexAttrib4f {
6331   typedef VertexAttrib4f ValueType;
6332   static const CommandId kCmdId = kVertexAttrib4f;
6333   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6334   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6335
6336   static uint32_t ComputeSize() {
6337     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6338   }
6339
6340   void SetHeader() { header.SetCmd<ValueType>(); }
6341
6342   void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
6343     SetHeader();
6344     indx = _indx;
6345     x = _x;
6346     y = _y;
6347     z = _z;
6348     w = _w;
6349   }
6350
6351   void* Set(void* cmd,
6352             GLuint _indx,
6353             GLfloat _x,
6354             GLfloat _y,
6355             GLfloat _z,
6356             GLfloat _w) {
6357     static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w);
6358     return NextCmdAddress<ValueType>(cmd);
6359   }
6360
6361   gpu::CommandHeader header;
6362   uint32_t indx;
6363   float x;
6364   float y;
6365   float z;
6366   float w;
6367 };
6368
6369 COMPILE_ASSERT(sizeof(VertexAttrib4f) == 24, Sizeof_VertexAttrib4f_is_not_24);
6370 COMPILE_ASSERT(offsetof(VertexAttrib4f, header) == 0,
6371                OffsetOf_VertexAttrib4f_header_not_0);
6372 COMPILE_ASSERT(offsetof(VertexAttrib4f, indx) == 4,
6373                OffsetOf_VertexAttrib4f_indx_not_4);
6374 COMPILE_ASSERT(offsetof(VertexAttrib4f, x) == 8,
6375                OffsetOf_VertexAttrib4f_x_not_8);
6376 COMPILE_ASSERT(offsetof(VertexAttrib4f, y) == 12,
6377                OffsetOf_VertexAttrib4f_y_not_12);
6378 COMPILE_ASSERT(offsetof(VertexAttrib4f, z) == 16,
6379                OffsetOf_VertexAttrib4f_z_not_16);
6380 COMPILE_ASSERT(offsetof(VertexAttrib4f, w) == 20,
6381                OffsetOf_VertexAttrib4f_w_not_20);
6382
6383 struct VertexAttrib4fvImmediate {
6384   typedef VertexAttrib4fvImmediate ValueType;
6385   static const CommandId kCmdId = kVertexAttrib4fvImmediate;
6386   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
6387   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6388
6389   static uint32_t ComputeDataSize() {
6390     return static_cast<uint32_t>(sizeof(GLfloat) * 4);  // NOLINT
6391   }
6392
6393   static uint32_t ComputeSize() {
6394     return static_cast<uint32_t>(sizeof(ValueType) +
6395                                  ComputeDataSize());  // NOLINT
6396   }
6397
6398   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
6399
6400   void Init(GLuint _indx, const GLfloat* _values) {
6401     SetHeader();
6402     indx = _indx;
6403     memcpy(ImmediateDataAddress(this), _values, ComputeDataSize());
6404   }
6405
6406   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
6407     static_cast<ValueType*>(cmd)->Init(_indx, _values);
6408     const uint32_t size = ComputeSize();
6409     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6410   }
6411
6412   gpu::CommandHeader header;
6413   uint32_t indx;
6414 };
6415
6416 COMPILE_ASSERT(sizeof(VertexAttrib4fvImmediate) == 8,
6417                Sizeof_VertexAttrib4fvImmediate_is_not_8);
6418 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0,
6419                OffsetOf_VertexAttrib4fvImmediate_header_not_0);
6420 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4,
6421                OffsetOf_VertexAttrib4fvImmediate_indx_not_4);
6422
6423 struct VertexAttribPointer {
6424   typedef VertexAttribPointer ValueType;
6425   static const CommandId kCmdId = kVertexAttribPointer;
6426   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6427   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6428
6429   static uint32_t ComputeSize() {
6430     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6431   }
6432
6433   void SetHeader() { header.SetCmd<ValueType>(); }
6434
6435   void Init(GLuint _indx,
6436             GLint _size,
6437             GLenum _type,
6438             GLboolean _normalized,
6439             GLsizei _stride,
6440             GLuint _offset) {
6441     SetHeader();
6442     indx = _indx;
6443     size = _size;
6444     type = _type;
6445     normalized = _normalized;
6446     stride = _stride;
6447     offset = _offset;
6448   }
6449
6450   void* Set(void* cmd,
6451             GLuint _indx,
6452             GLint _size,
6453             GLenum _type,
6454             GLboolean _normalized,
6455             GLsizei _stride,
6456             GLuint _offset) {
6457     static_cast<ValueType*>(cmd)
6458         ->Init(_indx, _size, _type, _normalized, _stride, _offset);
6459     return NextCmdAddress<ValueType>(cmd);
6460   }
6461
6462   gpu::CommandHeader header;
6463   uint32_t indx;
6464   int32_t size;
6465   uint32_t type;
6466   uint32_t normalized;
6467   int32_t stride;
6468   uint32_t offset;
6469 };
6470
6471 COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28,
6472                Sizeof_VertexAttribPointer_is_not_28);
6473 COMPILE_ASSERT(offsetof(VertexAttribPointer, header) == 0,
6474                OffsetOf_VertexAttribPointer_header_not_0);
6475 COMPILE_ASSERT(offsetof(VertexAttribPointer, indx) == 4,
6476                OffsetOf_VertexAttribPointer_indx_not_4);
6477 COMPILE_ASSERT(offsetof(VertexAttribPointer, size) == 8,
6478                OffsetOf_VertexAttribPointer_size_not_8);
6479 COMPILE_ASSERT(offsetof(VertexAttribPointer, type) == 12,
6480                OffsetOf_VertexAttribPointer_type_not_12);
6481 COMPILE_ASSERT(offsetof(VertexAttribPointer, normalized) == 16,
6482                OffsetOf_VertexAttribPointer_normalized_not_16);
6483 COMPILE_ASSERT(offsetof(VertexAttribPointer, stride) == 20,
6484                OffsetOf_VertexAttribPointer_stride_not_20);
6485 COMPILE_ASSERT(offsetof(VertexAttribPointer, offset) == 24,
6486                OffsetOf_VertexAttribPointer_offset_not_24);
6487
6488 struct Viewport {
6489   typedef Viewport ValueType;
6490   static const CommandId kCmdId = kViewport;
6491   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6492   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6493
6494   static uint32_t ComputeSize() {
6495     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6496   }
6497
6498   void SetHeader() { header.SetCmd<ValueType>(); }
6499
6500   void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
6501     SetHeader();
6502     x = _x;
6503     y = _y;
6504     width = _width;
6505     height = _height;
6506   }
6507
6508   void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
6509     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
6510     return NextCmdAddress<ValueType>(cmd);
6511   }
6512
6513   gpu::CommandHeader header;
6514   int32_t x;
6515   int32_t y;
6516   int32_t width;
6517   int32_t height;
6518 };
6519
6520 COMPILE_ASSERT(sizeof(Viewport) == 20, Sizeof_Viewport_is_not_20);
6521 COMPILE_ASSERT(offsetof(Viewport, header) == 0, OffsetOf_Viewport_header_not_0);
6522 COMPILE_ASSERT(offsetof(Viewport, x) == 4, OffsetOf_Viewport_x_not_4);
6523 COMPILE_ASSERT(offsetof(Viewport, y) == 8, OffsetOf_Viewport_y_not_8);
6524 COMPILE_ASSERT(offsetof(Viewport, width) == 12, OffsetOf_Viewport_width_not_12);
6525 COMPILE_ASSERT(offsetof(Viewport, height) == 16,
6526                OffsetOf_Viewport_height_not_16);
6527
6528 struct BlitFramebufferCHROMIUM {
6529   typedef BlitFramebufferCHROMIUM ValueType;
6530   static const CommandId kCmdId = kBlitFramebufferCHROMIUM;
6531   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6532   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
6533
6534   static uint32_t ComputeSize() {
6535     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6536   }
6537
6538   void SetHeader() { header.SetCmd<ValueType>(); }
6539
6540   void Init(GLint _srcX0,
6541             GLint _srcY0,
6542             GLint _srcX1,
6543             GLint _srcY1,
6544             GLint _dstX0,
6545             GLint _dstY0,
6546             GLint _dstX1,
6547             GLint _dstY1,
6548             GLbitfield _mask,
6549             GLenum _filter) {
6550     SetHeader();
6551     srcX0 = _srcX0;
6552     srcY0 = _srcY0;
6553     srcX1 = _srcX1;
6554     srcY1 = _srcY1;
6555     dstX0 = _dstX0;
6556     dstY0 = _dstY0;
6557     dstX1 = _dstX1;
6558     dstY1 = _dstY1;
6559     mask = _mask;
6560     filter = _filter;
6561   }
6562
6563   void* Set(void* cmd,
6564             GLint _srcX0,
6565             GLint _srcY0,
6566             GLint _srcX1,
6567             GLint _srcY1,
6568             GLint _dstX0,
6569             GLint _dstY0,
6570             GLint _dstX1,
6571             GLint _dstY1,
6572             GLbitfield _mask,
6573             GLenum _filter) {
6574     static_cast<ValueType*>(cmd)->Init(_srcX0, _srcY0, _srcX1, _srcY1, _dstX0,
6575                                        _dstY0, _dstX1, _dstY1, _mask, _filter);
6576     return NextCmdAddress<ValueType>(cmd);
6577   }
6578
6579   gpu::CommandHeader header;
6580   int32_t srcX0;
6581   int32_t srcY0;
6582   int32_t srcX1;
6583   int32_t srcY1;
6584   int32_t dstX0;
6585   int32_t dstY0;
6586   int32_t dstX1;
6587   int32_t dstY1;
6588   uint32_t mask;
6589   uint32_t filter;
6590 };
6591
6592 COMPILE_ASSERT(sizeof(BlitFramebufferCHROMIUM) == 44,
6593                Sizeof_BlitFramebufferCHROMIUM_is_not_44);
6594 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, header) == 0,
6595                OffsetOf_BlitFramebufferCHROMIUM_header_not_0);
6596 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcX0) == 4,
6597                OffsetOf_BlitFramebufferCHROMIUM_srcX0_not_4);
6598 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcY0) == 8,
6599                OffsetOf_BlitFramebufferCHROMIUM_srcY0_not_8);
6600 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcX1) == 12,
6601                OffsetOf_BlitFramebufferCHROMIUM_srcX1_not_12);
6602 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, srcY1) == 16,
6603                OffsetOf_BlitFramebufferCHROMIUM_srcY1_not_16);
6604 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstX0) == 20,
6605                OffsetOf_BlitFramebufferCHROMIUM_dstX0_not_20);
6606 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstY0) == 24,
6607                OffsetOf_BlitFramebufferCHROMIUM_dstY0_not_24);
6608 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstX1) == 28,
6609                OffsetOf_BlitFramebufferCHROMIUM_dstX1_not_28);
6610 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, dstY1) == 32,
6611                OffsetOf_BlitFramebufferCHROMIUM_dstY1_not_32);
6612 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, mask) == 36,
6613                OffsetOf_BlitFramebufferCHROMIUM_mask_not_36);
6614 COMPILE_ASSERT(offsetof(BlitFramebufferCHROMIUM, filter) == 40,
6615                OffsetOf_BlitFramebufferCHROMIUM_filter_not_40);
6616
6617 // GL_CHROMIUM_framebuffer_multisample
6618 struct RenderbufferStorageMultisampleCHROMIUM {
6619   typedef RenderbufferStorageMultisampleCHROMIUM ValueType;
6620   static const CommandId kCmdId = kRenderbufferStorageMultisampleCHROMIUM;
6621   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6622   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6623
6624   static uint32_t ComputeSize() {
6625     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6626   }
6627
6628   void SetHeader() { header.SetCmd<ValueType>(); }
6629
6630   void Init(GLenum _target,
6631             GLsizei _samples,
6632             GLenum _internalformat,
6633             GLsizei _width,
6634             GLsizei _height) {
6635     SetHeader();
6636     target = _target;
6637     samples = _samples;
6638     internalformat = _internalformat;
6639     width = _width;
6640     height = _height;
6641   }
6642
6643   void* Set(void* cmd,
6644             GLenum _target,
6645             GLsizei _samples,
6646             GLenum _internalformat,
6647             GLsizei _width,
6648             GLsizei _height) {
6649     static_cast<ValueType*>(cmd)
6650         ->Init(_target, _samples, _internalformat, _width, _height);
6651     return NextCmdAddress<ValueType>(cmd);
6652   }
6653
6654   gpu::CommandHeader header;
6655   uint32_t target;
6656   int32_t samples;
6657   uint32_t internalformat;
6658   int32_t width;
6659   int32_t height;
6660 };
6661
6662 COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleCHROMIUM) == 24,
6663                Sizeof_RenderbufferStorageMultisampleCHROMIUM_is_not_24);
6664 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, header) == 0,
6665                OffsetOf_RenderbufferStorageMultisampleCHROMIUM_header_not_0);
6666 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, target) == 4,
6667                OffsetOf_RenderbufferStorageMultisampleCHROMIUM_target_not_4);
6668 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, samples) == 8,
6669                OffsetOf_RenderbufferStorageMultisampleCHROMIUM_samples_not_8);
6670 COMPILE_ASSERT(
6671     offsetof(RenderbufferStorageMultisampleCHROMIUM, internalformat) == 12,
6672     OffsetOf_RenderbufferStorageMultisampleCHROMIUM_internalformat_not_12);
6673 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, width) == 16,
6674                OffsetOf_RenderbufferStorageMultisampleCHROMIUM_width_not_16);
6675 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleCHROMIUM, height) == 20,
6676                OffsetOf_RenderbufferStorageMultisampleCHROMIUM_height_not_20);
6677
6678 // GL_EXT_multisampled_render_to_texture
6679 struct RenderbufferStorageMultisampleEXT {
6680   typedef RenderbufferStorageMultisampleEXT ValueType;
6681   static const CommandId kCmdId = kRenderbufferStorageMultisampleEXT;
6682   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6683   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6684
6685   static uint32_t ComputeSize() {
6686     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6687   }
6688
6689   void SetHeader() { header.SetCmd<ValueType>(); }
6690
6691   void Init(GLenum _target,
6692             GLsizei _samples,
6693             GLenum _internalformat,
6694             GLsizei _width,
6695             GLsizei _height) {
6696     SetHeader();
6697     target = _target;
6698     samples = _samples;
6699     internalformat = _internalformat;
6700     width = _width;
6701     height = _height;
6702   }
6703
6704   void* Set(void* cmd,
6705             GLenum _target,
6706             GLsizei _samples,
6707             GLenum _internalformat,
6708             GLsizei _width,
6709             GLsizei _height) {
6710     static_cast<ValueType*>(cmd)
6711         ->Init(_target, _samples, _internalformat, _width, _height);
6712     return NextCmdAddress<ValueType>(cmd);
6713   }
6714
6715   gpu::CommandHeader header;
6716   uint32_t target;
6717   int32_t samples;
6718   uint32_t internalformat;
6719   int32_t width;
6720   int32_t height;
6721 };
6722
6723 COMPILE_ASSERT(sizeof(RenderbufferStorageMultisampleEXT) == 24,
6724                Sizeof_RenderbufferStorageMultisampleEXT_is_not_24);
6725 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, header) == 0,
6726                OffsetOf_RenderbufferStorageMultisampleEXT_header_not_0);
6727 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, target) == 4,
6728                OffsetOf_RenderbufferStorageMultisampleEXT_target_not_4);
6729 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, samples) == 8,
6730                OffsetOf_RenderbufferStorageMultisampleEXT_samples_not_8);
6731 COMPILE_ASSERT(
6732     offsetof(RenderbufferStorageMultisampleEXT, internalformat) == 12,
6733     OffsetOf_RenderbufferStorageMultisampleEXT_internalformat_not_12);
6734 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, width) == 16,
6735                OffsetOf_RenderbufferStorageMultisampleEXT_width_not_16);
6736 COMPILE_ASSERT(offsetof(RenderbufferStorageMultisampleEXT, height) == 20,
6737                OffsetOf_RenderbufferStorageMultisampleEXT_height_not_20);
6738
6739 struct FramebufferTexture2DMultisampleEXT {
6740   typedef FramebufferTexture2DMultisampleEXT ValueType;
6741   static const CommandId kCmdId = kFramebufferTexture2DMultisampleEXT;
6742   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6743   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
6744
6745   static uint32_t ComputeSize() {
6746     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6747   }
6748
6749   void SetHeader() { header.SetCmd<ValueType>(); }
6750
6751   void Init(GLenum _target,
6752             GLenum _attachment,
6753             GLenum _textarget,
6754             GLuint _texture,
6755             GLsizei _samples) {
6756     SetHeader();
6757     target = _target;
6758     attachment = _attachment;
6759     textarget = _textarget;
6760     texture = _texture;
6761     samples = _samples;
6762   }
6763
6764   void* Set(void* cmd,
6765             GLenum _target,
6766             GLenum _attachment,
6767             GLenum _textarget,
6768             GLuint _texture,
6769             GLsizei _samples) {
6770     static_cast<ValueType*>(cmd)
6771         ->Init(_target, _attachment, _textarget, _texture, _samples);
6772     return NextCmdAddress<ValueType>(cmd);
6773   }
6774
6775   gpu::CommandHeader header;
6776   uint32_t target;
6777   uint32_t attachment;
6778   uint32_t textarget;
6779   uint32_t texture;
6780   int32_t samples;
6781   static const int32_t level = 0;
6782 };
6783
6784 COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 24,
6785                Sizeof_FramebufferTexture2DMultisampleEXT_is_not_24);
6786 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, header) == 0,
6787                OffsetOf_FramebufferTexture2DMultisampleEXT_header_not_0);
6788 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, target) == 4,
6789                OffsetOf_FramebufferTexture2DMultisampleEXT_target_not_4);
6790 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, attachment) == 8,
6791                OffsetOf_FramebufferTexture2DMultisampleEXT_attachment_not_8);
6792 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, textarget) == 12,
6793                OffsetOf_FramebufferTexture2DMultisampleEXT_textarget_not_12);
6794 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, texture) == 16,
6795                OffsetOf_FramebufferTexture2DMultisampleEXT_texture_not_16);
6796 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, samples) == 20,
6797                OffsetOf_FramebufferTexture2DMultisampleEXT_samples_not_20);
6798
6799 struct TexStorage2DEXT {
6800   typedef TexStorage2DEXT ValueType;
6801   static const CommandId kCmdId = kTexStorage2DEXT;
6802   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6803   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6804
6805   static uint32_t ComputeSize() {
6806     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6807   }
6808
6809   void SetHeader() { header.SetCmd<ValueType>(); }
6810
6811   void Init(GLenum _target,
6812             GLsizei _levels,
6813             GLenum _internalFormat,
6814             GLsizei _width,
6815             GLsizei _height) {
6816     SetHeader();
6817     target = _target;
6818     levels = _levels;
6819     internalFormat = _internalFormat;
6820     width = _width;
6821     height = _height;
6822   }
6823
6824   void* Set(void* cmd,
6825             GLenum _target,
6826             GLsizei _levels,
6827             GLenum _internalFormat,
6828             GLsizei _width,
6829             GLsizei _height) {
6830     static_cast<ValueType*>(cmd)
6831         ->Init(_target, _levels, _internalFormat, _width, _height);
6832     return NextCmdAddress<ValueType>(cmd);
6833   }
6834
6835   gpu::CommandHeader header;
6836   uint32_t target;
6837   int32_t levels;
6838   uint32_t internalFormat;
6839   int32_t width;
6840   int32_t height;
6841 };
6842
6843 COMPILE_ASSERT(sizeof(TexStorage2DEXT) == 24, Sizeof_TexStorage2DEXT_is_not_24);
6844 COMPILE_ASSERT(offsetof(TexStorage2DEXT, header) == 0,
6845                OffsetOf_TexStorage2DEXT_header_not_0);
6846 COMPILE_ASSERT(offsetof(TexStorage2DEXT, target) == 4,
6847                OffsetOf_TexStorage2DEXT_target_not_4);
6848 COMPILE_ASSERT(offsetof(TexStorage2DEXT, levels) == 8,
6849                OffsetOf_TexStorage2DEXT_levels_not_8);
6850 COMPILE_ASSERT(offsetof(TexStorage2DEXT, internalFormat) == 12,
6851                OffsetOf_TexStorage2DEXT_internalFormat_not_12);
6852 COMPILE_ASSERT(offsetof(TexStorage2DEXT, width) == 16,
6853                OffsetOf_TexStorage2DEXT_width_not_16);
6854 COMPILE_ASSERT(offsetof(TexStorage2DEXT, height) == 20,
6855                OffsetOf_TexStorage2DEXT_height_not_20);
6856
6857 struct GenQueriesEXTImmediate {
6858   typedef GenQueriesEXTImmediate ValueType;
6859   static const CommandId kCmdId = kGenQueriesEXTImmediate;
6860   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
6861   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6862
6863   static uint32_t ComputeDataSize(GLsizei n) {
6864     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
6865   }
6866
6867   static uint32_t ComputeSize(GLsizei n) {
6868     return static_cast<uint32_t>(sizeof(ValueType) +
6869                                  ComputeDataSize(n));  // NOLINT
6870   }
6871
6872   void SetHeader(GLsizei n) {
6873     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
6874   }
6875
6876   void Init(GLsizei _n, GLuint* _queries) {
6877     SetHeader(_n);
6878     n = _n;
6879     memcpy(ImmediateDataAddress(this), _queries, ComputeDataSize(_n));
6880   }
6881
6882   void* Set(void* cmd, GLsizei _n, GLuint* _queries) {
6883     static_cast<ValueType*>(cmd)->Init(_n, _queries);
6884     const uint32_t size = ComputeSize(_n);
6885     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6886   }
6887
6888   gpu::CommandHeader header;
6889   int32_t n;
6890 };
6891
6892 COMPILE_ASSERT(sizeof(GenQueriesEXTImmediate) == 8,
6893                Sizeof_GenQueriesEXTImmediate_is_not_8);
6894 COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, header) == 0,
6895                OffsetOf_GenQueriesEXTImmediate_header_not_0);
6896 COMPILE_ASSERT(offsetof(GenQueriesEXTImmediate, n) == 4,
6897                OffsetOf_GenQueriesEXTImmediate_n_not_4);
6898
6899 struct DeleteQueriesEXTImmediate {
6900   typedef DeleteQueriesEXTImmediate ValueType;
6901   static const CommandId kCmdId = kDeleteQueriesEXTImmediate;
6902   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
6903   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6904
6905   static uint32_t ComputeDataSize(GLsizei n) {
6906     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
6907   }
6908
6909   static uint32_t ComputeSize(GLsizei n) {
6910     return static_cast<uint32_t>(sizeof(ValueType) +
6911                                  ComputeDataSize(n));  // NOLINT
6912   }
6913
6914   void SetHeader(GLsizei n) {
6915     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
6916   }
6917
6918   void Init(GLsizei _n, const GLuint* _queries) {
6919     SetHeader(_n);
6920     n = _n;
6921     memcpy(ImmediateDataAddress(this), _queries, ComputeDataSize(_n));
6922   }
6923
6924   void* Set(void* cmd, GLsizei _n, const GLuint* _queries) {
6925     static_cast<ValueType*>(cmd)->Init(_n, _queries);
6926     const uint32_t size = ComputeSize(_n);
6927     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
6928   }
6929
6930   gpu::CommandHeader header;
6931   int32_t n;
6932 };
6933
6934 COMPILE_ASSERT(sizeof(DeleteQueriesEXTImmediate) == 8,
6935                Sizeof_DeleteQueriesEXTImmediate_is_not_8);
6936 COMPILE_ASSERT(offsetof(DeleteQueriesEXTImmediate, header) == 0,
6937                OffsetOf_DeleteQueriesEXTImmediate_header_not_0);
6938 COMPILE_ASSERT(offsetof(DeleteQueriesEXTImmediate, n) == 4,
6939                OffsetOf_DeleteQueriesEXTImmediate_n_not_4);
6940
6941 struct BeginQueryEXT {
6942   typedef BeginQueryEXT ValueType;
6943   static const CommandId kCmdId = kBeginQueryEXT;
6944   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6945   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6946
6947   static uint32_t ComputeSize() {
6948     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
6949   }
6950
6951   void SetHeader() { header.SetCmd<ValueType>(); }
6952
6953   void Init(GLenum _target,
6954             GLuint _id,
6955             uint32_t _sync_data_shm_id,
6956             uint32_t _sync_data_shm_offset) {
6957     SetHeader();
6958     target = _target;
6959     id = _id;
6960     sync_data_shm_id = _sync_data_shm_id;
6961     sync_data_shm_offset = _sync_data_shm_offset;
6962   }
6963
6964   void* Set(void* cmd,
6965             GLenum _target,
6966             GLuint _id,
6967             uint32_t _sync_data_shm_id,
6968             uint32_t _sync_data_shm_offset) {
6969     static_cast<ValueType*>(cmd)
6970         ->Init(_target, _id, _sync_data_shm_id, _sync_data_shm_offset);
6971     return NextCmdAddress<ValueType>(cmd);
6972   }
6973
6974   gpu::CommandHeader header;
6975   uint32_t target;
6976   uint32_t id;
6977   uint32_t sync_data_shm_id;
6978   uint32_t sync_data_shm_offset;
6979 };
6980
6981 COMPILE_ASSERT(sizeof(BeginQueryEXT) == 20, Sizeof_BeginQueryEXT_is_not_20);
6982 COMPILE_ASSERT(offsetof(BeginQueryEXT, header) == 0,
6983                OffsetOf_BeginQueryEXT_header_not_0);
6984 COMPILE_ASSERT(offsetof(BeginQueryEXT, target) == 4,
6985                OffsetOf_BeginQueryEXT_target_not_4);
6986 COMPILE_ASSERT(offsetof(BeginQueryEXT, id) == 8,
6987                OffsetOf_BeginQueryEXT_id_not_8);
6988 COMPILE_ASSERT(offsetof(BeginQueryEXT, sync_data_shm_id) == 12,
6989                OffsetOf_BeginQueryEXT_sync_data_shm_id_not_12);
6990 COMPILE_ASSERT(offsetof(BeginQueryEXT, sync_data_shm_offset) == 16,
6991                OffsetOf_BeginQueryEXT_sync_data_shm_offset_not_16);
6992
6993 struct EndQueryEXT {
6994   typedef EndQueryEXT ValueType;
6995   static const CommandId kCmdId = kEndQueryEXT;
6996   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
6997   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
6998
6999   static uint32_t ComputeSize() {
7000     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7001   }
7002
7003   void SetHeader() { header.SetCmd<ValueType>(); }
7004
7005   void Init(GLenum _target, GLuint _submit_count) {
7006     SetHeader();
7007     target = _target;
7008     submit_count = _submit_count;
7009   }
7010
7011   void* Set(void* cmd, GLenum _target, GLuint _submit_count) {
7012     static_cast<ValueType*>(cmd)->Init(_target, _submit_count);
7013     return NextCmdAddress<ValueType>(cmd);
7014   }
7015
7016   gpu::CommandHeader header;
7017   uint32_t target;
7018   uint32_t submit_count;
7019 };
7020
7021 COMPILE_ASSERT(sizeof(EndQueryEXT) == 12, Sizeof_EndQueryEXT_is_not_12);
7022 COMPILE_ASSERT(offsetof(EndQueryEXT, header) == 0,
7023                OffsetOf_EndQueryEXT_header_not_0);
7024 COMPILE_ASSERT(offsetof(EndQueryEXT, target) == 4,
7025                OffsetOf_EndQueryEXT_target_not_4);
7026 COMPILE_ASSERT(offsetof(EndQueryEXT, submit_count) == 8,
7027                OffsetOf_EndQueryEXT_submit_count_not_8);
7028
7029 struct InsertEventMarkerEXT {
7030   typedef InsertEventMarkerEXT ValueType;
7031   static const CommandId kCmdId = kInsertEventMarkerEXT;
7032   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7033   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7034
7035   static uint32_t ComputeSize() {
7036     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7037   }
7038
7039   void SetHeader() { header.SetCmd<ValueType>(); }
7040
7041   void Init(GLuint _bucket_id) {
7042     SetHeader();
7043     bucket_id = _bucket_id;
7044   }
7045
7046   void* Set(void* cmd, GLuint _bucket_id) {
7047     static_cast<ValueType*>(cmd)->Init(_bucket_id);
7048     return NextCmdAddress<ValueType>(cmd);
7049   }
7050
7051   gpu::CommandHeader header;
7052   uint32_t bucket_id;
7053 };
7054
7055 COMPILE_ASSERT(sizeof(InsertEventMarkerEXT) == 8,
7056                Sizeof_InsertEventMarkerEXT_is_not_8);
7057 COMPILE_ASSERT(offsetof(InsertEventMarkerEXT, header) == 0,
7058                OffsetOf_InsertEventMarkerEXT_header_not_0);
7059 COMPILE_ASSERT(offsetof(InsertEventMarkerEXT, bucket_id) == 4,
7060                OffsetOf_InsertEventMarkerEXT_bucket_id_not_4);
7061
7062 struct PushGroupMarkerEXT {
7063   typedef PushGroupMarkerEXT ValueType;
7064   static const CommandId kCmdId = kPushGroupMarkerEXT;
7065   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7066   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7067
7068   static uint32_t ComputeSize() {
7069     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7070   }
7071
7072   void SetHeader() { header.SetCmd<ValueType>(); }
7073
7074   void Init(GLuint _bucket_id) {
7075     SetHeader();
7076     bucket_id = _bucket_id;
7077   }
7078
7079   void* Set(void* cmd, GLuint _bucket_id) {
7080     static_cast<ValueType*>(cmd)->Init(_bucket_id);
7081     return NextCmdAddress<ValueType>(cmd);
7082   }
7083
7084   gpu::CommandHeader header;
7085   uint32_t bucket_id;
7086 };
7087
7088 COMPILE_ASSERT(sizeof(PushGroupMarkerEXT) == 8,
7089                Sizeof_PushGroupMarkerEXT_is_not_8);
7090 COMPILE_ASSERT(offsetof(PushGroupMarkerEXT, header) == 0,
7091                OffsetOf_PushGroupMarkerEXT_header_not_0);
7092 COMPILE_ASSERT(offsetof(PushGroupMarkerEXT, bucket_id) == 4,
7093                OffsetOf_PushGroupMarkerEXT_bucket_id_not_4);
7094
7095 struct PopGroupMarkerEXT {
7096   typedef PopGroupMarkerEXT ValueType;
7097   static const CommandId kCmdId = kPopGroupMarkerEXT;
7098   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7099   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7100
7101   static uint32_t ComputeSize() {
7102     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7103   }
7104
7105   void SetHeader() { header.SetCmd<ValueType>(); }
7106
7107   void Init() { SetHeader(); }
7108
7109   void* Set(void* cmd) {
7110     static_cast<ValueType*>(cmd)->Init();
7111     return NextCmdAddress<ValueType>(cmd);
7112   }
7113
7114   gpu::CommandHeader header;
7115 };
7116
7117 COMPILE_ASSERT(sizeof(PopGroupMarkerEXT) == 4,
7118                Sizeof_PopGroupMarkerEXT_is_not_4);
7119 COMPILE_ASSERT(offsetof(PopGroupMarkerEXT, header) == 0,
7120                OffsetOf_PopGroupMarkerEXT_header_not_0);
7121
7122 struct GenVertexArraysOESImmediate {
7123   typedef GenVertexArraysOESImmediate ValueType;
7124   static const CommandId kCmdId = kGenVertexArraysOESImmediate;
7125   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
7126   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7127
7128   static uint32_t ComputeDataSize(GLsizei n) {
7129     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
7130   }
7131
7132   static uint32_t ComputeSize(GLsizei n) {
7133     return static_cast<uint32_t>(sizeof(ValueType) +
7134                                  ComputeDataSize(n));  // NOLINT
7135   }
7136
7137   void SetHeader(GLsizei n) {
7138     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
7139   }
7140
7141   void Init(GLsizei _n, GLuint* _arrays) {
7142     SetHeader(_n);
7143     n = _n;
7144     memcpy(ImmediateDataAddress(this), _arrays, ComputeDataSize(_n));
7145   }
7146
7147   void* Set(void* cmd, GLsizei _n, GLuint* _arrays) {
7148     static_cast<ValueType*>(cmd)->Init(_n, _arrays);
7149     const uint32_t size = ComputeSize(_n);
7150     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
7151   }
7152
7153   gpu::CommandHeader header;
7154   int32_t n;
7155 };
7156
7157 COMPILE_ASSERT(sizeof(GenVertexArraysOESImmediate) == 8,
7158                Sizeof_GenVertexArraysOESImmediate_is_not_8);
7159 COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, header) == 0,
7160                OffsetOf_GenVertexArraysOESImmediate_header_not_0);
7161 COMPILE_ASSERT(offsetof(GenVertexArraysOESImmediate, n) == 4,
7162                OffsetOf_GenVertexArraysOESImmediate_n_not_4);
7163
7164 struct DeleteVertexArraysOESImmediate {
7165   typedef DeleteVertexArraysOESImmediate ValueType;
7166   static const CommandId kCmdId = kDeleteVertexArraysOESImmediate;
7167   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
7168   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7169
7170   static uint32_t ComputeDataSize(GLsizei n) {
7171     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
7172   }
7173
7174   static uint32_t ComputeSize(GLsizei n) {
7175     return static_cast<uint32_t>(sizeof(ValueType) +
7176                                  ComputeDataSize(n));  // NOLINT
7177   }
7178
7179   void SetHeader(GLsizei n) {
7180     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
7181   }
7182
7183   void Init(GLsizei _n, const GLuint* _arrays) {
7184     SetHeader(_n);
7185     n = _n;
7186     memcpy(ImmediateDataAddress(this), _arrays, ComputeDataSize(_n));
7187   }
7188
7189   void* Set(void* cmd, GLsizei _n, const GLuint* _arrays) {
7190     static_cast<ValueType*>(cmd)->Init(_n, _arrays);
7191     const uint32_t size = ComputeSize(_n);
7192     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
7193   }
7194
7195   gpu::CommandHeader header;
7196   int32_t n;
7197 };
7198
7199 COMPILE_ASSERT(sizeof(DeleteVertexArraysOESImmediate) == 8,
7200                Sizeof_DeleteVertexArraysOESImmediate_is_not_8);
7201 COMPILE_ASSERT(offsetof(DeleteVertexArraysOESImmediate, header) == 0,
7202                OffsetOf_DeleteVertexArraysOESImmediate_header_not_0);
7203 COMPILE_ASSERT(offsetof(DeleteVertexArraysOESImmediate, n) == 4,
7204                OffsetOf_DeleteVertexArraysOESImmediate_n_not_4);
7205
7206 struct IsVertexArrayOES {
7207   typedef IsVertexArrayOES ValueType;
7208   static const CommandId kCmdId = kIsVertexArrayOES;
7209   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7210   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7211
7212   typedef uint32_t Result;
7213
7214   static uint32_t ComputeSize() {
7215     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7216   }
7217
7218   void SetHeader() { header.SetCmd<ValueType>(); }
7219
7220   void Init(GLuint _array,
7221             uint32_t _result_shm_id,
7222             uint32_t _result_shm_offset) {
7223     SetHeader();
7224     array = _array;
7225     result_shm_id = _result_shm_id;
7226     result_shm_offset = _result_shm_offset;
7227   }
7228
7229   void* Set(void* cmd,
7230             GLuint _array,
7231             uint32_t _result_shm_id,
7232             uint32_t _result_shm_offset) {
7233     static_cast<ValueType*>(cmd)
7234         ->Init(_array, _result_shm_id, _result_shm_offset);
7235     return NextCmdAddress<ValueType>(cmd);
7236   }
7237
7238   gpu::CommandHeader header;
7239   uint32_t array;
7240   uint32_t result_shm_id;
7241   uint32_t result_shm_offset;
7242 };
7243
7244 COMPILE_ASSERT(sizeof(IsVertexArrayOES) == 16,
7245                Sizeof_IsVertexArrayOES_is_not_16);
7246 COMPILE_ASSERT(offsetof(IsVertexArrayOES, header) == 0,
7247                OffsetOf_IsVertexArrayOES_header_not_0);
7248 COMPILE_ASSERT(offsetof(IsVertexArrayOES, array) == 4,
7249                OffsetOf_IsVertexArrayOES_array_not_4);
7250 COMPILE_ASSERT(offsetof(IsVertexArrayOES, result_shm_id) == 8,
7251                OffsetOf_IsVertexArrayOES_result_shm_id_not_8);
7252 COMPILE_ASSERT(offsetof(IsVertexArrayOES, result_shm_offset) == 12,
7253                OffsetOf_IsVertexArrayOES_result_shm_offset_not_12);
7254
7255 struct BindVertexArrayOES {
7256   typedef BindVertexArrayOES ValueType;
7257   static const CommandId kCmdId = kBindVertexArrayOES;
7258   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7259   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7260
7261   static uint32_t ComputeSize() {
7262     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7263   }
7264
7265   void SetHeader() { header.SetCmd<ValueType>(); }
7266
7267   void Init(GLuint _array) {
7268     SetHeader();
7269     array = _array;
7270   }
7271
7272   void* Set(void* cmd, GLuint _array) {
7273     static_cast<ValueType*>(cmd)->Init(_array);
7274     return NextCmdAddress<ValueType>(cmd);
7275   }
7276
7277   gpu::CommandHeader header;
7278   uint32_t array;
7279 };
7280
7281 COMPILE_ASSERT(sizeof(BindVertexArrayOES) == 8,
7282                Sizeof_BindVertexArrayOES_is_not_8);
7283 COMPILE_ASSERT(offsetof(BindVertexArrayOES, header) == 0,
7284                OffsetOf_BindVertexArrayOES_header_not_0);
7285 COMPILE_ASSERT(offsetof(BindVertexArrayOES, array) == 4,
7286                OffsetOf_BindVertexArrayOES_array_not_4);
7287
7288 struct SwapBuffers {
7289   typedef SwapBuffers ValueType;
7290   static const CommandId kCmdId = kSwapBuffers;
7291   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7292   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
7293
7294   static uint32_t ComputeSize() {
7295     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7296   }
7297
7298   void SetHeader() { header.SetCmd<ValueType>(); }
7299
7300   void Init() { SetHeader(); }
7301
7302   void* Set(void* cmd) {
7303     static_cast<ValueType*>(cmd)->Init();
7304     return NextCmdAddress<ValueType>(cmd);
7305   }
7306
7307   gpu::CommandHeader header;
7308 };
7309
7310 COMPILE_ASSERT(sizeof(SwapBuffers) == 4, Sizeof_SwapBuffers_is_not_4);
7311 COMPILE_ASSERT(offsetof(SwapBuffers, header) == 0,
7312                OffsetOf_SwapBuffers_header_not_0);
7313
7314 struct GetMaxValueInBufferCHROMIUM {
7315   typedef GetMaxValueInBufferCHROMIUM ValueType;
7316   static const CommandId kCmdId = kGetMaxValueInBufferCHROMIUM;
7317   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7318   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7319
7320   typedef GLuint Result;
7321
7322   static uint32_t ComputeSize() {
7323     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7324   }
7325
7326   void SetHeader() { header.SetCmd<ValueType>(); }
7327
7328   void Init(GLuint _buffer_id,
7329             GLsizei _count,
7330             GLenum _type,
7331             GLuint _offset,
7332             uint32_t _result_shm_id,
7333             uint32_t _result_shm_offset) {
7334     SetHeader();
7335     buffer_id = _buffer_id;
7336     count = _count;
7337     type = _type;
7338     offset = _offset;
7339     result_shm_id = _result_shm_id;
7340     result_shm_offset = _result_shm_offset;
7341   }
7342
7343   void* Set(void* cmd,
7344             GLuint _buffer_id,
7345             GLsizei _count,
7346             GLenum _type,
7347             GLuint _offset,
7348             uint32_t _result_shm_id,
7349             uint32_t _result_shm_offset) {
7350     static_cast<ValueType*>(cmd)->Init(_buffer_id, _count, _type, _offset,
7351                                        _result_shm_id, _result_shm_offset);
7352     return NextCmdAddress<ValueType>(cmd);
7353   }
7354
7355   gpu::CommandHeader header;
7356   uint32_t buffer_id;
7357   int32_t count;
7358   uint32_t type;
7359   uint32_t offset;
7360   uint32_t result_shm_id;
7361   uint32_t result_shm_offset;
7362 };
7363
7364 COMPILE_ASSERT(sizeof(GetMaxValueInBufferCHROMIUM) == 28,
7365                Sizeof_GetMaxValueInBufferCHROMIUM_is_not_28);
7366 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, header) == 0,
7367                OffsetOf_GetMaxValueInBufferCHROMIUM_header_not_0);
7368 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, buffer_id) == 4,
7369                OffsetOf_GetMaxValueInBufferCHROMIUM_buffer_id_not_4);
7370 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, count) == 8,
7371                OffsetOf_GetMaxValueInBufferCHROMIUM_count_not_8);
7372 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, type) == 12,
7373                OffsetOf_GetMaxValueInBufferCHROMIUM_type_not_12);
7374 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, offset) == 16,
7375                OffsetOf_GetMaxValueInBufferCHROMIUM_offset_not_16);
7376 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, result_shm_id) == 20,
7377                OffsetOf_GetMaxValueInBufferCHROMIUM_result_shm_id_not_20);
7378 COMPILE_ASSERT(offsetof(GetMaxValueInBufferCHROMIUM, result_shm_offset) == 24,
7379                OffsetOf_GetMaxValueInBufferCHROMIUM_result_shm_offset_not_24);
7380
7381 struct EnableFeatureCHROMIUM {
7382   typedef EnableFeatureCHROMIUM ValueType;
7383   static const CommandId kCmdId = kEnableFeatureCHROMIUM;
7384   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7385   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7386
7387   typedef GLint Result;
7388
7389   static uint32_t ComputeSize() {
7390     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7391   }
7392
7393   void SetHeader() { header.SetCmd<ValueType>(); }
7394
7395   void Init(GLuint _bucket_id,
7396             uint32_t _result_shm_id,
7397             uint32_t _result_shm_offset) {
7398     SetHeader();
7399     bucket_id = _bucket_id;
7400     result_shm_id = _result_shm_id;
7401     result_shm_offset = _result_shm_offset;
7402   }
7403
7404   void* Set(void* cmd,
7405             GLuint _bucket_id,
7406             uint32_t _result_shm_id,
7407             uint32_t _result_shm_offset) {
7408     static_cast<ValueType*>(cmd)
7409         ->Init(_bucket_id, _result_shm_id, _result_shm_offset);
7410     return NextCmdAddress<ValueType>(cmd);
7411   }
7412
7413   gpu::CommandHeader header;
7414   uint32_t bucket_id;
7415   uint32_t result_shm_id;
7416   uint32_t result_shm_offset;
7417 };
7418
7419 COMPILE_ASSERT(sizeof(EnableFeatureCHROMIUM) == 16,
7420                Sizeof_EnableFeatureCHROMIUM_is_not_16);
7421 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, header) == 0,
7422                OffsetOf_EnableFeatureCHROMIUM_header_not_0);
7423 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, bucket_id) == 4,
7424                OffsetOf_EnableFeatureCHROMIUM_bucket_id_not_4);
7425 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, result_shm_id) == 8,
7426                OffsetOf_EnableFeatureCHROMIUM_result_shm_id_not_8);
7427 COMPILE_ASSERT(offsetof(EnableFeatureCHROMIUM, result_shm_offset) == 12,
7428                OffsetOf_EnableFeatureCHROMIUM_result_shm_offset_not_12);
7429
7430 struct ResizeCHROMIUM {
7431   typedef ResizeCHROMIUM ValueType;
7432   static const CommandId kCmdId = kResizeCHROMIUM;
7433   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7434   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7435
7436   static uint32_t ComputeSize() {
7437     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7438   }
7439
7440   void SetHeader() { header.SetCmd<ValueType>(); }
7441
7442   void Init(GLuint _width, GLuint _height, GLfloat _scale_factor) {
7443     SetHeader();
7444     width = _width;
7445     height = _height;
7446     scale_factor = _scale_factor;
7447   }
7448
7449   void* Set(void* cmd, GLuint _width, GLuint _height, GLfloat _scale_factor) {
7450     static_cast<ValueType*>(cmd)->Init(_width, _height, _scale_factor);
7451     return NextCmdAddress<ValueType>(cmd);
7452   }
7453
7454   gpu::CommandHeader header;
7455   uint32_t width;
7456   uint32_t height;
7457   float scale_factor;
7458 };
7459
7460 COMPILE_ASSERT(sizeof(ResizeCHROMIUM) == 16, Sizeof_ResizeCHROMIUM_is_not_16);
7461 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, header) == 0,
7462                OffsetOf_ResizeCHROMIUM_header_not_0);
7463 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, width) == 4,
7464                OffsetOf_ResizeCHROMIUM_width_not_4);
7465 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, height) == 8,
7466                OffsetOf_ResizeCHROMIUM_height_not_8);
7467 COMPILE_ASSERT(offsetof(ResizeCHROMIUM, scale_factor) == 12,
7468                OffsetOf_ResizeCHROMIUM_scale_factor_not_12);
7469
7470 struct GetRequestableExtensionsCHROMIUM {
7471   typedef GetRequestableExtensionsCHROMIUM ValueType;
7472   static const CommandId kCmdId = kGetRequestableExtensionsCHROMIUM;
7473   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7474   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7475
7476   static uint32_t ComputeSize() {
7477     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7478   }
7479
7480   void SetHeader() { header.SetCmd<ValueType>(); }
7481
7482   void Init(uint32_t _bucket_id) {
7483     SetHeader();
7484     bucket_id = _bucket_id;
7485   }
7486
7487   void* Set(void* cmd, uint32_t _bucket_id) {
7488     static_cast<ValueType*>(cmd)->Init(_bucket_id);
7489     return NextCmdAddress<ValueType>(cmd);
7490   }
7491
7492   gpu::CommandHeader header;
7493   uint32_t bucket_id;
7494 };
7495
7496 COMPILE_ASSERT(sizeof(GetRequestableExtensionsCHROMIUM) == 8,
7497                Sizeof_GetRequestableExtensionsCHROMIUM_is_not_8);
7498 COMPILE_ASSERT(offsetof(GetRequestableExtensionsCHROMIUM, header) == 0,
7499                OffsetOf_GetRequestableExtensionsCHROMIUM_header_not_0);
7500 COMPILE_ASSERT(offsetof(GetRequestableExtensionsCHROMIUM, bucket_id) == 4,
7501                OffsetOf_GetRequestableExtensionsCHROMIUM_bucket_id_not_4);
7502
7503 struct RequestExtensionCHROMIUM {
7504   typedef RequestExtensionCHROMIUM ValueType;
7505   static const CommandId kCmdId = kRequestExtensionCHROMIUM;
7506   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7507   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7508
7509   static uint32_t ComputeSize() {
7510     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7511   }
7512
7513   void SetHeader() { header.SetCmd<ValueType>(); }
7514
7515   void Init(uint32_t _bucket_id) {
7516     SetHeader();
7517     bucket_id = _bucket_id;
7518   }
7519
7520   void* Set(void* cmd, uint32_t _bucket_id) {
7521     static_cast<ValueType*>(cmd)->Init(_bucket_id);
7522     return NextCmdAddress<ValueType>(cmd);
7523   }
7524
7525   gpu::CommandHeader header;
7526   uint32_t bucket_id;
7527 };
7528
7529 COMPILE_ASSERT(sizeof(RequestExtensionCHROMIUM) == 8,
7530                Sizeof_RequestExtensionCHROMIUM_is_not_8);
7531 COMPILE_ASSERT(offsetof(RequestExtensionCHROMIUM, header) == 0,
7532                OffsetOf_RequestExtensionCHROMIUM_header_not_0);
7533 COMPILE_ASSERT(offsetof(RequestExtensionCHROMIUM, bucket_id) == 4,
7534                OffsetOf_RequestExtensionCHROMIUM_bucket_id_not_4);
7535
7536 struct GetMultipleIntegervCHROMIUM {
7537   typedef GetMultipleIntegervCHROMIUM ValueType;
7538   static const CommandId kCmdId = kGetMultipleIntegervCHROMIUM;
7539   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7540   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7541
7542   static uint32_t ComputeSize() {
7543     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7544   }
7545
7546   void SetHeader() { header.SetCmd<ValueType>(); }
7547
7548   void Init(uint32_t _pnames_shm_id,
7549             uint32_t _pnames_shm_offset,
7550             GLuint _count,
7551             uint32_t _results_shm_id,
7552             uint32_t _results_shm_offset,
7553             GLsizeiptr _size) {
7554     SetHeader();
7555     pnames_shm_id = _pnames_shm_id;
7556     pnames_shm_offset = _pnames_shm_offset;
7557     count = _count;
7558     results_shm_id = _results_shm_id;
7559     results_shm_offset = _results_shm_offset;
7560     size = _size;
7561   }
7562
7563   void* Set(void* cmd,
7564             uint32_t _pnames_shm_id,
7565             uint32_t _pnames_shm_offset,
7566             GLuint _count,
7567             uint32_t _results_shm_id,
7568             uint32_t _results_shm_offset,
7569             GLsizeiptr _size) {
7570     static_cast<ValueType*>(cmd)->Init(_pnames_shm_id, _pnames_shm_offset,
7571                                        _count, _results_shm_id,
7572                                        _results_shm_offset, _size);
7573     return NextCmdAddress<ValueType>(cmd);
7574   }
7575
7576   gpu::CommandHeader header;
7577   uint32_t pnames_shm_id;
7578   uint32_t pnames_shm_offset;
7579   uint32_t count;
7580   uint32_t results_shm_id;
7581   uint32_t results_shm_offset;
7582   int32_t size;
7583 };
7584
7585 COMPILE_ASSERT(sizeof(GetMultipleIntegervCHROMIUM) == 28,
7586                Sizeof_GetMultipleIntegervCHROMIUM_is_not_28);
7587 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, header) == 0,
7588                OffsetOf_GetMultipleIntegervCHROMIUM_header_not_0);
7589 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, pnames_shm_id) == 4,
7590                OffsetOf_GetMultipleIntegervCHROMIUM_pnames_shm_id_not_4);
7591 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, pnames_shm_offset) == 8,
7592                OffsetOf_GetMultipleIntegervCHROMIUM_pnames_shm_offset_not_8);
7593 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, count) == 12,
7594                OffsetOf_GetMultipleIntegervCHROMIUM_count_not_12);
7595 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, results_shm_id) == 16,
7596                OffsetOf_GetMultipleIntegervCHROMIUM_results_shm_id_not_16);
7597 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, results_shm_offset) == 20,
7598                OffsetOf_GetMultipleIntegervCHROMIUM_results_shm_offset_not_20);
7599 COMPILE_ASSERT(offsetof(GetMultipleIntegervCHROMIUM, size) == 24,
7600                OffsetOf_GetMultipleIntegervCHROMIUM_size_not_24);
7601
7602 struct GetProgramInfoCHROMIUM {
7603   typedef GetProgramInfoCHROMIUM ValueType;
7604   static const CommandId kCmdId = kGetProgramInfoCHROMIUM;
7605   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7606   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7607
7608   struct Result {
7609     uint32_t link_status;
7610     uint32_t num_attribs;
7611     uint32_t num_uniforms;
7612   };
7613
7614   static uint32_t ComputeSize() {
7615     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7616   }
7617
7618   void SetHeader() { header.SetCmd<ValueType>(); }
7619
7620   void Init(GLuint _program, uint32_t _bucket_id) {
7621     SetHeader();
7622     program = _program;
7623     bucket_id = _bucket_id;
7624   }
7625
7626   void* Set(void* cmd, GLuint _program, uint32_t _bucket_id) {
7627     static_cast<ValueType*>(cmd)->Init(_program, _bucket_id);
7628     return NextCmdAddress<ValueType>(cmd);
7629   }
7630
7631   gpu::CommandHeader header;
7632   uint32_t program;
7633   uint32_t bucket_id;
7634 };
7635
7636 COMPILE_ASSERT(sizeof(GetProgramInfoCHROMIUM) == 12,
7637                Sizeof_GetProgramInfoCHROMIUM_is_not_12);
7638 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, header) == 0,
7639                OffsetOf_GetProgramInfoCHROMIUM_header_not_0);
7640 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, program) == 4,
7641                OffsetOf_GetProgramInfoCHROMIUM_program_not_4);
7642 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM, bucket_id) == 8,
7643                OffsetOf_GetProgramInfoCHROMIUM_bucket_id_not_8);
7644 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, link_status) == 0,
7645                OffsetOf_GetProgramInfoCHROMIUM_Result_link_status_not_0);
7646 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, num_attribs) == 4,
7647                OffsetOf_GetProgramInfoCHROMIUM_Result_num_attribs_not_4);
7648 COMPILE_ASSERT(offsetof(GetProgramInfoCHROMIUM::Result, num_uniforms) == 8,
7649                OffsetOf_GetProgramInfoCHROMIUM_Result_num_uniforms_not_8);
7650
7651 struct GetTranslatedShaderSourceANGLE {
7652   typedef GetTranslatedShaderSourceANGLE ValueType;
7653   static const CommandId kCmdId = kGetTranslatedShaderSourceANGLE;
7654   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7655   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7656
7657   static uint32_t ComputeSize() {
7658     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7659   }
7660
7661   void SetHeader() { header.SetCmd<ValueType>(); }
7662
7663   void Init(GLuint _shader, uint32_t _bucket_id) {
7664     SetHeader();
7665     shader = _shader;
7666     bucket_id = _bucket_id;
7667   }
7668
7669   void* Set(void* cmd, GLuint _shader, uint32_t _bucket_id) {
7670     static_cast<ValueType*>(cmd)->Init(_shader, _bucket_id);
7671     return NextCmdAddress<ValueType>(cmd);
7672   }
7673
7674   gpu::CommandHeader header;
7675   uint32_t shader;
7676   uint32_t bucket_id;
7677 };
7678
7679 COMPILE_ASSERT(sizeof(GetTranslatedShaderSourceANGLE) == 12,
7680                Sizeof_GetTranslatedShaderSourceANGLE_is_not_12);
7681 COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, header) == 0,
7682                OffsetOf_GetTranslatedShaderSourceANGLE_header_not_0);
7683 COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, shader) == 4,
7684                OffsetOf_GetTranslatedShaderSourceANGLE_shader_not_4);
7685 COMPILE_ASSERT(offsetof(GetTranslatedShaderSourceANGLE, bucket_id) == 8,
7686                OffsetOf_GetTranslatedShaderSourceANGLE_bucket_id_not_8);
7687
7688 struct PostSubBufferCHROMIUM {
7689   typedef PostSubBufferCHROMIUM ValueType;
7690   static const CommandId kCmdId = kPostSubBufferCHROMIUM;
7691   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7692   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7693
7694   static uint32_t ComputeSize() {
7695     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7696   }
7697
7698   void SetHeader() { header.SetCmd<ValueType>(); }
7699
7700   void Init(GLint _x, GLint _y, GLint _width, GLint _height) {
7701     SetHeader();
7702     x = _x;
7703     y = _y;
7704     width = _width;
7705     height = _height;
7706   }
7707
7708   void* Set(void* cmd, GLint _x, GLint _y, GLint _width, GLint _height) {
7709     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
7710     return NextCmdAddress<ValueType>(cmd);
7711   }
7712
7713   gpu::CommandHeader header;
7714   int32_t x;
7715   int32_t y;
7716   int32_t width;
7717   int32_t height;
7718 };
7719
7720 COMPILE_ASSERT(sizeof(PostSubBufferCHROMIUM) == 20,
7721                Sizeof_PostSubBufferCHROMIUM_is_not_20);
7722 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, header) == 0,
7723                OffsetOf_PostSubBufferCHROMIUM_header_not_0);
7724 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, x) == 4,
7725                OffsetOf_PostSubBufferCHROMIUM_x_not_4);
7726 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, y) == 8,
7727                OffsetOf_PostSubBufferCHROMIUM_y_not_8);
7728 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, width) == 12,
7729                OffsetOf_PostSubBufferCHROMIUM_width_not_12);
7730 COMPILE_ASSERT(offsetof(PostSubBufferCHROMIUM, height) == 16,
7731                OffsetOf_PostSubBufferCHROMIUM_height_not_16);
7732
7733 struct TexImageIOSurface2DCHROMIUM {
7734   typedef TexImageIOSurface2DCHROMIUM ValueType;
7735   static const CommandId kCmdId = kTexImageIOSurface2DCHROMIUM;
7736   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7737   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7738
7739   static uint32_t ComputeSize() {
7740     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7741   }
7742
7743   void SetHeader() { header.SetCmd<ValueType>(); }
7744
7745   void Init(GLenum _target,
7746             GLsizei _width,
7747             GLsizei _height,
7748             GLuint _ioSurfaceId,
7749             GLuint _plane) {
7750     SetHeader();
7751     target = _target;
7752     width = _width;
7753     height = _height;
7754     ioSurfaceId = _ioSurfaceId;
7755     plane = _plane;
7756   }
7757
7758   void* Set(void* cmd,
7759             GLenum _target,
7760             GLsizei _width,
7761             GLsizei _height,
7762             GLuint _ioSurfaceId,
7763             GLuint _plane) {
7764     static_cast<ValueType*>(cmd)
7765         ->Init(_target, _width, _height, _ioSurfaceId, _plane);
7766     return NextCmdAddress<ValueType>(cmd);
7767   }
7768
7769   gpu::CommandHeader header;
7770   uint32_t target;
7771   int32_t width;
7772   int32_t height;
7773   uint32_t ioSurfaceId;
7774   uint32_t plane;
7775 };
7776
7777 COMPILE_ASSERT(sizeof(TexImageIOSurface2DCHROMIUM) == 24,
7778                Sizeof_TexImageIOSurface2DCHROMIUM_is_not_24);
7779 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, header) == 0,
7780                OffsetOf_TexImageIOSurface2DCHROMIUM_header_not_0);
7781 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, target) == 4,
7782                OffsetOf_TexImageIOSurface2DCHROMIUM_target_not_4);
7783 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, width) == 8,
7784                OffsetOf_TexImageIOSurface2DCHROMIUM_width_not_8);
7785 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, height) == 12,
7786                OffsetOf_TexImageIOSurface2DCHROMIUM_height_not_12);
7787 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, ioSurfaceId) == 16,
7788                OffsetOf_TexImageIOSurface2DCHROMIUM_ioSurfaceId_not_16);
7789 COMPILE_ASSERT(offsetof(TexImageIOSurface2DCHROMIUM, plane) == 20,
7790                OffsetOf_TexImageIOSurface2DCHROMIUM_plane_not_20);
7791
7792 struct CopyTextureCHROMIUM {
7793   typedef CopyTextureCHROMIUM ValueType;
7794   static const CommandId kCmdId = kCopyTextureCHROMIUM;
7795   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7796   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7797
7798   static uint32_t ComputeSize() {
7799     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7800   }
7801
7802   void SetHeader() { header.SetCmd<ValueType>(); }
7803
7804   void Init(GLenum _target,
7805             GLenum _source_id,
7806             GLenum _dest_id,
7807             GLint _level,
7808             GLint _internalformat,
7809             GLenum _dest_type) {
7810     SetHeader();
7811     target = _target;
7812     source_id = _source_id;
7813     dest_id = _dest_id;
7814     level = _level;
7815     internalformat = _internalformat;
7816     dest_type = _dest_type;
7817   }
7818
7819   void* Set(void* cmd,
7820             GLenum _target,
7821             GLenum _source_id,
7822             GLenum _dest_id,
7823             GLint _level,
7824             GLint _internalformat,
7825             GLenum _dest_type) {
7826     static_cast<ValueType*>(cmd)->Init(_target, _source_id, _dest_id, _level,
7827                                        _internalformat, _dest_type);
7828     return NextCmdAddress<ValueType>(cmd);
7829   }
7830
7831   gpu::CommandHeader header;
7832   uint32_t target;
7833   uint32_t source_id;
7834   uint32_t dest_id;
7835   int32_t level;
7836   int32_t internalformat;
7837   uint32_t dest_type;
7838 };
7839
7840 COMPILE_ASSERT(sizeof(CopyTextureCHROMIUM) == 28,
7841                Sizeof_CopyTextureCHROMIUM_is_not_28);
7842 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, header) == 0,
7843                OffsetOf_CopyTextureCHROMIUM_header_not_0);
7844 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, target) == 4,
7845                OffsetOf_CopyTextureCHROMIUM_target_not_4);
7846 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, source_id) == 8,
7847                OffsetOf_CopyTextureCHROMIUM_source_id_not_8);
7848 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, dest_id) == 12,
7849                OffsetOf_CopyTextureCHROMIUM_dest_id_not_12);
7850 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, level) == 16,
7851                OffsetOf_CopyTextureCHROMIUM_level_not_16);
7852 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, internalformat) == 20,
7853                OffsetOf_CopyTextureCHROMIUM_internalformat_not_20);
7854 COMPILE_ASSERT(offsetof(CopyTextureCHROMIUM, dest_type) == 24,
7855                OffsetOf_CopyTextureCHROMIUM_dest_type_not_24);
7856
7857 struct DrawArraysInstancedANGLE {
7858   typedef DrawArraysInstancedANGLE ValueType;
7859   static const CommandId kCmdId = kDrawArraysInstancedANGLE;
7860   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7861   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7862
7863   static uint32_t ComputeSize() {
7864     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7865   }
7866
7867   void SetHeader() { header.SetCmd<ValueType>(); }
7868
7869   void Init(GLenum _mode, GLint _first, GLsizei _count, GLsizei _primcount) {
7870     SetHeader();
7871     mode = _mode;
7872     first = _first;
7873     count = _count;
7874     primcount = _primcount;
7875   }
7876
7877   void* Set(void* cmd,
7878             GLenum _mode,
7879             GLint _first,
7880             GLsizei _count,
7881             GLsizei _primcount) {
7882     static_cast<ValueType*>(cmd)->Init(_mode, _first, _count, _primcount);
7883     return NextCmdAddress<ValueType>(cmd);
7884   }
7885
7886   gpu::CommandHeader header;
7887   uint32_t mode;
7888   int32_t first;
7889   int32_t count;
7890   int32_t primcount;
7891 };
7892
7893 COMPILE_ASSERT(sizeof(DrawArraysInstancedANGLE) == 20,
7894                Sizeof_DrawArraysInstancedANGLE_is_not_20);
7895 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, header) == 0,
7896                OffsetOf_DrawArraysInstancedANGLE_header_not_0);
7897 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, mode) == 4,
7898                OffsetOf_DrawArraysInstancedANGLE_mode_not_4);
7899 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, first) == 8,
7900                OffsetOf_DrawArraysInstancedANGLE_first_not_8);
7901 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, count) == 12,
7902                OffsetOf_DrawArraysInstancedANGLE_count_not_12);
7903 COMPILE_ASSERT(offsetof(DrawArraysInstancedANGLE, primcount) == 16,
7904                OffsetOf_DrawArraysInstancedANGLE_primcount_not_16);
7905
7906 struct DrawElementsInstancedANGLE {
7907   typedef DrawElementsInstancedANGLE ValueType;
7908   static const CommandId kCmdId = kDrawElementsInstancedANGLE;
7909   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7910   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7911
7912   static uint32_t ComputeSize() {
7913     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7914   }
7915
7916   void SetHeader() { header.SetCmd<ValueType>(); }
7917
7918   void Init(GLenum _mode,
7919             GLsizei _count,
7920             GLenum _type,
7921             GLuint _index_offset,
7922             GLsizei _primcount) {
7923     SetHeader();
7924     mode = _mode;
7925     count = _count;
7926     type = _type;
7927     index_offset = _index_offset;
7928     primcount = _primcount;
7929   }
7930
7931   void* Set(void* cmd,
7932             GLenum _mode,
7933             GLsizei _count,
7934             GLenum _type,
7935             GLuint _index_offset,
7936             GLsizei _primcount) {
7937     static_cast<ValueType*>(cmd)
7938         ->Init(_mode, _count, _type, _index_offset, _primcount);
7939     return NextCmdAddress<ValueType>(cmd);
7940   }
7941
7942   gpu::CommandHeader header;
7943   uint32_t mode;
7944   int32_t count;
7945   uint32_t type;
7946   uint32_t index_offset;
7947   int32_t primcount;
7948 };
7949
7950 COMPILE_ASSERT(sizeof(DrawElementsInstancedANGLE) == 24,
7951                Sizeof_DrawElementsInstancedANGLE_is_not_24);
7952 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, header) == 0,
7953                OffsetOf_DrawElementsInstancedANGLE_header_not_0);
7954 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, mode) == 4,
7955                OffsetOf_DrawElementsInstancedANGLE_mode_not_4);
7956 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, count) == 8,
7957                OffsetOf_DrawElementsInstancedANGLE_count_not_8);
7958 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, type) == 12,
7959                OffsetOf_DrawElementsInstancedANGLE_type_not_12);
7960 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, index_offset) == 16,
7961                OffsetOf_DrawElementsInstancedANGLE_index_offset_not_16);
7962 COMPILE_ASSERT(offsetof(DrawElementsInstancedANGLE, primcount) == 20,
7963                OffsetOf_DrawElementsInstancedANGLE_primcount_not_20);
7964
7965 struct VertexAttribDivisorANGLE {
7966   typedef VertexAttribDivisorANGLE ValueType;
7967   static const CommandId kCmdId = kVertexAttribDivisorANGLE;
7968   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
7969   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
7970
7971   static uint32_t ComputeSize() {
7972     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
7973   }
7974
7975   void SetHeader() { header.SetCmd<ValueType>(); }
7976
7977   void Init(GLuint _index, GLuint _divisor) {
7978     SetHeader();
7979     index = _index;
7980     divisor = _divisor;
7981   }
7982
7983   void* Set(void* cmd, GLuint _index, GLuint _divisor) {
7984     static_cast<ValueType*>(cmd)->Init(_index, _divisor);
7985     return NextCmdAddress<ValueType>(cmd);
7986   }
7987
7988   gpu::CommandHeader header;
7989   uint32_t index;
7990   uint32_t divisor;
7991 };
7992
7993 COMPILE_ASSERT(sizeof(VertexAttribDivisorANGLE) == 12,
7994                Sizeof_VertexAttribDivisorANGLE_is_not_12);
7995 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, header) == 0,
7996                OffsetOf_VertexAttribDivisorANGLE_header_not_0);
7997 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, index) == 4,
7998                OffsetOf_VertexAttribDivisorANGLE_index_not_4);
7999 COMPILE_ASSERT(offsetof(VertexAttribDivisorANGLE, divisor) == 8,
8000                OffsetOf_VertexAttribDivisorANGLE_divisor_not_8);
8001
8002 struct ProduceTextureCHROMIUMImmediate {
8003   typedef ProduceTextureCHROMIUMImmediate ValueType;
8004   static const CommandId kCmdId = kProduceTextureCHROMIUMImmediate;
8005   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8006   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
8007
8008   static uint32_t ComputeDataSize() {
8009     return static_cast<uint32_t>(sizeof(GLbyte) * 64);  // NOLINT
8010   }
8011
8012   static uint32_t ComputeSize() {
8013     return static_cast<uint32_t>(sizeof(ValueType) +
8014                                  ComputeDataSize());  // NOLINT
8015   }
8016
8017   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
8018
8019   void Init(GLenum _target, const GLbyte* _mailbox) {
8020     SetHeader();
8021     target = _target;
8022     memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize());
8023   }
8024
8025   void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) {
8026     static_cast<ValueType*>(cmd)->Init(_target, _mailbox);
8027     const uint32_t size = ComputeSize();
8028     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
8029   }
8030
8031   gpu::CommandHeader header;
8032   uint32_t target;
8033 };
8034
8035 COMPILE_ASSERT(sizeof(ProduceTextureCHROMIUMImmediate) == 8,
8036                Sizeof_ProduceTextureCHROMIUMImmediate_is_not_8);
8037 COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, header) == 0,
8038                OffsetOf_ProduceTextureCHROMIUMImmediate_header_not_0);
8039 COMPILE_ASSERT(offsetof(ProduceTextureCHROMIUMImmediate, target) == 4,
8040                OffsetOf_ProduceTextureCHROMIUMImmediate_target_not_4);
8041
8042 struct ProduceTextureDirectCHROMIUMImmediate {
8043   typedef ProduceTextureDirectCHROMIUMImmediate ValueType;
8044   static const CommandId kCmdId = kProduceTextureDirectCHROMIUMImmediate;
8045   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8046   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
8047
8048   static uint32_t ComputeDataSize() {
8049     return static_cast<uint32_t>(sizeof(GLbyte) * 64);  // NOLINT
8050   }
8051
8052   static uint32_t ComputeSize() {
8053     return static_cast<uint32_t>(sizeof(ValueType) +
8054                                  ComputeDataSize());  // NOLINT
8055   }
8056
8057   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
8058
8059   void Init(GLuint _texture, GLenum _target, const GLbyte* _mailbox) {
8060     SetHeader();
8061     texture = _texture;
8062     target = _target;
8063     memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize());
8064   }
8065
8066   void* Set(void* cmd,
8067             GLuint _texture,
8068             GLenum _target,
8069             const GLbyte* _mailbox) {
8070     static_cast<ValueType*>(cmd)->Init(_texture, _target, _mailbox);
8071     const uint32_t size = ComputeSize();
8072     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
8073   }
8074
8075   gpu::CommandHeader header;
8076   uint32_t texture;
8077   uint32_t target;
8078 };
8079
8080 COMPILE_ASSERT(sizeof(ProduceTextureDirectCHROMIUMImmediate) == 12,
8081                Sizeof_ProduceTextureDirectCHROMIUMImmediate_is_not_12);
8082 COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, header) == 0,
8083                OffsetOf_ProduceTextureDirectCHROMIUMImmediate_header_not_0);
8084 COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, texture) == 4,
8085                OffsetOf_ProduceTextureDirectCHROMIUMImmediate_texture_not_4);
8086 COMPILE_ASSERT(offsetof(ProduceTextureDirectCHROMIUMImmediate, target) == 8,
8087                OffsetOf_ProduceTextureDirectCHROMIUMImmediate_target_not_8);
8088
8089 struct ConsumeTextureCHROMIUMImmediate {
8090   typedef ConsumeTextureCHROMIUMImmediate ValueType;
8091   static const CommandId kCmdId = kConsumeTextureCHROMIUMImmediate;
8092   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8093   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
8094
8095   static uint32_t ComputeDataSize() {
8096     return static_cast<uint32_t>(sizeof(GLbyte) * 64);  // NOLINT
8097   }
8098
8099   static uint32_t ComputeSize() {
8100     return static_cast<uint32_t>(sizeof(ValueType) +
8101                                  ComputeDataSize());  // NOLINT
8102   }
8103
8104   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
8105
8106   void Init(GLenum _target, const GLbyte* _mailbox) {
8107     SetHeader();
8108     target = _target;
8109     memcpy(ImmediateDataAddress(this), _mailbox, ComputeDataSize());
8110   }
8111
8112   void* Set(void* cmd, GLenum _target, const GLbyte* _mailbox) {
8113     static_cast<ValueType*>(cmd)->Init(_target, _mailbox);
8114     const uint32_t size = ComputeSize();
8115     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
8116   }
8117
8118   gpu::CommandHeader header;
8119   uint32_t target;
8120 };
8121
8122 COMPILE_ASSERT(sizeof(ConsumeTextureCHROMIUMImmediate) == 8,
8123                Sizeof_ConsumeTextureCHROMIUMImmediate_is_not_8);
8124 COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, header) == 0,
8125                OffsetOf_ConsumeTextureCHROMIUMImmediate_header_not_0);
8126 COMPILE_ASSERT(offsetof(ConsumeTextureCHROMIUMImmediate, target) == 4,
8127                OffsetOf_ConsumeTextureCHROMIUMImmediate_target_not_4);
8128
8129 struct BindUniformLocationCHROMIUMBucket {
8130   typedef BindUniformLocationCHROMIUMBucket ValueType;
8131   static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket;
8132   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8133   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8134
8135   static uint32_t ComputeSize() {
8136     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8137   }
8138
8139   void SetHeader() { header.SetCmd<ValueType>(); }
8140
8141   void Init(GLuint _program, GLint _location, uint32_t _name_bucket_id) {
8142     SetHeader();
8143     program = _program;
8144     location = _location;
8145     name_bucket_id = _name_bucket_id;
8146   }
8147
8148   void* Set(void* cmd,
8149             GLuint _program,
8150             GLint _location,
8151             uint32_t _name_bucket_id) {
8152     static_cast<ValueType*>(cmd)->Init(_program, _location, _name_bucket_id);
8153     return NextCmdAddress<ValueType>(cmd);
8154   }
8155
8156   gpu::CommandHeader header;
8157   uint32_t program;
8158   int32_t location;
8159   uint32_t name_bucket_id;
8160 };
8161
8162 COMPILE_ASSERT(sizeof(BindUniformLocationCHROMIUMBucket) == 16,
8163                Sizeof_BindUniformLocationCHROMIUMBucket_is_not_16);
8164 COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, header) == 0,
8165                OffsetOf_BindUniformLocationCHROMIUMBucket_header_not_0);
8166 COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, program) == 4,
8167                OffsetOf_BindUniformLocationCHROMIUMBucket_program_not_4);
8168 COMPILE_ASSERT(offsetof(BindUniformLocationCHROMIUMBucket, location) == 8,
8169                OffsetOf_BindUniformLocationCHROMIUMBucket_location_not_8);
8170 COMPILE_ASSERT(
8171     offsetof(BindUniformLocationCHROMIUMBucket, name_bucket_id) == 12,
8172     OffsetOf_BindUniformLocationCHROMIUMBucket_name_bucket_id_not_12);
8173
8174 struct GenValuebuffersCHROMIUMImmediate {
8175   typedef GenValuebuffersCHROMIUMImmediate ValueType;
8176   static const CommandId kCmdId = kGenValuebuffersCHROMIUMImmediate;
8177   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8178   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8179
8180   static uint32_t ComputeDataSize(GLsizei n) {
8181     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
8182   }
8183
8184   static uint32_t ComputeSize(GLsizei n) {
8185     return static_cast<uint32_t>(sizeof(ValueType) +
8186                                  ComputeDataSize(n));  // NOLINT
8187   }
8188
8189   void SetHeader(GLsizei n) {
8190     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
8191   }
8192
8193   void Init(GLsizei _n, GLuint* _buffers) {
8194     SetHeader(_n);
8195     n = _n;
8196     memcpy(ImmediateDataAddress(this), _buffers, ComputeDataSize(_n));
8197   }
8198
8199   void* Set(void* cmd, GLsizei _n, GLuint* _buffers) {
8200     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
8201     const uint32_t size = ComputeSize(_n);
8202     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
8203   }
8204
8205   gpu::CommandHeader header;
8206   int32_t n;
8207 };
8208
8209 COMPILE_ASSERT(sizeof(GenValuebuffersCHROMIUMImmediate) == 8,
8210                Sizeof_GenValuebuffersCHROMIUMImmediate_is_not_8);
8211 COMPILE_ASSERT(offsetof(GenValuebuffersCHROMIUMImmediate, header) == 0,
8212                OffsetOf_GenValuebuffersCHROMIUMImmediate_header_not_0);
8213 COMPILE_ASSERT(offsetof(GenValuebuffersCHROMIUMImmediate, n) == 4,
8214                OffsetOf_GenValuebuffersCHROMIUMImmediate_n_not_4);
8215
8216 struct DeleteValuebuffersCHROMIUMImmediate {
8217   typedef DeleteValuebuffersCHROMIUMImmediate ValueType;
8218   static const CommandId kCmdId = kDeleteValuebuffersCHROMIUMImmediate;
8219   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8220   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8221
8222   static uint32_t ComputeDataSize(GLsizei n) {
8223     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
8224   }
8225
8226   static uint32_t ComputeSize(GLsizei n) {
8227     return static_cast<uint32_t>(sizeof(ValueType) +
8228                                  ComputeDataSize(n));  // NOLINT
8229   }
8230
8231   void SetHeader(GLsizei n) {
8232     header.SetCmdByTotalSize<ValueType>(ComputeSize(n));
8233   }
8234
8235   void Init(GLsizei _n, const GLuint* _valuebuffers) {
8236     SetHeader(_n);
8237     n = _n;
8238     memcpy(ImmediateDataAddress(this), _valuebuffers, ComputeDataSize(_n));
8239   }
8240
8241   void* Set(void* cmd, GLsizei _n, const GLuint* _valuebuffers) {
8242     static_cast<ValueType*>(cmd)->Init(_n, _valuebuffers);
8243     const uint32_t size = ComputeSize(_n);
8244     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
8245   }
8246
8247   gpu::CommandHeader header;
8248   int32_t n;
8249 };
8250
8251 COMPILE_ASSERT(sizeof(DeleteValuebuffersCHROMIUMImmediate) == 8,
8252                Sizeof_DeleteValuebuffersCHROMIUMImmediate_is_not_8);
8253 COMPILE_ASSERT(offsetof(DeleteValuebuffersCHROMIUMImmediate, header) == 0,
8254                OffsetOf_DeleteValuebuffersCHROMIUMImmediate_header_not_0);
8255 COMPILE_ASSERT(offsetof(DeleteValuebuffersCHROMIUMImmediate, n) == 4,
8256                OffsetOf_DeleteValuebuffersCHROMIUMImmediate_n_not_4);
8257
8258 struct IsValuebufferCHROMIUM {
8259   typedef IsValuebufferCHROMIUM ValueType;
8260   static const CommandId kCmdId = kIsValuebufferCHROMIUM;
8261   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8262   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8263
8264   typedef uint32_t Result;
8265
8266   static uint32_t ComputeSize() {
8267     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8268   }
8269
8270   void SetHeader() { header.SetCmd<ValueType>(); }
8271
8272   void Init(GLuint _valuebuffer,
8273             uint32_t _result_shm_id,
8274             uint32_t _result_shm_offset) {
8275     SetHeader();
8276     valuebuffer = _valuebuffer;
8277     result_shm_id = _result_shm_id;
8278     result_shm_offset = _result_shm_offset;
8279   }
8280
8281   void* Set(void* cmd,
8282             GLuint _valuebuffer,
8283             uint32_t _result_shm_id,
8284             uint32_t _result_shm_offset) {
8285     static_cast<ValueType*>(cmd)
8286         ->Init(_valuebuffer, _result_shm_id, _result_shm_offset);
8287     return NextCmdAddress<ValueType>(cmd);
8288   }
8289
8290   gpu::CommandHeader header;
8291   uint32_t valuebuffer;
8292   uint32_t result_shm_id;
8293   uint32_t result_shm_offset;
8294 };
8295
8296 COMPILE_ASSERT(sizeof(IsValuebufferCHROMIUM) == 16,
8297                Sizeof_IsValuebufferCHROMIUM_is_not_16);
8298 COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, header) == 0,
8299                OffsetOf_IsValuebufferCHROMIUM_header_not_0);
8300 COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, valuebuffer) == 4,
8301                OffsetOf_IsValuebufferCHROMIUM_valuebuffer_not_4);
8302 COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, result_shm_id) == 8,
8303                OffsetOf_IsValuebufferCHROMIUM_result_shm_id_not_8);
8304 COMPILE_ASSERT(offsetof(IsValuebufferCHROMIUM, result_shm_offset) == 12,
8305                OffsetOf_IsValuebufferCHROMIUM_result_shm_offset_not_12);
8306
8307 struct BindValuebufferCHROMIUM {
8308   typedef BindValuebufferCHROMIUM ValueType;
8309   static const CommandId kCmdId = kBindValuebufferCHROMIUM;
8310   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8311   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8312
8313   static uint32_t ComputeSize() {
8314     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8315   }
8316
8317   void SetHeader() { header.SetCmd<ValueType>(); }
8318
8319   void Init(GLenum _target, GLuint _valuebuffer) {
8320     SetHeader();
8321     target = _target;
8322     valuebuffer = _valuebuffer;
8323   }
8324
8325   void* Set(void* cmd, GLenum _target, GLuint _valuebuffer) {
8326     static_cast<ValueType*>(cmd)->Init(_target, _valuebuffer);
8327     return NextCmdAddress<ValueType>(cmd);
8328   }
8329
8330   gpu::CommandHeader header;
8331   uint32_t target;
8332   uint32_t valuebuffer;
8333 };
8334
8335 COMPILE_ASSERT(sizeof(BindValuebufferCHROMIUM) == 12,
8336                Sizeof_BindValuebufferCHROMIUM_is_not_12);
8337 COMPILE_ASSERT(offsetof(BindValuebufferCHROMIUM, header) == 0,
8338                OffsetOf_BindValuebufferCHROMIUM_header_not_0);
8339 COMPILE_ASSERT(offsetof(BindValuebufferCHROMIUM, target) == 4,
8340                OffsetOf_BindValuebufferCHROMIUM_target_not_4);
8341 COMPILE_ASSERT(offsetof(BindValuebufferCHROMIUM, valuebuffer) == 8,
8342                OffsetOf_BindValuebufferCHROMIUM_valuebuffer_not_8);
8343
8344 struct SubscribeValueCHROMIUM {
8345   typedef SubscribeValueCHROMIUM ValueType;
8346   static const CommandId kCmdId = kSubscribeValueCHROMIUM;
8347   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8348   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8349
8350   static uint32_t ComputeSize() {
8351     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8352   }
8353
8354   void SetHeader() { header.SetCmd<ValueType>(); }
8355
8356   void Init(GLenum _target, GLenum _subscription) {
8357     SetHeader();
8358     target = _target;
8359     subscription = _subscription;
8360   }
8361
8362   void* Set(void* cmd, GLenum _target, GLenum _subscription) {
8363     static_cast<ValueType*>(cmd)->Init(_target, _subscription);
8364     return NextCmdAddress<ValueType>(cmd);
8365   }
8366
8367   gpu::CommandHeader header;
8368   uint32_t target;
8369   uint32_t subscription;
8370 };
8371
8372 COMPILE_ASSERT(sizeof(SubscribeValueCHROMIUM) == 12,
8373                Sizeof_SubscribeValueCHROMIUM_is_not_12);
8374 COMPILE_ASSERT(offsetof(SubscribeValueCHROMIUM, header) == 0,
8375                OffsetOf_SubscribeValueCHROMIUM_header_not_0);
8376 COMPILE_ASSERT(offsetof(SubscribeValueCHROMIUM, target) == 4,
8377                OffsetOf_SubscribeValueCHROMIUM_target_not_4);
8378 COMPILE_ASSERT(offsetof(SubscribeValueCHROMIUM, subscription) == 8,
8379                OffsetOf_SubscribeValueCHROMIUM_subscription_not_8);
8380
8381 struct PopulateSubscribedValuesCHROMIUM {
8382   typedef PopulateSubscribedValuesCHROMIUM ValueType;
8383   static const CommandId kCmdId = kPopulateSubscribedValuesCHROMIUM;
8384   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8385   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8386
8387   static uint32_t ComputeSize() {
8388     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8389   }
8390
8391   void SetHeader() { header.SetCmd<ValueType>(); }
8392
8393   void Init(GLenum _target) {
8394     SetHeader();
8395     target = _target;
8396   }
8397
8398   void* Set(void* cmd, GLenum _target) {
8399     static_cast<ValueType*>(cmd)->Init(_target);
8400     return NextCmdAddress<ValueType>(cmd);
8401   }
8402
8403   gpu::CommandHeader header;
8404   uint32_t target;
8405 };
8406
8407 COMPILE_ASSERT(sizeof(PopulateSubscribedValuesCHROMIUM) == 8,
8408                Sizeof_PopulateSubscribedValuesCHROMIUM_is_not_8);
8409 COMPILE_ASSERT(offsetof(PopulateSubscribedValuesCHROMIUM, header) == 0,
8410                OffsetOf_PopulateSubscribedValuesCHROMIUM_header_not_0);
8411 COMPILE_ASSERT(offsetof(PopulateSubscribedValuesCHROMIUM, target) == 4,
8412                OffsetOf_PopulateSubscribedValuesCHROMIUM_target_not_4);
8413
8414 struct UniformValuebufferCHROMIUM {
8415   typedef UniformValuebufferCHROMIUM ValueType;
8416   static const CommandId kCmdId = kUniformValuebufferCHROMIUM;
8417   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8418   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8419
8420   static uint32_t ComputeSize() {
8421     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8422   }
8423
8424   void SetHeader() { header.SetCmd<ValueType>(); }
8425
8426   void Init(GLint _location, GLenum _target, GLenum _subscription) {
8427     SetHeader();
8428     location = _location;
8429     target = _target;
8430     subscription = _subscription;
8431   }
8432
8433   void* Set(void* cmd, GLint _location, GLenum _target, GLenum _subscription) {
8434     static_cast<ValueType*>(cmd)->Init(_location, _target, _subscription);
8435     return NextCmdAddress<ValueType>(cmd);
8436   }
8437
8438   gpu::CommandHeader header;
8439   int32_t location;
8440   uint32_t target;
8441   uint32_t subscription;
8442 };
8443
8444 COMPILE_ASSERT(sizeof(UniformValuebufferCHROMIUM) == 16,
8445                Sizeof_UniformValuebufferCHROMIUM_is_not_16);
8446 COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, header) == 0,
8447                OffsetOf_UniformValuebufferCHROMIUM_header_not_0);
8448 COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, location) == 4,
8449                OffsetOf_UniformValuebufferCHROMIUM_location_not_4);
8450 COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, target) == 8,
8451                OffsetOf_UniformValuebufferCHROMIUM_target_not_8);
8452 COMPILE_ASSERT(offsetof(UniformValuebufferCHROMIUM, subscription) == 12,
8453                OffsetOf_UniformValuebufferCHROMIUM_subscription_not_12);
8454
8455 struct BindTexImage2DCHROMIUM {
8456   typedef BindTexImage2DCHROMIUM ValueType;
8457   static const CommandId kCmdId = kBindTexImage2DCHROMIUM;
8458   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8459   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8460
8461   static uint32_t ComputeSize() {
8462     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8463   }
8464
8465   void SetHeader() { header.SetCmd<ValueType>(); }
8466
8467   void Init(GLenum _target, GLint _imageId) {
8468     SetHeader();
8469     target = _target;
8470     imageId = _imageId;
8471   }
8472
8473   void* Set(void* cmd, GLenum _target, GLint _imageId) {
8474     static_cast<ValueType*>(cmd)->Init(_target, _imageId);
8475     return NextCmdAddress<ValueType>(cmd);
8476   }
8477
8478   gpu::CommandHeader header;
8479   uint32_t target;
8480   int32_t imageId;
8481 };
8482
8483 COMPILE_ASSERT(sizeof(BindTexImage2DCHROMIUM) == 12,
8484                Sizeof_BindTexImage2DCHROMIUM_is_not_12);
8485 COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, header) == 0,
8486                OffsetOf_BindTexImage2DCHROMIUM_header_not_0);
8487 COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, target) == 4,
8488                OffsetOf_BindTexImage2DCHROMIUM_target_not_4);
8489 COMPILE_ASSERT(offsetof(BindTexImage2DCHROMIUM, imageId) == 8,
8490                OffsetOf_BindTexImage2DCHROMIUM_imageId_not_8);
8491
8492 struct ReleaseTexImage2DCHROMIUM {
8493   typedef ReleaseTexImage2DCHROMIUM ValueType;
8494   static const CommandId kCmdId = kReleaseTexImage2DCHROMIUM;
8495   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8496   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8497
8498   static uint32_t ComputeSize() {
8499     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8500   }
8501
8502   void SetHeader() { header.SetCmd<ValueType>(); }
8503
8504   void Init(GLenum _target, GLint _imageId) {
8505     SetHeader();
8506     target = _target;
8507     imageId = _imageId;
8508   }
8509
8510   void* Set(void* cmd, GLenum _target, GLint _imageId) {
8511     static_cast<ValueType*>(cmd)->Init(_target, _imageId);
8512     return NextCmdAddress<ValueType>(cmd);
8513   }
8514
8515   gpu::CommandHeader header;
8516   uint32_t target;
8517   int32_t imageId;
8518 };
8519
8520 COMPILE_ASSERT(sizeof(ReleaseTexImage2DCHROMIUM) == 12,
8521                Sizeof_ReleaseTexImage2DCHROMIUM_is_not_12);
8522 COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, header) == 0,
8523                OffsetOf_ReleaseTexImage2DCHROMIUM_header_not_0);
8524 COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, target) == 4,
8525                OffsetOf_ReleaseTexImage2DCHROMIUM_target_not_4);
8526 COMPILE_ASSERT(offsetof(ReleaseTexImage2DCHROMIUM, imageId) == 8,
8527                OffsetOf_ReleaseTexImage2DCHROMIUM_imageId_not_8);
8528
8529 struct TraceBeginCHROMIUM {
8530   typedef TraceBeginCHROMIUM ValueType;
8531   static const CommandId kCmdId = kTraceBeginCHROMIUM;
8532   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8533   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8534
8535   static uint32_t ComputeSize() {
8536     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8537   }
8538
8539   void SetHeader() { header.SetCmd<ValueType>(); }
8540
8541   void Init(GLuint _bucket_id) {
8542     SetHeader();
8543     bucket_id = _bucket_id;
8544   }
8545
8546   void* Set(void* cmd, GLuint _bucket_id) {
8547     static_cast<ValueType*>(cmd)->Init(_bucket_id);
8548     return NextCmdAddress<ValueType>(cmd);
8549   }
8550
8551   gpu::CommandHeader header;
8552   uint32_t bucket_id;
8553 };
8554
8555 COMPILE_ASSERT(sizeof(TraceBeginCHROMIUM) == 8,
8556                Sizeof_TraceBeginCHROMIUM_is_not_8);
8557 COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, header) == 0,
8558                OffsetOf_TraceBeginCHROMIUM_header_not_0);
8559 COMPILE_ASSERT(offsetof(TraceBeginCHROMIUM, bucket_id) == 4,
8560                OffsetOf_TraceBeginCHROMIUM_bucket_id_not_4);
8561
8562 struct TraceEndCHROMIUM {
8563   typedef TraceEndCHROMIUM ValueType;
8564   static const CommandId kCmdId = kTraceEndCHROMIUM;
8565   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8566   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8567
8568   static uint32_t ComputeSize() {
8569     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8570   }
8571
8572   void SetHeader() { header.SetCmd<ValueType>(); }
8573
8574   void Init() { SetHeader(); }
8575
8576   void* Set(void* cmd) {
8577     static_cast<ValueType*>(cmd)->Init();
8578     return NextCmdAddress<ValueType>(cmd);
8579   }
8580
8581   gpu::CommandHeader header;
8582 };
8583
8584 COMPILE_ASSERT(sizeof(TraceEndCHROMIUM) == 4, Sizeof_TraceEndCHROMIUM_is_not_4);
8585 COMPILE_ASSERT(offsetof(TraceEndCHROMIUM, header) == 0,
8586                OffsetOf_TraceEndCHROMIUM_header_not_0);
8587
8588 struct AsyncTexSubImage2DCHROMIUM {
8589   typedef AsyncTexSubImage2DCHROMIUM ValueType;
8590   static const CommandId kCmdId = kAsyncTexSubImage2DCHROMIUM;
8591   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8592   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8593
8594   static uint32_t ComputeSize() {
8595     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8596   }
8597
8598   void SetHeader() { header.SetCmd<ValueType>(); }
8599
8600   void Init(GLenum _target,
8601             GLint _level,
8602             GLint _xoffset,
8603             GLint _yoffset,
8604             GLsizei _width,
8605             GLsizei _height,
8606             GLenum _format,
8607             GLenum _type,
8608             uint32_t _data_shm_id,
8609             uint32_t _data_shm_offset,
8610             uint32_t _async_upload_token,
8611             uint32_t _sync_data_shm_id,
8612             uint32_t _sync_data_shm_offset) {
8613     SetHeader();
8614     target = _target;
8615     level = _level;
8616     xoffset = _xoffset;
8617     yoffset = _yoffset;
8618     width = _width;
8619     height = _height;
8620     format = _format;
8621     type = _type;
8622     data_shm_id = _data_shm_id;
8623     data_shm_offset = _data_shm_offset;
8624     async_upload_token = _async_upload_token;
8625     sync_data_shm_id = _sync_data_shm_id;
8626     sync_data_shm_offset = _sync_data_shm_offset;
8627   }
8628
8629   void* Set(void* cmd,
8630             GLenum _target,
8631             GLint _level,
8632             GLint _xoffset,
8633             GLint _yoffset,
8634             GLsizei _width,
8635             GLsizei _height,
8636             GLenum _format,
8637             GLenum _type,
8638             uint32_t _data_shm_id,
8639             uint32_t _data_shm_offset,
8640             uint32_t _async_upload_token,
8641             uint32_t _sync_data_shm_id,
8642             uint32_t _sync_data_shm_offset) {
8643     static_cast<ValueType*>(cmd)
8644         ->Init(_target, _level, _xoffset, _yoffset, _width, _height, _format,
8645                _type, _data_shm_id, _data_shm_offset, _async_upload_token,
8646                _sync_data_shm_id, _sync_data_shm_offset);
8647     return NextCmdAddress<ValueType>(cmd);
8648   }
8649
8650   gpu::CommandHeader header;
8651   uint32_t target;
8652   int32_t level;
8653   int32_t xoffset;
8654   int32_t yoffset;
8655   int32_t width;
8656   int32_t height;
8657   uint32_t format;
8658   uint32_t type;
8659   uint32_t data_shm_id;
8660   uint32_t data_shm_offset;
8661   uint32_t async_upload_token;
8662   uint32_t sync_data_shm_id;
8663   uint32_t sync_data_shm_offset;
8664 };
8665
8666 COMPILE_ASSERT(sizeof(AsyncTexSubImage2DCHROMIUM) == 56,
8667                Sizeof_AsyncTexSubImage2DCHROMIUM_is_not_56);
8668 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, header) == 0,
8669                OffsetOf_AsyncTexSubImage2DCHROMIUM_header_not_0);
8670 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, target) == 4,
8671                OffsetOf_AsyncTexSubImage2DCHROMIUM_target_not_4);
8672 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, level) == 8,
8673                OffsetOf_AsyncTexSubImage2DCHROMIUM_level_not_8);
8674 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, xoffset) == 12,
8675                OffsetOf_AsyncTexSubImage2DCHROMIUM_xoffset_not_12);
8676 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, yoffset) == 16,
8677                OffsetOf_AsyncTexSubImage2DCHROMIUM_yoffset_not_16);
8678 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, width) == 20,
8679                OffsetOf_AsyncTexSubImage2DCHROMIUM_width_not_20);
8680 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, height) == 24,
8681                OffsetOf_AsyncTexSubImage2DCHROMIUM_height_not_24);
8682 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, format) == 28,
8683                OffsetOf_AsyncTexSubImage2DCHROMIUM_format_not_28);
8684 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, type) == 32,
8685                OffsetOf_AsyncTexSubImage2DCHROMIUM_type_not_32);
8686 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_id) == 36,
8687                OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_id_not_36);
8688 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, data_shm_offset) == 40,
8689                OffsetOf_AsyncTexSubImage2DCHROMIUM_data_shm_offset_not_40);
8690 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, async_upload_token) == 44,
8691                OffsetOf_AsyncTexSubImage2DCHROMIUM_async_upload_token_not_44);
8692 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_id) == 48,
8693                OffsetOf_AsyncTexSubImage2DCHROMIUM_sync_data_shm_id_not_48);
8694 COMPILE_ASSERT(offsetof(AsyncTexSubImage2DCHROMIUM, sync_data_shm_offset) == 52,
8695                OffsetOf_AsyncTexSubImage2DCHROMIUM_sync_data_shm_offset_not_52);
8696
8697 struct AsyncTexImage2DCHROMIUM {
8698   typedef AsyncTexImage2DCHROMIUM ValueType;
8699   static const CommandId kCmdId = kAsyncTexImage2DCHROMIUM;
8700   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8701   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8702
8703   static uint32_t ComputeSize() {
8704     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8705   }
8706
8707   void SetHeader() { header.SetCmd<ValueType>(); }
8708
8709   void Init(GLenum _target,
8710             GLint _level,
8711             GLint _internalformat,
8712             GLsizei _width,
8713             GLsizei _height,
8714             GLenum _format,
8715             GLenum _type,
8716             uint32_t _pixels_shm_id,
8717             uint32_t _pixels_shm_offset,
8718             uint32_t _async_upload_token,
8719             uint32_t _sync_data_shm_id,
8720             uint32_t _sync_data_shm_offset) {
8721     SetHeader();
8722     target = _target;
8723     level = _level;
8724     internalformat = _internalformat;
8725     width = _width;
8726     height = _height;
8727     format = _format;
8728     type = _type;
8729     pixels_shm_id = _pixels_shm_id;
8730     pixels_shm_offset = _pixels_shm_offset;
8731     async_upload_token = _async_upload_token;
8732     sync_data_shm_id = _sync_data_shm_id;
8733     sync_data_shm_offset = _sync_data_shm_offset;
8734   }
8735
8736   void* Set(void* cmd,
8737             GLenum _target,
8738             GLint _level,
8739             GLint _internalformat,
8740             GLsizei _width,
8741             GLsizei _height,
8742             GLenum _format,
8743             GLenum _type,
8744             uint32_t _pixels_shm_id,
8745             uint32_t _pixels_shm_offset,
8746             uint32_t _async_upload_token,
8747             uint32_t _sync_data_shm_id,
8748             uint32_t _sync_data_shm_offset) {
8749     static_cast<ValueType*>(cmd)
8750         ->Init(_target, _level, _internalformat, _width, _height, _format,
8751                _type, _pixels_shm_id, _pixels_shm_offset, _async_upload_token,
8752                _sync_data_shm_id, _sync_data_shm_offset);
8753     return NextCmdAddress<ValueType>(cmd);
8754   }
8755
8756   gpu::CommandHeader header;
8757   uint32_t target;
8758   int32_t level;
8759   int32_t internalformat;
8760   int32_t width;
8761   int32_t height;
8762   uint32_t format;
8763   uint32_t type;
8764   uint32_t pixels_shm_id;
8765   uint32_t pixels_shm_offset;
8766   uint32_t async_upload_token;
8767   uint32_t sync_data_shm_id;
8768   uint32_t sync_data_shm_offset;
8769   static const int32_t border = 0;
8770 };
8771
8772 COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 52,
8773                Sizeof_AsyncTexImage2DCHROMIUM_is_not_52);
8774 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, header) == 0,
8775                OffsetOf_AsyncTexImage2DCHROMIUM_header_not_0);
8776 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, target) == 4,
8777                OffsetOf_AsyncTexImage2DCHROMIUM_target_not_4);
8778 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, level) == 8,
8779                OffsetOf_AsyncTexImage2DCHROMIUM_level_not_8);
8780 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, internalformat) == 12,
8781                OffsetOf_AsyncTexImage2DCHROMIUM_internalformat_not_12);
8782 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, width) == 16,
8783                OffsetOf_AsyncTexImage2DCHROMIUM_width_not_16);
8784 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, height) == 20,
8785                OffsetOf_AsyncTexImage2DCHROMIUM_height_not_20);
8786 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, format) == 24,
8787                OffsetOf_AsyncTexImage2DCHROMIUM_format_not_24);
8788 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, type) == 28,
8789                OffsetOf_AsyncTexImage2DCHROMIUM_type_not_28);
8790 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 32,
8791                OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_id_not_32);
8792 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 36,
8793                OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_offset_not_36);
8794 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, async_upload_token) == 40,
8795                OffsetOf_AsyncTexImage2DCHROMIUM_async_upload_token_not_40);
8796 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_id) == 44,
8797                OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_id_not_44);
8798 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_offset) == 48,
8799                OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_offset_not_48);
8800
8801 struct WaitAsyncTexImage2DCHROMIUM {
8802   typedef WaitAsyncTexImage2DCHROMIUM ValueType;
8803   static const CommandId kCmdId = kWaitAsyncTexImage2DCHROMIUM;
8804   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8805   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8806
8807   static uint32_t ComputeSize() {
8808     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8809   }
8810
8811   void SetHeader() { header.SetCmd<ValueType>(); }
8812
8813   void Init(GLenum _target) {
8814     SetHeader();
8815     target = _target;
8816   }
8817
8818   void* Set(void* cmd, GLenum _target) {
8819     static_cast<ValueType*>(cmd)->Init(_target);
8820     return NextCmdAddress<ValueType>(cmd);
8821   }
8822
8823   gpu::CommandHeader header;
8824   uint32_t target;
8825 };
8826
8827 COMPILE_ASSERT(sizeof(WaitAsyncTexImage2DCHROMIUM) == 8,
8828                Sizeof_WaitAsyncTexImage2DCHROMIUM_is_not_8);
8829 COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, header) == 0,
8830                OffsetOf_WaitAsyncTexImage2DCHROMIUM_header_not_0);
8831 COMPILE_ASSERT(offsetof(WaitAsyncTexImage2DCHROMIUM, target) == 4,
8832                OffsetOf_WaitAsyncTexImage2DCHROMIUM_target_not_4);
8833
8834 struct WaitAllAsyncTexImage2DCHROMIUM {
8835   typedef WaitAllAsyncTexImage2DCHROMIUM ValueType;
8836   static const CommandId kCmdId = kWaitAllAsyncTexImage2DCHROMIUM;
8837   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8838   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8839
8840   static uint32_t ComputeSize() {
8841     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8842   }
8843
8844   void SetHeader() { header.SetCmd<ValueType>(); }
8845
8846   void Init() { SetHeader(); }
8847
8848   void* Set(void* cmd) {
8849     static_cast<ValueType*>(cmd)->Init();
8850     return NextCmdAddress<ValueType>(cmd);
8851   }
8852
8853   gpu::CommandHeader header;
8854 };
8855
8856 COMPILE_ASSERT(sizeof(WaitAllAsyncTexImage2DCHROMIUM) == 4,
8857                Sizeof_WaitAllAsyncTexImage2DCHROMIUM_is_not_4);
8858 COMPILE_ASSERT(offsetof(WaitAllAsyncTexImage2DCHROMIUM, header) == 0,
8859                OffsetOf_WaitAllAsyncTexImage2DCHROMIUM_header_not_0);
8860
8861 struct DiscardFramebufferEXTImmediate {
8862   typedef DiscardFramebufferEXTImmediate ValueType;
8863   static const CommandId kCmdId = kDiscardFramebufferEXTImmediate;
8864   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8865   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8866
8867   static uint32_t ComputeDataSize(GLsizei count) {
8868     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
8869   }
8870
8871   static uint32_t ComputeSize(GLsizei count) {
8872     return static_cast<uint32_t>(sizeof(ValueType) +
8873                                  ComputeDataSize(count));  // NOLINT
8874   }
8875
8876   void SetHeader(GLsizei count) {
8877     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
8878   }
8879
8880   void Init(GLenum _target, GLsizei _count, const GLenum* _attachments) {
8881     SetHeader(_count);
8882     target = _target;
8883     count = _count;
8884     memcpy(ImmediateDataAddress(this), _attachments, ComputeDataSize(_count));
8885   }
8886
8887   void* Set(void* cmd,
8888             GLenum _target,
8889             GLsizei _count,
8890             const GLenum* _attachments) {
8891     static_cast<ValueType*>(cmd)->Init(_target, _count, _attachments);
8892     const uint32_t size = ComputeSize(_count);
8893     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
8894   }
8895
8896   gpu::CommandHeader header;
8897   uint32_t target;
8898   int32_t count;
8899 };
8900
8901 COMPILE_ASSERT(sizeof(DiscardFramebufferEXTImmediate) == 12,
8902                Sizeof_DiscardFramebufferEXTImmediate_is_not_12);
8903 COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, header) == 0,
8904                OffsetOf_DiscardFramebufferEXTImmediate_header_not_0);
8905 COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, target) == 4,
8906                OffsetOf_DiscardFramebufferEXTImmediate_target_not_4);
8907 COMPILE_ASSERT(offsetof(DiscardFramebufferEXTImmediate, count) == 8,
8908                OffsetOf_DiscardFramebufferEXTImmediate_count_not_8);
8909
8910 struct LoseContextCHROMIUM {
8911   typedef LoseContextCHROMIUM ValueType;
8912   static const CommandId kCmdId = kLoseContextCHROMIUM;
8913   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8914   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8915
8916   static uint32_t ComputeSize() {
8917     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8918   }
8919
8920   void SetHeader() { header.SetCmd<ValueType>(); }
8921
8922   void Init(GLenum _current, GLenum _other) {
8923     SetHeader();
8924     current = _current;
8925     other = _other;
8926   }
8927
8928   void* Set(void* cmd, GLenum _current, GLenum _other) {
8929     static_cast<ValueType*>(cmd)->Init(_current, _other);
8930     return NextCmdAddress<ValueType>(cmd);
8931   }
8932
8933   gpu::CommandHeader header;
8934   uint32_t current;
8935   uint32_t other;
8936 };
8937
8938 COMPILE_ASSERT(sizeof(LoseContextCHROMIUM) == 12,
8939                Sizeof_LoseContextCHROMIUM_is_not_12);
8940 COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, header) == 0,
8941                OffsetOf_LoseContextCHROMIUM_header_not_0);
8942 COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, current) == 4,
8943                OffsetOf_LoseContextCHROMIUM_current_not_4);
8944 COMPILE_ASSERT(offsetof(LoseContextCHROMIUM, other) == 8,
8945                OffsetOf_LoseContextCHROMIUM_other_not_8);
8946
8947 struct WaitSyncPointCHROMIUM {
8948   typedef WaitSyncPointCHROMIUM ValueType;
8949   static const CommandId kCmdId = kWaitSyncPointCHROMIUM;
8950   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
8951   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
8952
8953   static uint32_t ComputeSize() {
8954     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
8955   }
8956
8957   void SetHeader() { header.SetCmd<ValueType>(); }
8958
8959   void Init(GLuint _sync_point) {
8960     SetHeader();
8961     sync_point = _sync_point;
8962   }
8963
8964   void* Set(void* cmd, GLuint _sync_point) {
8965     static_cast<ValueType*>(cmd)->Init(_sync_point);
8966     return NextCmdAddress<ValueType>(cmd);
8967   }
8968
8969   gpu::CommandHeader header;
8970   uint32_t sync_point;
8971 };
8972
8973 COMPILE_ASSERT(sizeof(WaitSyncPointCHROMIUM) == 8,
8974                Sizeof_WaitSyncPointCHROMIUM_is_not_8);
8975 COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, header) == 0,
8976                OffsetOf_WaitSyncPointCHROMIUM_header_not_0);
8977 COMPILE_ASSERT(offsetof(WaitSyncPointCHROMIUM, sync_point) == 4,
8978                OffsetOf_WaitSyncPointCHROMIUM_sync_point_not_4);
8979
8980 struct DrawBuffersEXTImmediate {
8981   typedef DrawBuffersEXTImmediate ValueType;
8982   static const CommandId kCmdId = kDrawBuffersEXTImmediate;
8983   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
8984   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
8985
8986   static uint32_t ComputeDataSize(GLsizei count) {
8987     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
8988   }
8989
8990   static uint32_t ComputeSize(GLsizei count) {
8991     return static_cast<uint32_t>(sizeof(ValueType) +
8992                                  ComputeDataSize(count));  // NOLINT
8993   }
8994
8995   void SetHeader(GLsizei count) {
8996     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
8997   }
8998
8999   void Init(GLsizei _count, const GLenum* _bufs) {
9000     SetHeader(_count);
9001     count = _count;
9002     memcpy(ImmediateDataAddress(this), _bufs, ComputeDataSize(_count));
9003   }
9004
9005   void* Set(void* cmd, GLsizei _count, const GLenum* _bufs) {
9006     static_cast<ValueType*>(cmd)->Init(_count, _bufs);
9007     const uint32_t size = ComputeSize(_count);
9008     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
9009   }
9010
9011   gpu::CommandHeader header;
9012   int32_t count;
9013 };
9014
9015 COMPILE_ASSERT(sizeof(DrawBuffersEXTImmediate) == 8,
9016                Sizeof_DrawBuffersEXTImmediate_is_not_8);
9017 COMPILE_ASSERT(offsetof(DrawBuffersEXTImmediate, header) == 0,
9018                OffsetOf_DrawBuffersEXTImmediate_header_not_0);
9019 COMPILE_ASSERT(offsetof(DrawBuffersEXTImmediate, count) == 4,
9020                OffsetOf_DrawBuffersEXTImmediate_count_not_4);
9021
9022 struct DiscardBackbufferCHROMIUM {
9023   typedef DiscardBackbufferCHROMIUM ValueType;
9024   static const CommandId kCmdId = kDiscardBackbufferCHROMIUM;
9025   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
9026   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
9027
9028   static uint32_t ComputeSize() {
9029     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
9030   }
9031
9032   void SetHeader() { header.SetCmd<ValueType>(); }
9033
9034   void Init() { SetHeader(); }
9035
9036   void* Set(void* cmd) {
9037     static_cast<ValueType*>(cmd)->Init();
9038     return NextCmdAddress<ValueType>(cmd);
9039   }
9040
9041   gpu::CommandHeader header;
9042 };
9043
9044 COMPILE_ASSERT(sizeof(DiscardBackbufferCHROMIUM) == 4,
9045                Sizeof_DiscardBackbufferCHROMIUM_is_not_4);
9046 COMPILE_ASSERT(offsetof(DiscardBackbufferCHROMIUM, header) == 0,
9047                OffsetOf_DiscardBackbufferCHROMIUM_header_not_0);
9048
9049 struct ScheduleOverlayPlaneCHROMIUM {
9050   typedef ScheduleOverlayPlaneCHROMIUM ValueType;
9051   static const CommandId kCmdId = kScheduleOverlayPlaneCHROMIUM;
9052   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
9053   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
9054
9055   static uint32_t ComputeSize() {
9056     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
9057   }
9058
9059   void SetHeader() { header.SetCmd<ValueType>(); }
9060
9061   void Init(GLint _plane_z_order,
9062             GLenum _plane_transform,
9063             GLuint _overlay_texture_id,
9064             GLint _bounds_x,
9065             GLint _bounds_y,
9066             GLint _bounds_width,
9067             GLint _bounds_height,
9068             GLfloat _uv_x,
9069             GLfloat _uv_y,
9070             GLfloat _uv_width,
9071             GLfloat _uv_height) {
9072     SetHeader();
9073     plane_z_order = _plane_z_order;
9074     plane_transform = _plane_transform;
9075     overlay_texture_id = _overlay_texture_id;
9076     bounds_x = _bounds_x;
9077     bounds_y = _bounds_y;
9078     bounds_width = _bounds_width;
9079     bounds_height = _bounds_height;
9080     uv_x = _uv_x;
9081     uv_y = _uv_y;
9082     uv_width = _uv_width;
9083     uv_height = _uv_height;
9084   }
9085
9086   void* Set(void* cmd,
9087             GLint _plane_z_order,
9088             GLenum _plane_transform,
9089             GLuint _overlay_texture_id,
9090             GLint _bounds_x,
9091             GLint _bounds_y,
9092             GLint _bounds_width,
9093             GLint _bounds_height,
9094             GLfloat _uv_x,
9095             GLfloat _uv_y,
9096             GLfloat _uv_width,
9097             GLfloat _uv_height) {
9098     static_cast<ValueType*>(cmd)->Init(_plane_z_order, _plane_transform,
9099                                        _overlay_texture_id, _bounds_x,
9100                                        _bounds_y, _bounds_width, _bounds_height,
9101                                        _uv_x, _uv_y, _uv_width, _uv_height);
9102     return NextCmdAddress<ValueType>(cmd);
9103   }
9104
9105   gpu::CommandHeader header;
9106   int32_t plane_z_order;
9107   uint32_t plane_transform;
9108   uint32_t overlay_texture_id;
9109   int32_t bounds_x;
9110   int32_t bounds_y;
9111   int32_t bounds_width;
9112   int32_t bounds_height;
9113   float uv_x;
9114   float uv_y;
9115   float uv_width;
9116   float uv_height;
9117 };
9118
9119 COMPILE_ASSERT(sizeof(ScheduleOverlayPlaneCHROMIUM) == 48,
9120                Sizeof_ScheduleOverlayPlaneCHROMIUM_is_not_48);
9121 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, header) == 0,
9122                OffsetOf_ScheduleOverlayPlaneCHROMIUM_header_not_0);
9123 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, plane_z_order) == 4,
9124                OffsetOf_ScheduleOverlayPlaneCHROMIUM_plane_z_order_not_4);
9125 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, plane_transform) == 8,
9126                OffsetOf_ScheduleOverlayPlaneCHROMIUM_plane_transform_not_8);
9127 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, overlay_texture_id) == 12,
9128                OffsetOf_ScheduleOverlayPlaneCHROMIUM_overlay_texture_id_not_12);
9129 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_x) == 16,
9130                OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_x_not_16);
9131 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_y) == 20,
9132                OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_y_not_20);
9133 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_width) == 24,
9134                OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_width_not_24);
9135 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, bounds_height) == 28,
9136                OffsetOf_ScheduleOverlayPlaneCHROMIUM_bounds_height_not_28);
9137 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_x) == 32,
9138                OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_x_not_32);
9139 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_y) == 36,
9140                OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_y_not_36);
9141 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_width) == 40,
9142                OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_width_not_40);
9143 COMPILE_ASSERT(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_height) == 44,
9144                OffsetOf_ScheduleOverlayPlaneCHROMIUM_uv_height_not_44);
9145
9146 struct MatrixLoadfCHROMIUMImmediate {
9147   typedef MatrixLoadfCHROMIUMImmediate ValueType;
9148   static const CommandId kCmdId = kMatrixLoadfCHROMIUMImmediate;
9149   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
9150   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
9151
9152   static uint32_t ComputeDataSize() {
9153     return static_cast<uint32_t>(sizeof(GLfloat) * 16);  // NOLINT
9154   }
9155
9156   static uint32_t ComputeSize() {
9157     return static_cast<uint32_t>(sizeof(ValueType) +
9158                                  ComputeDataSize());  // NOLINT
9159   }
9160
9161   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
9162
9163   void Init(GLenum _matrixMode, const GLfloat* _m) {
9164     SetHeader();
9165     matrixMode = _matrixMode;
9166     memcpy(ImmediateDataAddress(this), _m, ComputeDataSize());
9167   }
9168
9169   void* Set(void* cmd, GLenum _matrixMode, const GLfloat* _m) {
9170     static_cast<ValueType*>(cmd)->Init(_matrixMode, _m);
9171     const uint32_t size = ComputeSize();
9172     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
9173   }
9174
9175   gpu::CommandHeader header;
9176   uint32_t matrixMode;
9177 };
9178
9179 COMPILE_ASSERT(sizeof(MatrixLoadfCHROMIUMImmediate) == 8,
9180                Sizeof_MatrixLoadfCHROMIUMImmediate_is_not_8);
9181 COMPILE_ASSERT(offsetof(MatrixLoadfCHROMIUMImmediate, header) == 0,
9182                OffsetOf_MatrixLoadfCHROMIUMImmediate_header_not_0);
9183 COMPILE_ASSERT(offsetof(MatrixLoadfCHROMIUMImmediate, matrixMode) == 4,
9184                OffsetOf_MatrixLoadfCHROMIUMImmediate_matrixMode_not_4);
9185
9186 struct MatrixLoadIdentityCHROMIUM {
9187   typedef MatrixLoadIdentityCHROMIUM ValueType;
9188   static const CommandId kCmdId = kMatrixLoadIdentityCHROMIUM;
9189   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
9190   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
9191
9192   static uint32_t ComputeSize() {
9193     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
9194   }
9195
9196   void SetHeader() { header.SetCmd<ValueType>(); }
9197
9198   void Init(GLenum _matrixMode) {
9199     SetHeader();
9200     matrixMode = _matrixMode;
9201   }
9202
9203   void* Set(void* cmd, GLenum _matrixMode) {
9204     static_cast<ValueType*>(cmd)->Init(_matrixMode);
9205     return NextCmdAddress<ValueType>(cmd);
9206   }
9207
9208   gpu::CommandHeader header;
9209   uint32_t matrixMode;
9210 };
9211
9212 COMPILE_ASSERT(sizeof(MatrixLoadIdentityCHROMIUM) == 8,
9213                Sizeof_MatrixLoadIdentityCHROMIUM_is_not_8);
9214 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0,
9215                OffsetOf_MatrixLoadIdentityCHROMIUM_header_not_0);
9216 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4,
9217                OffsetOf_MatrixLoadIdentityCHROMIUM_matrixMode_not_4);
9218
9219 struct BlendBarrierKHR {
9220   typedef BlendBarrierKHR ValueType;
9221   static const CommandId kCmdId = kBlendBarrierKHR;
9222   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
9223   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
9224
9225   static uint32_t ComputeSize() {
9226     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
9227   }
9228
9229   void SetHeader() { header.SetCmd<ValueType>(); }
9230
9231   void Init() { SetHeader(); }
9232
9233   void* Set(void* cmd) {
9234     static_cast<ValueType*>(cmd)->Init();
9235     return NextCmdAddress<ValueType>(cmd);
9236   }
9237
9238   gpu::CommandHeader header;
9239 };
9240
9241 COMPILE_ASSERT(sizeof(BlendBarrierKHR) == 4, Sizeof_BlendBarrierKHR_is_not_4);
9242 COMPILE_ASSERT(offsetof(BlendBarrierKHR, header) == 0,
9243                OffsetOf_BlendBarrierKHR_header_not_0);
9244
9245 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_