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