gpu/command_buffer/common/gles2_cmd_format_autogen.h

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