gles2_cmd_helper_autogen.h revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
12#define GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
13
14void ActiveTexture(GLenum texture) {
15  gles2::cmds::ActiveTexture* c = GetCmdSpace<gles2::cmds::ActiveTexture>();
16  if (c) {
17    c->Init(texture);
18  }
19}
20
21void AttachShader(GLuint program, GLuint shader) {
22  gles2::cmds::AttachShader* c = GetCmdSpace<gles2::cmds::AttachShader>();
23  if (c) {
24    c->Init(program, shader);
25  }
26}
27
28void BindAttribLocationBucket(GLuint program,
29                              GLuint index,
30                              uint32_t name_bucket_id) {
31  gles2::cmds::BindAttribLocationBucket* c =
32      GetCmdSpace<gles2::cmds::BindAttribLocationBucket>();
33  if (c) {
34    c->Init(program, index, name_bucket_id);
35  }
36}
37
38void BindBuffer(GLenum target, GLuint buffer) {
39  gles2::cmds::BindBuffer* c = GetCmdSpace<gles2::cmds::BindBuffer>();
40  if (c) {
41    c->Init(target, buffer);
42  }
43}
44
45void BindFramebuffer(GLenum target, GLuint framebuffer) {
46  gles2::cmds::BindFramebuffer* c = GetCmdSpace<gles2::cmds::BindFramebuffer>();
47  if (c) {
48    c->Init(target, framebuffer);
49  }
50}
51
52void BindRenderbuffer(GLenum target, GLuint renderbuffer) {
53  gles2::cmds::BindRenderbuffer* c =
54      GetCmdSpace<gles2::cmds::BindRenderbuffer>();
55  if (c) {
56    c->Init(target, renderbuffer);
57  }
58}
59
60void BindTexture(GLenum target, GLuint texture) {
61  gles2::cmds::BindTexture* c = GetCmdSpace<gles2::cmds::BindTexture>();
62  if (c) {
63    c->Init(target, texture);
64  }
65}
66
67void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
68  gles2::cmds::BlendColor* c = GetCmdSpace<gles2::cmds::BlendColor>();
69  if (c) {
70    c->Init(red, green, blue, alpha);
71  }
72}
73
74void BlendEquation(GLenum mode) {
75  gles2::cmds::BlendEquation* c = GetCmdSpace<gles2::cmds::BlendEquation>();
76  if (c) {
77    c->Init(mode);
78  }
79}
80
81void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
82  gles2::cmds::BlendEquationSeparate* c =
83      GetCmdSpace<gles2::cmds::BlendEquationSeparate>();
84  if (c) {
85    c->Init(modeRGB, modeAlpha);
86  }
87}
88
89void BlendFunc(GLenum sfactor, GLenum dfactor) {
90  gles2::cmds::BlendFunc* c = GetCmdSpace<gles2::cmds::BlendFunc>();
91  if (c) {
92    c->Init(sfactor, dfactor);
93  }
94}
95
96void BlendFuncSeparate(GLenum srcRGB,
97                       GLenum dstRGB,
98                       GLenum srcAlpha,
99                       GLenum dstAlpha) {
100  gles2::cmds::BlendFuncSeparate* c =
101      GetCmdSpace<gles2::cmds::BlendFuncSeparate>();
102  if (c) {
103    c->Init(srcRGB, dstRGB, srcAlpha, dstAlpha);
104  }
105}
106
107void BufferData(GLenum target,
108                GLsizeiptr size,
109                uint32_t data_shm_id,
110                uint32_t data_shm_offset,
111                GLenum usage) {
112  gles2::cmds::BufferData* c = GetCmdSpace<gles2::cmds::BufferData>();
113  if (c) {
114    c->Init(target, size, data_shm_id, data_shm_offset, usage);
115  }
116}
117
118void BufferSubData(GLenum target,
119                   GLintptr offset,
120                   GLsizeiptr size,
121                   uint32_t data_shm_id,
122                   uint32_t data_shm_offset) {
123  gles2::cmds::BufferSubData* c = GetCmdSpace<gles2::cmds::BufferSubData>();
124  if (c) {
125    c->Init(target, offset, size, data_shm_id, data_shm_offset);
126  }
127}
128
129void CheckFramebufferStatus(GLenum target,
130                            uint32_t result_shm_id,
131                            uint32_t result_shm_offset) {
132  gles2::cmds::CheckFramebufferStatus* c =
133      GetCmdSpace<gles2::cmds::CheckFramebufferStatus>();
134  if (c) {
135    c->Init(target, result_shm_id, result_shm_offset);
136  }
137}
138
139void Clear(GLbitfield mask) {
140  gles2::cmds::Clear* c = GetCmdSpace<gles2::cmds::Clear>();
141  if (c) {
142    c->Init(mask);
143  }
144}
145
146void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
147  gles2::cmds::ClearColor* c = GetCmdSpace<gles2::cmds::ClearColor>();
148  if (c) {
149    c->Init(red, green, blue, alpha);
150  }
151}
152
153void ClearDepthf(GLclampf depth) {
154  gles2::cmds::ClearDepthf* c = GetCmdSpace<gles2::cmds::ClearDepthf>();
155  if (c) {
156    c->Init(depth);
157  }
158}
159
160void ClearStencil(GLint s) {
161  gles2::cmds::ClearStencil* c = GetCmdSpace<gles2::cmds::ClearStencil>();
162  if (c) {
163    c->Init(s);
164  }
165}
166
167void ColorMask(GLboolean red,
168               GLboolean green,
169               GLboolean blue,
170               GLboolean alpha) {
171  gles2::cmds::ColorMask* c = GetCmdSpace<gles2::cmds::ColorMask>();
172  if (c) {
173    c->Init(red, green, blue, alpha);
174  }
175}
176
177void CompileShader(GLuint shader) {
178  gles2::cmds::CompileShader* c = GetCmdSpace<gles2::cmds::CompileShader>();
179  if (c) {
180    c->Init(shader);
181  }
182}
183
184void CompressedTexImage2DBucket(GLenum target,
185                                GLint level,
186                                GLenum internalformat,
187                                GLsizei width,
188                                GLsizei height,
189                                GLuint bucket_id) {
190  gles2::cmds::CompressedTexImage2DBucket* c =
191      GetCmdSpace<gles2::cmds::CompressedTexImage2DBucket>();
192  if (c) {
193    c->Init(target, level, internalformat, width, height, bucket_id);
194  }
195}
196
197void CompressedTexImage2D(GLenum target,
198                          GLint level,
199                          GLenum internalformat,
200                          GLsizei width,
201                          GLsizei height,
202                          GLsizei imageSize,
203                          uint32_t data_shm_id,
204                          uint32_t data_shm_offset) {
205  gles2::cmds::CompressedTexImage2D* c =
206      GetCmdSpace<gles2::cmds::CompressedTexImage2D>();
207  if (c) {
208    c->Init(target,
209            level,
210            internalformat,
211            width,
212            height,
213            imageSize,
214            data_shm_id,
215            data_shm_offset);
216  }
217}
218
219void CompressedTexSubImage2DBucket(GLenum target,
220                                   GLint level,
221                                   GLint xoffset,
222                                   GLint yoffset,
223                                   GLsizei width,
224                                   GLsizei height,
225                                   GLenum format,
226                                   GLuint bucket_id) {
227  gles2::cmds::CompressedTexSubImage2DBucket* c =
228      GetCmdSpace<gles2::cmds::CompressedTexSubImage2DBucket>();
229  if (c) {
230    c->Init(target, level, xoffset, yoffset, width, height, format, bucket_id);
231  }
232}
233
234void CompressedTexSubImage2D(GLenum target,
235                             GLint level,
236                             GLint xoffset,
237                             GLint yoffset,
238                             GLsizei width,
239                             GLsizei height,
240                             GLenum format,
241                             GLsizei imageSize,
242                             uint32_t data_shm_id,
243                             uint32_t data_shm_offset) {
244  gles2::cmds::CompressedTexSubImage2D* c =
245      GetCmdSpace<gles2::cmds::CompressedTexSubImage2D>();
246  if (c) {
247    c->Init(target,
248            level,
249            xoffset,
250            yoffset,
251            width,
252            height,
253            format,
254            imageSize,
255            data_shm_id,
256            data_shm_offset);
257  }
258}
259
260void CopyTexImage2D(GLenum target,
261                    GLint level,
262                    GLenum internalformat,
263                    GLint x,
264                    GLint y,
265                    GLsizei width,
266                    GLsizei height) {
267  gles2::cmds::CopyTexImage2D* c = GetCmdSpace<gles2::cmds::CopyTexImage2D>();
268  if (c) {
269    c->Init(target, level, internalformat, x, y, width, height);
270  }
271}
272
273void CopyTexSubImage2D(GLenum target,
274                       GLint level,
275                       GLint xoffset,
276                       GLint yoffset,
277                       GLint x,
278                       GLint y,
279                       GLsizei width,
280                       GLsizei height) {
281  gles2::cmds::CopyTexSubImage2D* c =
282      GetCmdSpace<gles2::cmds::CopyTexSubImage2D>();
283  if (c) {
284    c->Init(target, level, xoffset, yoffset, x, y, width, height);
285  }
286}
287
288void CreateProgram(uint32_t client_id) {
289  gles2::cmds::CreateProgram* c = GetCmdSpace<gles2::cmds::CreateProgram>();
290  if (c) {
291    c->Init(client_id);
292  }
293}
294
295void CreateShader(GLenum type, uint32_t client_id) {
296  gles2::cmds::CreateShader* c = GetCmdSpace<gles2::cmds::CreateShader>();
297  if (c) {
298    c->Init(type, client_id);
299  }
300}
301
302void CullFace(GLenum mode) {
303  gles2::cmds::CullFace* c = GetCmdSpace<gles2::cmds::CullFace>();
304  if (c) {
305    c->Init(mode);
306  }
307}
308
309void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) {
310  const uint32_t size = gles2::cmds::DeleteBuffersImmediate::ComputeSize(n);
311  gles2::cmds::DeleteBuffersImmediate* c =
312      GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteBuffersImmediate>(size);
313  if (c) {
314    c->Init(n, buffers);
315  }
316}
317
318void DeleteFramebuffersImmediate(GLsizei n, const GLuint* framebuffers) {
319  const uint32_t size =
320      gles2::cmds::DeleteFramebuffersImmediate::ComputeSize(n);
321  gles2::cmds::DeleteFramebuffersImmediate* c =
322      GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteFramebuffersImmediate>(
323          size);
324  if (c) {
325    c->Init(n, framebuffers);
326  }
327}
328
329void DeleteProgram(GLuint program) {
330  gles2::cmds::DeleteProgram* c = GetCmdSpace<gles2::cmds::DeleteProgram>();
331  if (c) {
332    c->Init(program);
333  }
334}
335
336void DeleteRenderbuffersImmediate(GLsizei n, const GLuint* renderbuffers) {
337  const uint32_t size =
338      gles2::cmds::DeleteRenderbuffersImmediate::ComputeSize(n);
339  gles2::cmds::DeleteRenderbuffersImmediate* c =
340      GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteRenderbuffersImmediate>(
341          size);
342  if (c) {
343    c->Init(n, renderbuffers);
344  }
345}
346
347void DeleteShader(GLuint shader) {
348  gles2::cmds::DeleteShader* c = GetCmdSpace<gles2::cmds::DeleteShader>();
349  if (c) {
350    c->Init(shader);
351  }
352}
353
354void DeleteTexturesImmediate(GLsizei n, const GLuint* textures) {
355  const uint32_t size = gles2::cmds::DeleteTexturesImmediate::ComputeSize(n);
356  gles2::cmds::DeleteTexturesImmediate* c =
357      GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteTexturesImmediate>(size);
358  if (c) {
359    c->Init(n, textures);
360  }
361}
362
363void DepthFunc(GLenum func) {
364  gles2::cmds::DepthFunc* c = GetCmdSpace<gles2::cmds::DepthFunc>();
365  if (c) {
366    c->Init(func);
367  }
368}
369
370void DepthMask(GLboolean flag) {
371  gles2::cmds::DepthMask* c = GetCmdSpace<gles2::cmds::DepthMask>();
372  if (c) {
373    c->Init(flag);
374  }
375}
376
377void DepthRangef(GLclampf zNear, GLclampf zFar) {
378  gles2::cmds::DepthRangef* c = GetCmdSpace<gles2::cmds::DepthRangef>();
379  if (c) {
380    c->Init(zNear, zFar);
381  }
382}
383
384void DetachShader(GLuint program, GLuint shader) {
385  gles2::cmds::DetachShader* c = GetCmdSpace<gles2::cmds::DetachShader>();
386  if (c) {
387    c->Init(program, shader);
388  }
389}
390
391void Disable(GLenum cap) {
392  gles2::cmds::Disable* c = GetCmdSpace<gles2::cmds::Disable>();
393  if (c) {
394    c->Init(cap);
395  }
396}
397
398void DisableVertexAttribArray(GLuint index) {
399  gles2::cmds::DisableVertexAttribArray* c =
400      GetCmdSpace<gles2::cmds::DisableVertexAttribArray>();
401  if (c) {
402    c->Init(index);
403  }
404}
405
406void DrawArrays(GLenum mode, GLint first, GLsizei count) {
407  gles2::cmds::DrawArrays* c = GetCmdSpace<gles2::cmds::DrawArrays>();
408  if (c) {
409    c->Init(mode, first, count);
410  }
411}
412
413void DrawElements(GLenum mode,
414                  GLsizei count,
415                  GLenum type,
416                  GLuint index_offset) {
417  gles2::cmds::DrawElements* c = GetCmdSpace<gles2::cmds::DrawElements>();
418  if (c) {
419    c->Init(mode, count, type, index_offset);
420  }
421}
422
423void Enable(GLenum cap) {
424  gles2::cmds::Enable* c = GetCmdSpace<gles2::cmds::Enable>();
425  if (c) {
426    c->Init(cap);
427  }
428}
429
430void EnableVertexAttribArray(GLuint index) {
431  gles2::cmds::EnableVertexAttribArray* c =
432      GetCmdSpace<gles2::cmds::EnableVertexAttribArray>();
433  if (c) {
434    c->Init(index);
435  }
436}
437
438void Finish() {
439  gles2::cmds::Finish* c = GetCmdSpace<gles2::cmds::Finish>();
440  if (c) {
441    c->Init();
442  }
443}
444
445void Flush() {
446  gles2::cmds::Flush* c = GetCmdSpace<gles2::cmds::Flush>();
447  if (c) {
448    c->Init();
449  }
450}
451
452void FramebufferRenderbuffer(GLenum target,
453                             GLenum attachment,
454                             GLenum renderbuffertarget,
455                             GLuint renderbuffer) {
456  gles2::cmds::FramebufferRenderbuffer* c =
457      GetCmdSpace<gles2::cmds::FramebufferRenderbuffer>();
458  if (c) {
459    c->Init(target, attachment, renderbuffertarget, renderbuffer);
460  }
461}
462
463void FramebufferTexture2D(GLenum target,
464                          GLenum attachment,
465                          GLenum textarget,
466                          GLuint texture) {
467  gles2::cmds::FramebufferTexture2D* c =
468      GetCmdSpace<gles2::cmds::FramebufferTexture2D>();
469  if (c) {
470    c->Init(target, attachment, textarget, texture);
471  }
472}
473
474void FrontFace(GLenum mode) {
475  gles2::cmds::FrontFace* c = GetCmdSpace<gles2::cmds::FrontFace>();
476  if (c) {
477    c->Init(mode);
478  }
479}
480
481void GenBuffersImmediate(GLsizei n, GLuint* buffers) {
482  const uint32_t size = gles2::cmds::GenBuffersImmediate::ComputeSize(n);
483  gles2::cmds::GenBuffersImmediate* c =
484      GetImmediateCmdSpaceTotalSize<gles2::cmds::GenBuffersImmediate>(size);
485  if (c) {
486    c->Init(n, buffers);
487  }
488}
489
490void GenerateMipmap(GLenum target) {
491  gles2::cmds::GenerateMipmap* c = GetCmdSpace<gles2::cmds::GenerateMipmap>();
492  if (c) {
493    c->Init(target);
494  }
495}
496
497void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) {
498  const uint32_t size = gles2::cmds::GenFramebuffersImmediate::ComputeSize(n);
499  gles2::cmds::GenFramebuffersImmediate* c =
500      GetImmediateCmdSpaceTotalSize<gles2::cmds::GenFramebuffersImmediate>(
501          size);
502  if (c) {
503    c->Init(n, framebuffers);
504  }
505}
506
507void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) {
508  const uint32_t size = gles2::cmds::GenRenderbuffersImmediate::ComputeSize(n);
509  gles2::cmds::GenRenderbuffersImmediate* c =
510      GetImmediateCmdSpaceTotalSize<gles2::cmds::GenRenderbuffersImmediate>(
511          size);
512  if (c) {
513    c->Init(n, renderbuffers);
514  }
515}
516
517void GenTexturesImmediate(GLsizei n, GLuint* textures) {
518  const uint32_t size = gles2::cmds::GenTexturesImmediate::ComputeSize(n);
519  gles2::cmds::GenTexturesImmediate* c =
520      GetImmediateCmdSpaceTotalSize<gles2::cmds::GenTexturesImmediate>(size);
521  if (c) {
522    c->Init(n, textures);
523  }
524}
525
526void GetActiveAttrib(GLuint program,
527                     GLuint index,
528                     uint32_t name_bucket_id,
529                     uint32_t result_shm_id,
530                     uint32_t result_shm_offset) {
531  gles2::cmds::GetActiveAttrib* c = GetCmdSpace<gles2::cmds::GetActiveAttrib>();
532  if (c) {
533    c->Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
534  }
535}
536
537void GetActiveUniform(GLuint program,
538                      GLuint index,
539                      uint32_t name_bucket_id,
540                      uint32_t result_shm_id,
541                      uint32_t result_shm_offset) {
542  gles2::cmds::GetActiveUniform* c =
543      GetCmdSpace<gles2::cmds::GetActiveUniform>();
544  if (c) {
545    c->Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
546  }
547}
548
549void GetAttachedShaders(GLuint program,
550                        uint32_t result_shm_id,
551                        uint32_t result_shm_offset,
552                        uint32_t result_size) {
553  gles2::cmds::GetAttachedShaders* c =
554      GetCmdSpace<gles2::cmds::GetAttachedShaders>();
555  if (c) {
556    c->Init(program, result_shm_id, result_shm_offset, result_size);
557  }
558}
559
560void GetAttribLocation(GLuint program,
561                       uint32_t name_bucket_id,
562                       uint32_t location_shm_id,
563                       uint32_t location_shm_offset) {
564  gles2::cmds::GetAttribLocation* c =
565      GetCmdSpace<gles2::cmds::GetAttribLocation>();
566  if (c) {
567    c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
568  }
569}
570
571void GetBooleanv(GLenum pname,
572                 uint32_t params_shm_id,
573                 uint32_t params_shm_offset) {
574  gles2::cmds::GetBooleanv* c = GetCmdSpace<gles2::cmds::GetBooleanv>();
575  if (c) {
576    c->Init(pname, params_shm_id, params_shm_offset);
577  }
578}
579
580void GetBufferParameteriv(GLenum target,
581                          GLenum pname,
582                          uint32_t params_shm_id,
583                          uint32_t params_shm_offset) {
584  gles2::cmds::GetBufferParameteriv* c =
585      GetCmdSpace<gles2::cmds::GetBufferParameteriv>();
586  if (c) {
587    c->Init(target, pname, params_shm_id, params_shm_offset);
588  }
589}
590
591void GetError(uint32_t result_shm_id, uint32_t result_shm_offset) {
592  gles2::cmds::GetError* c = GetCmdSpace<gles2::cmds::GetError>();
593  if (c) {
594    c->Init(result_shm_id, result_shm_offset);
595  }
596}
597
598void GetFloatv(GLenum pname,
599               uint32_t params_shm_id,
600               uint32_t params_shm_offset) {
601  gles2::cmds::GetFloatv* c = GetCmdSpace<gles2::cmds::GetFloatv>();
602  if (c) {
603    c->Init(pname, params_shm_id, params_shm_offset);
604  }
605}
606
607void GetFramebufferAttachmentParameteriv(GLenum target,
608                                         GLenum attachment,
609                                         GLenum pname,
610                                         uint32_t params_shm_id,
611                                         uint32_t params_shm_offset) {
612  gles2::cmds::GetFramebufferAttachmentParameteriv* c =
613      GetCmdSpace<gles2::cmds::GetFramebufferAttachmentParameteriv>();
614  if (c) {
615    c->Init(target, attachment, pname, params_shm_id, params_shm_offset);
616  }
617}
618
619void GetIntegerv(GLenum pname,
620                 uint32_t params_shm_id,
621                 uint32_t params_shm_offset) {
622  gles2::cmds::GetIntegerv* c = GetCmdSpace<gles2::cmds::GetIntegerv>();
623  if (c) {
624    c->Init(pname, params_shm_id, params_shm_offset);
625  }
626}
627
628void GetProgramiv(GLuint program,
629                  GLenum pname,
630                  uint32_t params_shm_id,
631                  uint32_t params_shm_offset) {
632  gles2::cmds::GetProgramiv* c = GetCmdSpace<gles2::cmds::GetProgramiv>();
633  if (c) {
634    c->Init(program, pname, params_shm_id, params_shm_offset);
635  }
636}
637
638void GetProgramInfoLog(GLuint program, uint32_t bucket_id) {
639  gles2::cmds::GetProgramInfoLog* c =
640      GetCmdSpace<gles2::cmds::GetProgramInfoLog>();
641  if (c) {
642    c->Init(program, bucket_id);
643  }
644}
645
646void GetRenderbufferParameteriv(GLenum target,
647                                GLenum pname,
648                                uint32_t params_shm_id,
649                                uint32_t params_shm_offset) {
650  gles2::cmds::GetRenderbufferParameteriv* c =
651      GetCmdSpace<gles2::cmds::GetRenderbufferParameteriv>();
652  if (c) {
653    c->Init(target, pname, params_shm_id, params_shm_offset);
654  }
655}
656
657void GetShaderiv(GLuint shader,
658                 GLenum pname,
659                 uint32_t params_shm_id,
660                 uint32_t params_shm_offset) {
661  gles2::cmds::GetShaderiv* c = GetCmdSpace<gles2::cmds::GetShaderiv>();
662  if (c) {
663    c->Init(shader, pname, params_shm_id, params_shm_offset);
664  }
665}
666
667void GetShaderInfoLog(GLuint shader, uint32_t bucket_id) {
668  gles2::cmds::GetShaderInfoLog* c =
669      GetCmdSpace<gles2::cmds::GetShaderInfoLog>();
670  if (c) {
671    c->Init(shader, bucket_id);
672  }
673}
674
675void GetShaderPrecisionFormat(GLenum shadertype,
676                              GLenum precisiontype,
677                              uint32_t result_shm_id,
678                              uint32_t result_shm_offset) {
679  gles2::cmds::GetShaderPrecisionFormat* c =
680      GetCmdSpace<gles2::cmds::GetShaderPrecisionFormat>();
681  if (c) {
682    c->Init(shadertype, precisiontype, result_shm_id, result_shm_offset);
683  }
684}
685
686void GetShaderSource(GLuint shader, uint32_t bucket_id) {
687  gles2::cmds::GetShaderSource* c = GetCmdSpace<gles2::cmds::GetShaderSource>();
688  if (c) {
689    c->Init(shader, bucket_id);
690  }
691}
692
693void GetString(GLenum name, uint32_t bucket_id) {
694  gles2::cmds::GetString* c = GetCmdSpace<gles2::cmds::GetString>();
695  if (c) {
696    c->Init(name, bucket_id);
697  }
698}
699
700void GetTexParameterfv(GLenum target,
701                       GLenum pname,
702                       uint32_t params_shm_id,
703                       uint32_t params_shm_offset) {
704  gles2::cmds::GetTexParameterfv* c =
705      GetCmdSpace<gles2::cmds::GetTexParameterfv>();
706  if (c) {
707    c->Init(target, pname, params_shm_id, params_shm_offset);
708  }
709}
710
711void GetTexParameteriv(GLenum target,
712                       GLenum pname,
713                       uint32_t params_shm_id,
714                       uint32_t params_shm_offset) {
715  gles2::cmds::GetTexParameteriv* c =
716      GetCmdSpace<gles2::cmds::GetTexParameteriv>();
717  if (c) {
718    c->Init(target, pname, params_shm_id, params_shm_offset);
719  }
720}
721
722void GetUniformfv(GLuint program,
723                  GLint location,
724                  uint32_t params_shm_id,
725                  uint32_t params_shm_offset) {
726  gles2::cmds::GetUniformfv* c = GetCmdSpace<gles2::cmds::GetUniformfv>();
727  if (c) {
728    c->Init(program, location, params_shm_id, params_shm_offset);
729  }
730}
731
732void GetUniformiv(GLuint program,
733                  GLint location,
734                  uint32_t params_shm_id,
735                  uint32_t params_shm_offset) {
736  gles2::cmds::GetUniformiv* c = GetCmdSpace<gles2::cmds::GetUniformiv>();
737  if (c) {
738    c->Init(program, location, params_shm_id, params_shm_offset);
739  }
740}
741
742void GetUniformLocation(GLuint program,
743                        uint32_t name_bucket_id,
744                        uint32_t location_shm_id,
745                        uint32_t location_shm_offset) {
746  gles2::cmds::GetUniformLocation* c =
747      GetCmdSpace<gles2::cmds::GetUniformLocation>();
748  if (c) {
749    c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
750  }
751}
752
753void GetVertexAttribfv(GLuint index,
754                       GLenum pname,
755                       uint32_t params_shm_id,
756                       uint32_t params_shm_offset) {
757  gles2::cmds::GetVertexAttribfv* c =
758      GetCmdSpace<gles2::cmds::GetVertexAttribfv>();
759  if (c) {
760    c->Init(index, pname, params_shm_id, params_shm_offset);
761  }
762}
763
764void GetVertexAttribiv(GLuint index,
765                       GLenum pname,
766                       uint32_t params_shm_id,
767                       uint32_t params_shm_offset) {
768  gles2::cmds::GetVertexAttribiv* c =
769      GetCmdSpace<gles2::cmds::GetVertexAttribiv>();
770  if (c) {
771    c->Init(index, pname, params_shm_id, params_shm_offset);
772  }
773}
774
775void GetVertexAttribPointerv(GLuint index,
776                             GLenum pname,
777                             uint32_t pointer_shm_id,
778                             uint32_t pointer_shm_offset) {
779  gles2::cmds::GetVertexAttribPointerv* c =
780      GetCmdSpace<gles2::cmds::GetVertexAttribPointerv>();
781  if (c) {
782    c->Init(index, pname, pointer_shm_id, pointer_shm_offset);
783  }
784}
785
786void Hint(GLenum target, GLenum mode) {
787  gles2::cmds::Hint* c = GetCmdSpace<gles2::cmds::Hint>();
788  if (c) {
789    c->Init(target, mode);
790  }
791}
792
793void IsBuffer(GLuint buffer,
794              uint32_t result_shm_id,
795              uint32_t result_shm_offset) {
796  gles2::cmds::IsBuffer* c = GetCmdSpace<gles2::cmds::IsBuffer>();
797  if (c) {
798    c->Init(buffer, result_shm_id, result_shm_offset);
799  }
800}
801
802void IsEnabled(GLenum cap, uint32_t result_shm_id, uint32_t result_shm_offset) {
803  gles2::cmds::IsEnabled* c = GetCmdSpace<gles2::cmds::IsEnabled>();
804  if (c) {
805    c->Init(cap, result_shm_id, result_shm_offset);
806  }
807}
808
809void IsFramebuffer(GLuint framebuffer,
810                   uint32_t result_shm_id,
811                   uint32_t result_shm_offset) {
812  gles2::cmds::IsFramebuffer* c = GetCmdSpace<gles2::cmds::IsFramebuffer>();
813  if (c) {
814    c->Init(framebuffer, result_shm_id, result_shm_offset);
815  }
816}
817
818void IsProgram(GLuint program,
819               uint32_t result_shm_id,
820               uint32_t result_shm_offset) {
821  gles2::cmds::IsProgram* c = GetCmdSpace<gles2::cmds::IsProgram>();
822  if (c) {
823    c->Init(program, result_shm_id, result_shm_offset);
824  }
825}
826
827void IsRenderbuffer(GLuint renderbuffer,
828                    uint32_t result_shm_id,
829                    uint32_t result_shm_offset) {
830  gles2::cmds::IsRenderbuffer* c = GetCmdSpace<gles2::cmds::IsRenderbuffer>();
831  if (c) {
832    c->Init(renderbuffer, result_shm_id, result_shm_offset);
833  }
834}
835
836void IsShader(GLuint shader,
837              uint32_t result_shm_id,
838              uint32_t result_shm_offset) {
839  gles2::cmds::IsShader* c = GetCmdSpace<gles2::cmds::IsShader>();
840  if (c) {
841    c->Init(shader, result_shm_id, result_shm_offset);
842  }
843}
844
845void IsTexture(GLuint texture,
846               uint32_t result_shm_id,
847               uint32_t result_shm_offset) {
848  gles2::cmds::IsTexture* c = GetCmdSpace<gles2::cmds::IsTexture>();
849  if (c) {
850    c->Init(texture, result_shm_id, result_shm_offset);
851  }
852}
853
854void LineWidth(GLfloat width) {
855  gles2::cmds::LineWidth* c = GetCmdSpace<gles2::cmds::LineWidth>();
856  if (c) {
857    c->Init(width);
858  }
859}
860
861void LinkProgram(GLuint program) {
862  gles2::cmds::LinkProgram* c = GetCmdSpace<gles2::cmds::LinkProgram>();
863  if (c) {
864    c->Init(program);
865  }
866}
867
868void PixelStorei(GLenum pname, GLint param) {
869  gles2::cmds::PixelStorei* c = GetCmdSpace<gles2::cmds::PixelStorei>();
870  if (c) {
871    c->Init(pname, param);
872  }
873}
874
875void PolygonOffset(GLfloat factor, GLfloat units) {
876  gles2::cmds::PolygonOffset* c = GetCmdSpace<gles2::cmds::PolygonOffset>();
877  if (c) {
878    c->Init(factor, units);
879  }
880}
881
882void ReadPixels(GLint x,
883                GLint y,
884                GLsizei width,
885                GLsizei height,
886                GLenum format,
887                GLenum type,
888                uint32_t pixels_shm_id,
889                uint32_t pixels_shm_offset,
890                uint32_t result_shm_id,
891                uint32_t result_shm_offset,
892                GLboolean async) {
893  gles2::cmds::ReadPixels* c = GetCmdSpace<gles2::cmds::ReadPixels>();
894  if (c) {
895    c->Init(x,
896            y,
897            width,
898            height,
899            format,
900            type,
901            pixels_shm_id,
902            pixels_shm_offset,
903            result_shm_id,
904            result_shm_offset,
905            async);
906  }
907}
908
909void ReleaseShaderCompiler() {
910  gles2::cmds::ReleaseShaderCompiler* c =
911      GetCmdSpace<gles2::cmds::ReleaseShaderCompiler>();
912  if (c) {
913    c->Init();
914  }
915}
916
917void RenderbufferStorage(GLenum target,
918                         GLenum internalformat,
919                         GLsizei width,
920                         GLsizei height) {
921  gles2::cmds::RenderbufferStorage* c =
922      GetCmdSpace<gles2::cmds::RenderbufferStorage>();
923  if (c) {
924    c->Init(target, internalformat, width, height);
925  }
926}
927
928void SampleCoverage(GLclampf value, GLboolean invert) {
929  gles2::cmds::SampleCoverage* c = GetCmdSpace<gles2::cmds::SampleCoverage>();
930  if (c) {
931    c->Init(value, invert);
932  }
933}
934
935void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
936  gles2::cmds::Scissor* c = GetCmdSpace<gles2::cmds::Scissor>();
937  if (c) {
938    c->Init(x, y, width, height);
939  }
940}
941
942void ShaderBinary(GLsizei n,
943                  uint32_t shaders_shm_id,
944                  uint32_t shaders_shm_offset,
945                  GLenum binaryformat,
946                  uint32_t binary_shm_id,
947                  uint32_t binary_shm_offset,
948                  GLsizei length) {
949  gles2::cmds::ShaderBinary* c = GetCmdSpace<gles2::cmds::ShaderBinary>();
950  if (c) {
951    c->Init(n,
952            shaders_shm_id,
953            shaders_shm_offset,
954            binaryformat,
955            binary_shm_id,
956            binary_shm_offset,
957            length);
958  }
959}
960
961void ShaderSourceBucket(GLuint shader, uint32_t data_bucket_id) {
962  gles2::cmds::ShaderSourceBucket* c =
963      GetCmdSpace<gles2::cmds::ShaderSourceBucket>();
964  if (c) {
965    c->Init(shader, data_bucket_id);
966  }
967}
968
969void StencilFunc(GLenum func, GLint ref, GLuint mask) {
970  gles2::cmds::StencilFunc* c = GetCmdSpace<gles2::cmds::StencilFunc>();
971  if (c) {
972    c->Init(func, ref, mask);
973  }
974}
975
976void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
977  gles2::cmds::StencilFuncSeparate* c =
978      GetCmdSpace<gles2::cmds::StencilFuncSeparate>();
979  if (c) {
980    c->Init(face, func, ref, mask);
981  }
982}
983
984void StencilMask(GLuint mask) {
985  gles2::cmds::StencilMask* c = GetCmdSpace<gles2::cmds::StencilMask>();
986  if (c) {
987    c->Init(mask);
988  }
989}
990
991void StencilMaskSeparate(GLenum face, GLuint mask) {
992  gles2::cmds::StencilMaskSeparate* c =
993      GetCmdSpace<gles2::cmds::StencilMaskSeparate>();
994  if (c) {
995    c->Init(face, mask);
996  }
997}
998
999void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1000  gles2::cmds::StencilOp* c = GetCmdSpace<gles2::cmds::StencilOp>();
1001  if (c) {
1002    c->Init(fail, zfail, zpass);
1003  }
1004}
1005
1006void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
1007  gles2::cmds::StencilOpSeparate* c =
1008      GetCmdSpace<gles2::cmds::StencilOpSeparate>();
1009  if (c) {
1010    c->Init(face, fail, zfail, zpass);
1011  }
1012}
1013
1014void TexImage2D(GLenum target,
1015                GLint level,
1016                GLint internalformat,
1017                GLsizei width,
1018                GLsizei height,
1019                GLenum format,
1020                GLenum type,
1021                uint32_t pixels_shm_id,
1022                uint32_t pixels_shm_offset) {
1023  gles2::cmds::TexImage2D* c = GetCmdSpace<gles2::cmds::TexImage2D>();
1024  if (c) {
1025    c->Init(target,
1026            level,
1027            internalformat,
1028            width,
1029            height,
1030            format,
1031            type,
1032            pixels_shm_id,
1033            pixels_shm_offset);
1034  }
1035}
1036
1037void TexParameterf(GLenum target, GLenum pname, GLfloat param) {
1038  gles2::cmds::TexParameterf* c = GetCmdSpace<gles2::cmds::TexParameterf>();
1039  if (c) {
1040    c->Init(target, pname, param);
1041  }
1042}
1043
1044void TexParameterfvImmediate(GLenum target,
1045                             GLenum pname,
1046                             const GLfloat* params) {
1047  const uint32_t size = gles2::cmds::TexParameterfvImmediate::ComputeSize();
1048  gles2::cmds::TexParameterfvImmediate* c =
1049      GetImmediateCmdSpaceTotalSize<gles2::cmds::TexParameterfvImmediate>(size);
1050  if (c) {
1051    c->Init(target, pname, params);
1052  }
1053}
1054
1055void TexParameteri(GLenum target, GLenum pname, GLint param) {
1056  gles2::cmds::TexParameteri* c = GetCmdSpace<gles2::cmds::TexParameteri>();
1057  if (c) {
1058    c->Init(target, pname, param);
1059  }
1060}
1061
1062void TexParameterivImmediate(GLenum target, GLenum pname, const GLint* params) {
1063  const uint32_t size = gles2::cmds::TexParameterivImmediate::ComputeSize();
1064  gles2::cmds::TexParameterivImmediate* c =
1065      GetImmediateCmdSpaceTotalSize<gles2::cmds::TexParameterivImmediate>(size);
1066  if (c) {
1067    c->Init(target, pname, params);
1068  }
1069}
1070
1071void TexSubImage2D(GLenum target,
1072                   GLint level,
1073                   GLint xoffset,
1074                   GLint yoffset,
1075                   GLsizei width,
1076                   GLsizei height,
1077                   GLenum format,
1078                   GLenum type,
1079                   uint32_t pixels_shm_id,
1080                   uint32_t pixels_shm_offset,
1081                   GLboolean internal) {
1082  gles2::cmds::TexSubImage2D* c = GetCmdSpace<gles2::cmds::TexSubImage2D>();
1083  if (c) {
1084    c->Init(target,
1085            level,
1086            xoffset,
1087            yoffset,
1088            width,
1089            height,
1090            format,
1091            type,
1092            pixels_shm_id,
1093            pixels_shm_offset,
1094            internal);
1095  }
1096}
1097
1098void Uniform1f(GLint location, GLfloat x) {
1099  gles2::cmds::Uniform1f* c = GetCmdSpace<gles2::cmds::Uniform1f>();
1100  if (c) {
1101    c->Init(location, x);
1102  }
1103}
1104
1105void Uniform1fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1106  const uint32_t size = gles2::cmds::Uniform1fvImmediate::ComputeSize(count);
1107  gles2::cmds::Uniform1fvImmediate* c =
1108      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1fvImmediate>(size);
1109  if (c) {
1110    c->Init(location, count, v);
1111  }
1112}
1113
1114void Uniform1i(GLint location, GLint x) {
1115  gles2::cmds::Uniform1i* c = GetCmdSpace<gles2::cmds::Uniform1i>();
1116  if (c) {
1117    c->Init(location, x);
1118  }
1119}
1120
1121void Uniform1ivImmediate(GLint location, GLsizei count, const GLint* v) {
1122  const uint32_t size = gles2::cmds::Uniform1ivImmediate::ComputeSize(count);
1123  gles2::cmds::Uniform1ivImmediate* c =
1124      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1ivImmediate>(size);
1125  if (c) {
1126    c->Init(location, count, v);
1127  }
1128}
1129
1130void Uniform2f(GLint location, GLfloat x, GLfloat y) {
1131  gles2::cmds::Uniform2f* c = GetCmdSpace<gles2::cmds::Uniform2f>();
1132  if (c) {
1133    c->Init(location, x, y);
1134  }
1135}
1136
1137void Uniform2fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1138  const uint32_t size = gles2::cmds::Uniform2fvImmediate::ComputeSize(count);
1139  gles2::cmds::Uniform2fvImmediate* c =
1140      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2fvImmediate>(size);
1141  if (c) {
1142    c->Init(location, count, v);
1143  }
1144}
1145
1146void Uniform2i(GLint location, GLint x, GLint y) {
1147  gles2::cmds::Uniform2i* c = GetCmdSpace<gles2::cmds::Uniform2i>();
1148  if (c) {
1149    c->Init(location, x, y);
1150  }
1151}
1152
1153void Uniform2ivImmediate(GLint location, GLsizei count, const GLint* v) {
1154  const uint32_t size = gles2::cmds::Uniform2ivImmediate::ComputeSize(count);
1155  gles2::cmds::Uniform2ivImmediate* c =
1156      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2ivImmediate>(size);
1157  if (c) {
1158    c->Init(location, count, v);
1159  }
1160}
1161
1162void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
1163  gles2::cmds::Uniform3f* c = GetCmdSpace<gles2::cmds::Uniform3f>();
1164  if (c) {
1165    c->Init(location, x, y, z);
1166  }
1167}
1168
1169void Uniform3fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1170  const uint32_t size = gles2::cmds::Uniform3fvImmediate::ComputeSize(count);
1171  gles2::cmds::Uniform3fvImmediate* c =
1172      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3fvImmediate>(size);
1173  if (c) {
1174    c->Init(location, count, v);
1175  }
1176}
1177
1178void Uniform3i(GLint location, GLint x, GLint y, GLint z) {
1179  gles2::cmds::Uniform3i* c = GetCmdSpace<gles2::cmds::Uniform3i>();
1180  if (c) {
1181    c->Init(location, x, y, z);
1182  }
1183}
1184
1185void Uniform3ivImmediate(GLint location, GLsizei count, const GLint* v) {
1186  const uint32_t size = gles2::cmds::Uniform3ivImmediate::ComputeSize(count);
1187  gles2::cmds::Uniform3ivImmediate* c =
1188      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3ivImmediate>(size);
1189  if (c) {
1190    c->Init(location, count, v);
1191  }
1192}
1193
1194void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
1195  gles2::cmds::Uniform4f* c = GetCmdSpace<gles2::cmds::Uniform4f>();
1196  if (c) {
1197    c->Init(location, x, y, z, w);
1198  }
1199}
1200
1201void Uniform4fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1202  const uint32_t size = gles2::cmds::Uniform4fvImmediate::ComputeSize(count);
1203  gles2::cmds::Uniform4fvImmediate* c =
1204      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4fvImmediate>(size);
1205  if (c) {
1206    c->Init(location, count, v);
1207  }
1208}
1209
1210void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
1211  gles2::cmds::Uniform4i* c = GetCmdSpace<gles2::cmds::Uniform4i>();
1212  if (c) {
1213    c->Init(location, x, y, z, w);
1214  }
1215}
1216
1217void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) {
1218  const uint32_t size = gles2::cmds::Uniform4ivImmediate::ComputeSize(count);
1219  gles2::cmds::Uniform4ivImmediate* c =
1220      GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4ivImmediate>(size);
1221  if (c) {
1222    c->Init(location, count, v);
1223  }
1224}
1225
1226void UniformMatrix2fvImmediate(GLint location,
1227                               GLsizei count,
1228                               const GLfloat* value) {
1229  const uint32_t size =
1230      gles2::cmds::UniformMatrix2fvImmediate::ComputeSize(count);
1231  gles2::cmds::UniformMatrix2fvImmediate* c =
1232      GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix2fvImmediate>(
1233          size);
1234  if (c) {
1235    c->Init(location, count, value);
1236  }
1237}
1238
1239void UniformMatrix3fvImmediate(GLint location,
1240                               GLsizei count,
1241                               const GLfloat* value) {
1242  const uint32_t size =
1243      gles2::cmds::UniformMatrix3fvImmediate::ComputeSize(count);
1244  gles2::cmds::UniformMatrix3fvImmediate* c =
1245      GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix3fvImmediate>(
1246          size);
1247  if (c) {
1248    c->Init(location, count, value);
1249  }
1250}
1251
1252void UniformMatrix4fvImmediate(GLint location,
1253                               GLsizei count,
1254                               const GLfloat* value) {
1255  const uint32_t size =
1256      gles2::cmds::UniformMatrix4fvImmediate::ComputeSize(count);
1257  gles2::cmds::UniformMatrix4fvImmediate* c =
1258      GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix4fvImmediate>(
1259          size);
1260  if (c) {
1261    c->Init(location, count, value);
1262  }
1263}
1264
1265void UseProgram(GLuint program) {
1266  gles2::cmds::UseProgram* c = GetCmdSpace<gles2::cmds::UseProgram>();
1267  if (c) {
1268    c->Init(program);
1269  }
1270}
1271
1272void ValidateProgram(GLuint program) {
1273  gles2::cmds::ValidateProgram* c = GetCmdSpace<gles2::cmds::ValidateProgram>();
1274  if (c) {
1275    c->Init(program);
1276  }
1277}
1278
1279void VertexAttrib1f(GLuint indx, GLfloat x) {
1280  gles2::cmds::VertexAttrib1f* c = GetCmdSpace<gles2::cmds::VertexAttrib1f>();
1281  if (c) {
1282    c->Init(indx, x);
1283  }
1284}
1285
1286void VertexAttrib1fvImmediate(GLuint indx, const GLfloat* values) {
1287  const uint32_t size = gles2::cmds::VertexAttrib1fvImmediate::ComputeSize();
1288  gles2::cmds::VertexAttrib1fvImmediate* c =
1289      GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib1fvImmediate>(
1290          size);
1291  if (c) {
1292    c->Init(indx, values);
1293  }
1294}
1295
1296void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
1297  gles2::cmds::VertexAttrib2f* c = GetCmdSpace<gles2::cmds::VertexAttrib2f>();
1298  if (c) {
1299    c->Init(indx, x, y);
1300  }
1301}
1302
1303void VertexAttrib2fvImmediate(GLuint indx, const GLfloat* values) {
1304  const uint32_t size = gles2::cmds::VertexAttrib2fvImmediate::ComputeSize();
1305  gles2::cmds::VertexAttrib2fvImmediate* c =
1306      GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib2fvImmediate>(
1307          size);
1308  if (c) {
1309    c->Init(indx, values);
1310  }
1311}
1312
1313void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
1314  gles2::cmds::VertexAttrib3f* c = GetCmdSpace<gles2::cmds::VertexAttrib3f>();
1315  if (c) {
1316    c->Init(indx, x, y, z);
1317  }
1318}
1319
1320void VertexAttrib3fvImmediate(GLuint indx, const GLfloat* values) {
1321  const uint32_t size = gles2::cmds::VertexAttrib3fvImmediate::ComputeSize();
1322  gles2::cmds::VertexAttrib3fvImmediate* c =
1323      GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib3fvImmediate>(
1324          size);
1325  if (c) {
1326    c->Init(indx, values);
1327  }
1328}
1329
1330void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
1331  gles2::cmds::VertexAttrib4f* c = GetCmdSpace<gles2::cmds::VertexAttrib4f>();
1332  if (c) {
1333    c->Init(indx, x, y, z, w);
1334  }
1335}
1336
1337void VertexAttrib4fvImmediate(GLuint indx, const GLfloat* values) {
1338  const uint32_t size = gles2::cmds::VertexAttrib4fvImmediate::ComputeSize();
1339  gles2::cmds::VertexAttrib4fvImmediate* c =
1340      GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib4fvImmediate>(
1341          size);
1342  if (c) {
1343    c->Init(indx, values);
1344  }
1345}
1346
1347void VertexAttribPointer(GLuint indx,
1348                         GLint size,
1349                         GLenum type,
1350                         GLboolean normalized,
1351                         GLsizei stride,
1352                         GLuint offset) {
1353  gles2::cmds::VertexAttribPointer* c =
1354      GetCmdSpace<gles2::cmds::VertexAttribPointer>();
1355  if (c) {
1356    c->Init(indx, size, type, normalized, stride, offset);
1357  }
1358}
1359
1360void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1361  gles2::cmds::Viewport* c = GetCmdSpace<gles2::cmds::Viewport>();
1362  if (c) {
1363    c->Init(x, y, width, height);
1364  }
1365}
1366
1367void BlitFramebufferCHROMIUM(GLint srcX0,
1368                             GLint srcY0,
1369                             GLint srcX1,
1370                             GLint srcY1,
1371                             GLint dstX0,
1372                             GLint dstY0,
1373                             GLint dstX1,
1374                             GLint dstY1,
1375                             GLbitfield mask,
1376                             GLenum filter) {
1377  gles2::cmds::BlitFramebufferCHROMIUM* c =
1378      GetCmdSpace<gles2::cmds::BlitFramebufferCHROMIUM>();
1379  if (c) {
1380    c->Init(
1381        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1382  }
1383}
1384
1385void RenderbufferStorageMultisampleCHROMIUM(GLenum target,
1386                                            GLsizei samples,
1387                                            GLenum internalformat,
1388                                            GLsizei width,
1389                                            GLsizei height) {
1390  gles2::cmds::RenderbufferStorageMultisampleCHROMIUM* c =
1391      GetCmdSpace<gles2::cmds::RenderbufferStorageMultisampleCHROMIUM>();
1392  if (c) {
1393    c->Init(target, samples, internalformat, width, height);
1394  }
1395}
1396
1397void RenderbufferStorageMultisampleEXT(GLenum target,
1398                                       GLsizei samples,
1399                                       GLenum internalformat,
1400                                       GLsizei width,
1401                                       GLsizei height) {
1402  gles2::cmds::RenderbufferStorageMultisampleEXT* c =
1403      GetCmdSpace<gles2::cmds::RenderbufferStorageMultisampleEXT>();
1404  if (c) {
1405    c->Init(target, samples, internalformat, width, height);
1406  }
1407}
1408
1409void FramebufferTexture2DMultisampleEXT(GLenum target,
1410                                        GLenum attachment,
1411                                        GLenum textarget,
1412                                        GLuint texture,
1413                                        GLsizei samples) {
1414  gles2::cmds::FramebufferTexture2DMultisampleEXT* c =
1415      GetCmdSpace<gles2::cmds::FramebufferTexture2DMultisampleEXT>();
1416  if (c) {
1417    c->Init(target, attachment, textarget, texture, samples);
1418  }
1419}
1420
1421void TexStorage2DEXT(GLenum target,
1422                     GLsizei levels,
1423                     GLenum internalFormat,
1424                     GLsizei width,
1425                     GLsizei height) {
1426  gles2::cmds::TexStorage2DEXT* c = GetCmdSpace<gles2::cmds::TexStorage2DEXT>();
1427  if (c) {
1428    c->Init(target, levels, internalFormat, width, height);
1429  }
1430}
1431
1432void GenQueriesEXTImmediate(GLsizei n, GLuint* queries) {
1433  const uint32_t size = gles2::cmds::GenQueriesEXTImmediate::ComputeSize(n);
1434  gles2::cmds::GenQueriesEXTImmediate* c =
1435      GetImmediateCmdSpaceTotalSize<gles2::cmds::GenQueriesEXTImmediate>(size);
1436  if (c) {
1437    c->Init(n, queries);
1438  }
1439}
1440
1441void DeleteQueriesEXTImmediate(GLsizei n, const GLuint* queries) {
1442  const uint32_t size = gles2::cmds::DeleteQueriesEXTImmediate::ComputeSize(n);
1443  gles2::cmds::DeleteQueriesEXTImmediate* c =
1444      GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteQueriesEXTImmediate>(
1445          size);
1446  if (c) {
1447    c->Init(n, queries);
1448  }
1449}
1450
1451void BeginQueryEXT(GLenum target,
1452                   GLuint id,
1453                   uint32_t sync_data_shm_id,
1454                   uint32_t sync_data_shm_offset) {
1455  gles2::cmds::BeginQueryEXT* c = GetCmdSpace<gles2::cmds::BeginQueryEXT>();
1456  if (c) {
1457    c->Init(target, id, sync_data_shm_id, sync_data_shm_offset);
1458  }
1459}
1460
1461void EndQueryEXT(GLenum target, GLuint submit_count) {
1462  gles2::cmds::EndQueryEXT* c = GetCmdSpace<gles2::cmds::EndQueryEXT>();
1463  if (c) {
1464    c->Init(target, submit_count);
1465  }
1466}
1467
1468void InsertEventMarkerEXT(GLuint bucket_id) {
1469  gles2::cmds::InsertEventMarkerEXT* c =
1470      GetCmdSpace<gles2::cmds::InsertEventMarkerEXT>();
1471  if (c) {
1472    c->Init(bucket_id);
1473  }
1474}
1475
1476void PushGroupMarkerEXT(GLuint bucket_id) {
1477  gles2::cmds::PushGroupMarkerEXT* c =
1478      GetCmdSpace<gles2::cmds::PushGroupMarkerEXT>();
1479  if (c) {
1480    c->Init(bucket_id);
1481  }
1482}
1483
1484void PopGroupMarkerEXT() {
1485  gles2::cmds::PopGroupMarkerEXT* c =
1486      GetCmdSpace<gles2::cmds::PopGroupMarkerEXT>();
1487  if (c) {
1488    c->Init();
1489  }
1490}
1491
1492void GenVertexArraysOESImmediate(GLsizei n, GLuint* arrays) {
1493  const uint32_t size =
1494      gles2::cmds::GenVertexArraysOESImmediate::ComputeSize(n);
1495  gles2::cmds::GenVertexArraysOESImmediate* c =
1496      GetImmediateCmdSpaceTotalSize<gles2::cmds::GenVertexArraysOESImmediate>(
1497          size);
1498  if (c) {
1499    c->Init(n, arrays);
1500  }
1501}
1502
1503void DeleteVertexArraysOESImmediate(GLsizei n, const GLuint* arrays) {
1504  const uint32_t size =
1505      gles2::cmds::DeleteVertexArraysOESImmediate::ComputeSize(n);
1506  gles2::cmds::DeleteVertexArraysOESImmediate* c =
1507      GetImmediateCmdSpaceTotalSize<
1508          gles2::cmds::DeleteVertexArraysOESImmediate>(size);
1509  if (c) {
1510    c->Init(n, arrays);
1511  }
1512}
1513
1514void IsVertexArrayOES(GLuint array,
1515                      uint32_t result_shm_id,
1516                      uint32_t result_shm_offset) {
1517  gles2::cmds::IsVertexArrayOES* c =
1518      GetCmdSpace<gles2::cmds::IsVertexArrayOES>();
1519  if (c) {
1520    c->Init(array, result_shm_id, result_shm_offset);
1521  }
1522}
1523
1524void BindVertexArrayOES(GLuint array) {
1525  gles2::cmds::BindVertexArrayOES* c =
1526      GetCmdSpace<gles2::cmds::BindVertexArrayOES>();
1527  if (c) {
1528    c->Init(array);
1529  }
1530}
1531
1532void SwapBuffers() {
1533  gles2::cmds::SwapBuffers* c = GetCmdSpace<gles2::cmds::SwapBuffers>();
1534  if (c) {
1535    c->Init();
1536  }
1537}
1538
1539void GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1540                                 GLsizei count,
1541                                 GLenum type,
1542                                 GLuint offset,
1543                                 uint32_t result_shm_id,
1544                                 uint32_t result_shm_offset) {
1545  gles2::cmds::GetMaxValueInBufferCHROMIUM* c =
1546      GetCmdSpace<gles2::cmds::GetMaxValueInBufferCHROMIUM>();
1547  if (c) {
1548    c->Init(buffer_id, count, type, offset, result_shm_id, result_shm_offset);
1549  }
1550}
1551
1552void GenSharedIdsCHROMIUM(GLuint namespace_id,
1553                          GLuint id_offset,
1554                          GLsizei n,
1555                          uint32_t ids_shm_id,
1556                          uint32_t ids_shm_offset) {
1557  gles2::cmds::GenSharedIdsCHROMIUM* c =
1558      GetCmdSpace<gles2::cmds::GenSharedIdsCHROMIUM>();
1559  if (c) {
1560    c->Init(namespace_id, id_offset, n, ids_shm_id, ids_shm_offset);
1561  }
1562}
1563
1564void DeleteSharedIdsCHROMIUM(GLuint namespace_id,
1565                             GLsizei n,
1566                             uint32_t ids_shm_id,
1567                             uint32_t ids_shm_offset) {
1568  gles2::cmds::DeleteSharedIdsCHROMIUM* c =
1569      GetCmdSpace<gles2::cmds::DeleteSharedIdsCHROMIUM>();
1570  if (c) {
1571    c->Init(namespace_id, n, ids_shm_id, ids_shm_offset);
1572  }
1573}
1574
1575void RegisterSharedIdsCHROMIUM(GLuint namespace_id,
1576                               GLsizei n,
1577                               uint32_t ids_shm_id,
1578                               uint32_t ids_shm_offset) {
1579  gles2::cmds::RegisterSharedIdsCHROMIUM* c =
1580      GetCmdSpace<gles2::cmds::RegisterSharedIdsCHROMIUM>();
1581  if (c) {
1582    c->Init(namespace_id, n, ids_shm_id, ids_shm_offset);
1583  }
1584}
1585
1586void EnableFeatureCHROMIUM(GLuint bucket_id,
1587                           uint32_t result_shm_id,
1588                           uint32_t result_shm_offset) {
1589  gles2::cmds::EnableFeatureCHROMIUM* c =
1590      GetCmdSpace<gles2::cmds::EnableFeatureCHROMIUM>();
1591  if (c) {
1592    c->Init(bucket_id, result_shm_id, result_shm_offset);
1593  }
1594}
1595
1596void ResizeCHROMIUM(GLuint width, GLuint height, GLfloat scale_factor) {
1597  gles2::cmds::ResizeCHROMIUM* c = GetCmdSpace<gles2::cmds::ResizeCHROMIUM>();
1598  if (c) {
1599    c->Init(width, height, scale_factor);
1600  }
1601}
1602
1603void GetRequestableExtensionsCHROMIUM(uint32_t bucket_id) {
1604  gles2::cmds::GetRequestableExtensionsCHROMIUM* c =
1605      GetCmdSpace<gles2::cmds::GetRequestableExtensionsCHROMIUM>();
1606  if (c) {
1607    c->Init(bucket_id);
1608  }
1609}
1610
1611void RequestExtensionCHROMIUM(uint32_t bucket_id) {
1612  gles2::cmds::RequestExtensionCHROMIUM* c =
1613      GetCmdSpace<gles2::cmds::RequestExtensionCHROMIUM>();
1614  if (c) {
1615    c->Init(bucket_id);
1616  }
1617}
1618
1619void GetMultipleIntegervCHROMIUM(uint32_t pnames_shm_id,
1620                                 uint32_t pnames_shm_offset,
1621                                 GLuint count,
1622                                 uint32_t results_shm_id,
1623                                 uint32_t results_shm_offset,
1624                                 GLsizeiptr size) {
1625  gles2::cmds::GetMultipleIntegervCHROMIUM* c =
1626      GetCmdSpace<gles2::cmds::GetMultipleIntegervCHROMIUM>();
1627  if (c) {
1628    c->Init(pnames_shm_id,
1629            pnames_shm_offset,
1630            count,
1631            results_shm_id,
1632            results_shm_offset,
1633            size);
1634  }
1635}
1636
1637void GetProgramInfoCHROMIUM(GLuint program, uint32_t bucket_id) {
1638  gles2::cmds::GetProgramInfoCHROMIUM* c =
1639      GetCmdSpace<gles2::cmds::GetProgramInfoCHROMIUM>();
1640  if (c) {
1641    c->Init(program, bucket_id);
1642  }
1643}
1644
1645void GetTranslatedShaderSourceANGLE(GLuint shader, uint32_t bucket_id) {
1646  gles2::cmds::GetTranslatedShaderSourceANGLE* c =
1647      GetCmdSpace<gles2::cmds::GetTranslatedShaderSourceANGLE>();
1648  if (c) {
1649    c->Init(shader, bucket_id);
1650  }
1651}
1652
1653void PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
1654  gles2::cmds::PostSubBufferCHROMIUM* c =
1655      GetCmdSpace<gles2::cmds::PostSubBufferCHROMIUM>();
1656  if (c) {
1657    c->Init(x, y, width, height);
1658  }
1659}
1660
1661void TexImageIOSurface2DCHROMIUM(GLenum target,
1662                                 GLsizei width,
1663                                 GLsizei height,
1664                                 GLuint ioSurfaceId,
1665                                 GLuint plane) {
1666  gles2::cmds::TexImageIOSurface2DCHROMIUM* c =
1667      GetCmdSpace<gles2::cmds::TexImageIOSurface2DCHROMIUM>();
1668  if (c) {
1669    c->Init(target, width, height, ioSurfaceId, plane);
1670  }
1671}
1672
1673void CopyTextureCHROMIUM(GLenum target,
1674                         GLenum source_id,
1675                         GLenum dest_id,
1676                         GLint level,
1677                         GLint internalformat,
1678                         GLenum dest_type) {
1679  gles2::cmds::CopyTextureCHROMIUM* c =
1680      GetCmdSpace<gles2::cmds::CopyTextureCHROMIUM>();
1681  if (c) {
1682    c->Init(target, source_id, dest_id, level, internalformat, dest_type);
1683  }
1684}
1685
1686void DrawArraysInstancedANGLE(GLenum mode,
1687                              GLint first,
1688                              GLsizei count,
1689                              GLsizei primcount) {
1690  gles2::cmds::DrawArraysInstancedANGLE* c =
1691      GetCmdSpace<gles2::cmds::DrawArraysInstancedANGLE>();
1692  if (c) {
1693    c->Init(mode, first, count, primcount);
1694  }
1695}
1696
1697void DrawElementsInstancedANGLE(GLenum mode,
1698                                GLsizei count,
1699                                GLenum type,
1700                                GLuint index_offset,
1701                                GLsizei primcount) {
1702  gles2::cmds::DrawElementsInstancedANGLE* c =
1703      GetCmdSpace<gles2::cmds::DrawElementsInstancedANGLE>();
1704  if (c) {
1705    c->Init(mode, count, type, index_offset, primcount);
1706  }
1707}
1708
1709void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1710  gles2::cmds::VertexAttribDivisorANGLE* c =
1711      GetCmdSpace<gles2::cmds::VertexAttribDivisorANGLE>();
1712  if (c) {
1713    c->Init(index, divisor);
1714  }
1715}
1716
1717void ProduceTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
1718  const uint32_t size =
1719      gles2::cmds::ProduceTextureCHROMIUMImmediate::ComputeSize();
1720  gles2::cmds::ProduceTextureCHROMIUMImmediate* c =
1721      GetImmediateCmdSpaceTotalSize<
1722          gles2::cmds::ProduceTextureCHROMIUMImmediate>(size);
1723  if (c) {
1724    c->Init(target, mailbox);
1725  }
1726}
1727
1728void ProduceTextureDirectCHROMIUMImmediate(GLuint texture,
1729                                           GLenum target,
1730                                           const GLbyte* mailbox) {
1731  const uint32_t size =
1732      gles2::cmds::ProduceTextureDirectCHROMIUMImmediate::ComputeSize();
1733  gles2::cmds::ProduceTextureDirectCHROMIUMImmediate* c =
1734      GetImmediateCmdSpaceTotalSize<
1735          gles2::cmds::ProduceTextureDirectCHROMIUMImmediate>(size);
1736  if (c) {
1737    c->Init(texture, target, mailbox);
1738  }
1739}
1740
1741void ConsumeTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
1742  const uint32_t size =
1743      gles2::cmds::ConsumeTextureCHROMIUMImmediate::ComputeSize();
1744  gles2::cmds::ConsumeTextureCHROMIUMImmediate* c =
1745      GetImmediateCmdSpaceTotalSize<
1746          gles2::cmds::ConsumeTextureCHROMIUMImmediate>(size);
1747  if (c) {
1748    c->Init(target, mailbox);
1749  }
1750}
1751
1752void BindUniformLocationCHROMIUMBucket(GLuint program,
1753                                       GLint location,
1754                                       uint32_t name_bucket_id) {
1755  gles2::cmds::BindUniformLocationCHROMIUMBucket* c =
1756      GetCmdSpace<gles2::cmds::BindUniformLocationCHROMIUMBucket>();
1757  if (c) {
1758    c->Init(program, location, name_bucket_id);
1759  }
1760}
1761
1762void BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1763  gles2::cmds::BindTexImage2DCHROMIUM* c =
1764      GetCmdSpace<gles2::cmds::BindTexImage2DCHROMIUM>();
1765  if (c) {
1766    c->Init(target, imageId);
1767  }
1768}
1769
1770void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1771  gles2::cmds::ReleaseTexImage2DCHROMIUM* c =
1772      GetCmdSpace<gles2::cmds::ReleaseTexImage2DCHROMIUM>();
1773  if (c) {
1774    c->Init(target, imageId);
1775  }
1776}
1777
1778void TraceBeginCHROMIUM(GLuint bucket_id) {
1779  gles2::cmds::TraceBeginCHROMIUM* c =
1780      GetCmdSpace<gles2::cmds::TraceBeginCHROMIUM>();
1781  if (c) {
1782    c->Init(bucket_id);
1783  }
1784}
1785
1786void TraceEndCHROMIUM() {
1787  gles2::cmds::TraceEndCHROMIUM* c =
1788      GetCmdSpace<gles2::cmds::TraceEndCHROMIUM>();
1789  if (c) {
1790    c->Init();
1791  }
1792}
1793
1794void AsyncTexSubImage2DCHROMIUM(GLenum target,
1795                                GLint level,
1796                                GLint xoffset,
1797                                GLint yoffset,
1798                                GLsizei width,
1799                                GLsizei height,
1800                                GLenum format,
1801                                GLenum type,
1802                                uint32_t data_shm_id,
1803                                uint32_t data_shm_offset,
1804                                uint32_t async_upload_token,
1805                                uint32_t sync_data_shm_id,
1806                                uint32_t sync_data_shm_offset) {
1807  gles2::cmds::AsyncTexSubImage2DCHROMIUM* c =
1808      GetCmdSpace<gles2::cmds::AsyncTexSubImage2DCHROMIUM>();
1809  if (c) {
1810    c->Init(target,
1811            level,
1812            xoffset,
1813            yoffset,
1814            width,
1815            height,
1816            format,
1817            type,
1818            data_shm_id,
1819            data_shm_offset,
1820            async_upload_token,
1821            sync_data_shm_id,
1822            sync_data_shm_offset);
1823  }
1824}
1825
1826void AsyncTexImage2DCHROMIUM(GLenum target,
1827                             GLint level,
1828                             GLint internalformat,
1829                             GLsizei width,
1830                             GLsizei height,
1831                             GLenum format,
1832                             GLenum type,
1833                             uint32_t pixels_shm_id,
1834                             uint32_t pixels_shm_offset,
1835                             uint32_t async_upload_token,
1836                             uint32_t sync_data_shm_id,
1837                             uint32_t sync_data_shm_offset) {
1838  gles2::cmds::AsyncTexImage2DCHROMIUM* c =
1839      GetCmdSpace<gles2::cmds::AsyncTexImage2DCHROMIUM>();
1840  if (c) {
1841    c->Init(target,
1842            level,
1843            internalformat,
1844            width,
1845            height,
1846            format,
1847            type,
1848            pixels_shm_id,
1849            pixels_shm_offset,
1850            async_upload_token,
1851            sync_data_shm_id,
1852            sync_data_shm_offset);
1853  }
1854}
1855
1856void WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1857  gles2::cmds::WaitAsyncTexImage2DCHROMIUM* c =
1858      GetCmdSpace<gles2::cmds::WaitAsyncTexImage2DCHROMIUM>();
1859  if (c) {
1860    c->Init(target);
1861  }
1862}
1863
1864void WaitAllAsyncTexImage2DCHROMIUM() {
1865  gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM* c =
1866      GetCmdSpace<gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM>();
1867  if (c) {
1868    c->Init();
1869  }
1870}
1871
1872void DiscardFramebufferEXTImmediate(GLenum target,
1873                                    GLsizei count,
1874                                    const GLenum* attachments) {
1875  const uint32_t size =
1876      gles2::cmds::DiscardFramebufferEXTImmediate::ComputeSize(count);
1877  gles2::cmds::DiscardFramebufferEXTImmediate* c =
1878      GetImmediateCmdSpaceTotalSize<
1879          gles2::cmds::DiscardFramebufferEXTImmediate>(size);
1880  if (c) {
1881    c->Init(target, count, attachments);
1882  }
1883}
1884
1885void LoseContextCHROMIUM(GLenum current, GLenum other) {
1886  gles2::cmds::LoseContextCHROMIUM* c =
1887      GetCmdSpace<gles2::cmds::LoseContextCHROMIUM>();
1888  if (c) {
1889    c->Init(current, other);
1890  }
1891}
1892
1893void WaitSyncPointCHROMIUM(GLuint sync_point) {
1894  gles2::cmds::WaitSyncPointCHROMIUM* c =
1895      GetCmdSpace<gles2::cmds::WaitSyncPointCHROMIUM>();
1896  if (c) {
1897    c->Init(sync_point);
1898  }
1899}
1900
1901void DrawBuffersEXTImmediate(GLsizei count, const GLenum* bufs) {
1902  const uint32_t size =
1903      gles2::cmds::DrawBuffersEXTImmediate::ComputeSize(count);
1904  gles2::cmds::DrawBuffersEXTImmediate* c =
1905      GetImmediateCmdSpaceTotalSize<gles2::cmds::DrawBuffersEXTImmediate>(size);
1906  if (c) {
1907    c->Init(count, bufs);
1908  }
1909}
1910
1911void DiscardBackbufferCHROMIUM() {
1912  gles2::cmds::DiscardBackbufferCHROMIUM* c =
1913      GetCmdSpace<gles2::cmds::DiscardBackbufferCHROMIUM>();
1914  if (c) {
1915    c->Init();
1916  }
1917}
1918
1919void ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1920                                  GLenum plane_transform,
1921                                  GLuint overlay_texture_id,
1922                                  GLint bounds_x,
1923                                  GLint bounds_y,
1924                                  GLint bounds_width,
1925                                  GLint bounds_height,
1926                                  GLfloat uv_x,
1927                                  GLfloat uv_y,
1928                                  GLfloat uv_width,
1929                                  GLfloat uv_height) {
1930  gles2::cmds::ScheduleOverlayPlaneCHROMIUM* c =
1931      GetCmdSpace<gles2::cmds::ScheduleOverlayPlaneCHROMIUM>();
1932  if (c) {
1933    c->Init(plane_z_order,
1934            plane_transform,
1935            overlay_texture_id,
1936            bounds_x,
1937            bounds_y,
1938            bounds_width,
1939            bounds_height,
1940            uv_x,
1941            uv_y,
1942            uv_width,
1943            uv_height);
1944  }
1945}
1946
1947void MatrixLoadfCHROMIUMImmediate(GLenum matrixMode, const GLfloat* m) {
1948  const uint32_t size =
1949      gles2::cmds::MatrixLoadfCHROMIUMImmediate::ComputeSize();
1950  gles2::cmds::MatrixLoadfCHROMIUMImmediate* c =
1951      GetImmediateCmdSpaceTotalSize<gles2::cmds::MatrixLoadfCHROMIUMImmediate>(
1952          size);
1953  if (c) {
1954    c->Init(matrixMode, m);
1955  }
1956}
1957
1958void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1959  gles2::cmds::MatrixLoadIdentityCHROMIUM* c =
1960      GetCmdSpace<gles2::cmds::MatrixLoadIdentityCHROMIUM>();
1961  if (c) {
1962    c->Init(matrixMode);
1963  }
1964}
1965
1966#endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
1967