src/gpu/command_buffer/common/gles2_cmd_format_autogen.h

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