src/gpu/command_buffer/common/gles2_cmd_format_autogen.h

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