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