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