src/gpu/command_buffer/common/gles2_cmd_format_autogen.h

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