gpu/command_buffer/client/gles2_cmd_helper_autogen.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is auto-generated from
   6 // gpu/command_buffer/build_gles2_cmd_buffer.py
   7 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
  12 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
  13
  14 void ActiveTexture(GLenum texture) {
  15   gles2::cmds::ActiveTexture* c = GetCmdSpace<gles2::cmds::ActiveTexture>();
  16   if (c) {
  17     c->Init(texture);
  18   }
  19 }
  20
  21 void 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
  28 void 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
  38 void 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
  45 void BindBufferBase(GLenum target, GLuint index, GLuint buffer) {
  46   gles2::cmds::BindBufferBase* c = GetCmdSpace<gles2::cmds::BindBufferBase>();
  47   if (c) {
  48     c->Init(target, index, buffer);
  49   }
  50 }
  51
  52 void BindBufferRange(GLenum target,
  53                      GLuint index,
  54                      GLuint buffer,
  55                      GLintptr offset,
  56                      GLsizeiptr size) {
  57   gles2::cmds::BindBufferRange* c = GetCmdSpace<gles2::cmds::BindBufferRange>();
  58   if (c) {
  59     c->Init(target, index, buffer, offset, size);
  60   }
  61 }
  62
  63 void BindFramebuffer(GLenum target, GLuint framebuffer) {
  64   gles2::cmds::BindFramebuffer* c = GetCmdSpace<gles2::cmds::BindFramebuffer>();
  65   if (c) {
  66     c->Init(target, framebuffer);
  67   }
  68 }
  69
  70 void BindRenderbuffer(GLenum target, GLuint renderbuffer) {
  71   gles2::cmds::BindRenderbuffer* c =
  72       GetCmdSpace<gles2::cmds::BindRenderbuffer>();
  73   if (c) {
  74     c->Init(target, renderbuffer);
  75   }
  76 }
  77
  78 void BindSampler(GLuint unit, GLuint sampler) {
  79   gles2::cmds::BindSampler* c = GetCmdSpace<gles2::cmds::BindSampler>();
  80   if (c) {
  81     c->Init(unit, sampler);
  82   }
  83 }
  84
  85 void BindTexture(GLenum target, GLuint texture) {
  86   gles2::cmds::BindTexture* c = GetCmdSpace<gles2::cmds::BindTexture>();
  87   if (c) {
  88     c->Init(target, texture);
  89   }
  90 }
  91
  92 void BindTransformFeedback(GLenum target, GLuint transformfeedback) {
  93   gles2::cmds::BindTransformFeedback* c =
  94       GetCmdSpace<gles2::cmds::BindTransformFeedback>();
  95   if (c) {
  96     c->Init(target, transformfeedback);
  97   }
  98 }
  99
 100 void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
 101   gles2::cmds::BlendColor* c = GetCmdSpace<gles2::cmds::BlendColor>();
 102   if (c) {
 103     c->Init(red, green, blue, alpha);
 104   }
 105 }
 106
 107 void BlendEquation(GLenum mode) {
 108   gles2::cmds::BlendEquation* c = GetCmdSpace<gles2::cmds::BlendEquation>();
 109   if (c) {
 110     c->Init(mode);
 111   }
 112 }
 113
 114 void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
 115   gles2::cmds::BlendEquationSeparate* c =
 116       GetCmdSpace<gles2::cmds::BlendEquationSeparate>();
 117   if (c) {
 118     c->Init(modeRGB, modeAlpha);
 119   }
 120 }
 121
 122 void BlendFunc(GLenum sfactor, GLenum dfactor) {
 123   gles2::cmds::BlendFunc* c = GetCmdSpace<gles2::cmds::BlendFunc>();
 124   if (c) {
 125     c->Init(sfactor, dfactor);
 126   }
 127 }
 128
 129 void BlendFuncSeparate(GLenum srcRGB,
 130                        GLenum dstRGB,
 131                        GLenum srcAlpha,
 132                        GLenum dstAlpha) {
 133   gles2::cmds::BlendFuncSeparate* c =
 134       GetCmdSpace<gles2::cmds::BlendFuncSeparate>();
 135   if (c) {
 136     c->Init(srcRGB, dstRGB, srcAlpha, dstAlpha);
 137   }
 138 }
 139
 140 void BufferData(GLenum target,
 141                 GLsizeiptr size,
 142                 uint32_t data_shm_id,
 143                 uint32_t data_shm_offset,
 144                 GLenum usage) {
 145   gles2::cmds::BufferData* c = GetCmdSpace<gles2::cmds::BufferData>();
 146   if (c) {
 147     c->Init(target, size, data_shm_id, data_shm_offset, usage);
 148   }
 149 }
 150
 151 void BufferSubData(GLenum target,
 152                    GLintptr offset,
 153                    GLsizeiptr size,
 154                    uint32_t data_shm_id,
 155                    uint32_t data_shm_offset) {
 156   gles2::cmds::BufferSubData* c = GetCmdSpace<gles2::cmds::BufferSubData>();
 157   if (c) {
 158     c->Init(target, offset, size, data_shm_id, data_shm_offset);
 159   }
 160 }
 161
 162 void CheckFramebufferStatus(GLenum target,
 163                             uint32_t result_shm_id,
 164                             uint32_t result_shm_offset) {
 165   gles2::cmds::CheckFramebufferStatus* c =
 166       GetCmdSpace<gles2::cmds::CheckFramebufferStatus>();
 167   if (c) {
 168     c->Init(target, result_shm_id, result_shm_offset);
 169   }
 170 }
 171
 172 void Clear(GLbitfield mask) {
 173   gles2::cmds::Clear* c = GetCmdSpace<gles2::cmds::Clear>();
 174   if (c) {
 175     c->Init(mask);
 176   }
 177 }
 178
 179 void ClearBufferfi(GLenum buffer,
 180                    GLint drawbuffers,
 181                    GLfloat depth,
 182                    GLint stencil) {
 183   gles2::cmds::ClearBufferfi* c = GetCmdSpace<gles2::cmds::ClearBufferfi>();
 184   if (c) {
 185     c->Init(buffer, drawbuffers, depth, stencil);
 186   }
 187 }
 188
 189 void ClearBufferfvImmediate(GLenum buffer,
 190                             GLint drawbuffers,
 191                             const GLfloat* value) {
 192   const uint32_t size = gles2::cmds::ClearBufferfvImmediate::ComputeSize();
 193   gles2::cmds::ClearBufferfvImmediate* c =
 194       GetImmediateCmdSpaceTotalSize<gles2::cmds::ClearBufferfvImmediate>(size);
 195   if (c) {
 196     c->Init(buffer, drawbuffers, value);
 197   }
 198 }
 199
 200 void ClearBufferivImmediate(GLenum buffer,
 201                             GLint drawbuffers,
 202                             const GLint* value) {
 203   const uint32_t size = gles2::cmds::ClearBufferivImmediate::ComputeSize();
 204   gles2::cmds::ClearBufferivImmediate* c =
 205       GetImmediateCmdSpaceTotalSize<gles2::cmds::ClearBufferivImmediate>(size);
 206   if (c) {
 207     c->Init(buffer, drawbuffers, value);
 208   }
 209 }
 210
 211 void ClearBufferuivImmediate(GLenum buffer,
 212                              GLint drawbuffers,
 213                              const GLuint* value) {
 214   const uint32_t size = gles2::cmds::ClearBufferuivImmediate::ComputeSize();
 215   gles2::cmds::ClearBufferuivImmediate* c =
 216       GetImmediateCmdSpaceTotalSize<gles2::cmds::ClearBufferuivImmediate>(size);
 217   if (c) {
 218     c->Init(buffer, drawbuffers, value);
 219   }
 220 }
 221
 222 void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
 223   gles2::cmds::ClearColor* c = GetCmdSpace<gles2::cmds::ClearColor>();
 224   if (c) {
 225     c->Init(red, green, blue, alpha);
 226   }
 227 }
 228
 229 void ClearDepthf(GLclampf depth) {
 230   gles2::cmds::ClearDepthf* c = GetCmdSpace<gles2::cmds::ClearDepthf>();
 231   if (c) {
 232     c->Init(depth);
 233   }
 234 }
 235
 236 void ClearStencil(GLint s) {
 237   gles2::cmds::ClearStencil* c = GetCmdSpace<gles2::cmds::ClearStencil>();
 238   if (c) {
 239     c->Init(s);
 240   }
 241 }
 242
 243 void ClientWaitSync(GLuint sync,
 244                     GLbitfield flags,
 245                     GLuint timeout_0,
 246                     GLuint timeout_1,
 247                     uint32_t result_shm_id,
 248                     uint32_t result_shm_offset) {
 249   gles2::cmds::ClientWaitSync* c = GetCmdSpace<gles2::cmds::ClientWaitSync>();
 250   if (c) {
 251     c->Init(sync, flags, timeout_0, timeout_1, result_shm_id,
 252             result_shm_offset);
 253   }
 254 }
 255
 256 void ColorMask(GLboolean red,
 257                GLboolean green,
 258                GLboolean blue,
 259                GLboolean alpha) {
 260   gles2::cmds::ColorMask* c = GetCmdSpace<gles2::cmds::ColorMask>();
 261   if (c) {
 262     c->Init(red, green, blue, alpha);
 263   }
 264 }
 265
 266 void CompileShader(GLuint shader) {
 267   gles2::cmds::CompileShader* c = GetCmdSpace<gles2::cmds::CompileShader>();
 268   if (c) {
 269     c->Init(shader);
 270   }
 271 }
 272
 273 void CompressedTexImage2DBucket(GLenum target,
 274                                 GLint level,
 275                                 GLenum internalformat,
 276                                 GLsizei width,
 277                                 GLsizei height,
 278                                 GLuint bucket_id) {
 279   gles2::cmds::CompressedTexImage2DBucket* c =
 280       GetCmdSpace<gles2::cmds::CompressedTexImage2DBucket>();
 281   if (c) {
 282     c->Init(target, level, internalformat, width, height, bucket_id);
 283   }
 284 }
 285
 286 void CompressedTexImage2D(GLenum target,
 287                           GLint level,
 288                           GLenum internalformat,
 289                           GLsizei width,
 290                           GLsizei height,
 291                           GLsizei imageSize,
 292                           uint32_t data_shm_id,
 293                           uint32_t data_shm_offset) {
 294   gles2::cmds::CompressedTexImage2D* c =
 295       GetCmdSpace<gles2::cmds::CompressedTexImage2D>();
 296   if (c) {
 297     c->Init(target, level, internalformat, width, height, imageSize,
 298             data_shm_id, data_shm_offset);
 299   }
 300 }
 301
 302 void CompressedTexSubImage2DBucket(GLenum target,
 303                                    GLint level,
 304                                    GLint xoffset,
 305                                    GLint yoffset,
 306                                    GLsizei width,
 307                                    GLsizei height,
 308                                    GLenum format,
 309                                    GLuint bucket_id) {
 310   gles2::cmds::CompressedTexSubImage2DBucket* c =
 311       GetCmdSpace<gles2::cmds::CompressedTexSubImage2DBucket>();
 312   if (c) {
 313     c->Init(target, level, xoffset, yoffset, width, height, format, bucket_id);
 314   }
 315 }
 316
 317 void CompressedTexSubImage2D(GLenum target,
 318                              GLint level,
 319                              GLint xoffset,
 320                              GLint yoffset,
 321                              GLsizei width,
 322                              GLsizei height,
 323                              GLenum format,
 324                              GLsizei imageSize,
 325                              uint32_t data_shm_id,
 326                              uint32_t data_shm_offset) {
 327   gles2::cmds::CompressedTexSubImage2D* c =
 328       GetCmdSpace<gles2::cmds::CompressedTexSubImage2D>();
 329   if (c) {
 330     c->Init(target, level, xoffset, yoffset, width, height, format, imageSize,
 331             data_shm_id, data_shm_offset);
 332   }
 333 }
 334
 335 void CompressedTexImage3DBucket(GLenum target,
 336                                 GLint level,
 337                                 GLenum internalformat,
 338                                 GLsizei width,
 339                                 GLsizei height,
 340                                 GLsizei depth,
 341                                 GLuint bucket_id) {
 342   gles2::cmds::CompressedTexImage3DBucket* c =
 343       GetCmdSpace<gles2::cmds::CompressedTexImage3DBucket>();
 344   if (c) {
 345     c->Init(target, level, internalformat, width, height, depth, bucket_id);
 346   }
 347 }
 348
 349 void CompressedTexImage3D(GLenum target,
 350                           GLint level,
 351                           GLenum internalformat,
 352                           GLsizei width,
 353                           GLsizei height,
 354                           GLsizei depth,
 355                           GLsizei imageSize,
 356                           uint32_t data_shm_id,
 357                           uint32_t data_shm_offset) {
 358   gles2::cmds::CompressedTexImage3D* c =
 359       GetCmdSpace<gles2::cmds::CompressedTexImage3D>();
 360   if (c) {
 361     c->Init(target, level, internalformat, width, height, depth, imageSize,
 362             data_shm_id, data_shm_offset);
 363   }
 364 }
 365
 366 void CompressedTexSubImage3DBucket(GLenum target,
 367                                    GLint level,
 368                                    GLint xoffset,
 369                                    GLint yoffset,
 370                                    GLint zoffset,
 371                                    GLsizei width,
 372                                    GLsizei height,
 373                                    GLsizei depth,
 374                                    GLenum format,
 375                                    GLuint bucket_id) {
 376   gles2::cmds::CompressedTexSubImage3DBucket* c =
 377       GetCmdSpace<gles2::cmds::CompressedTexSubImage3DBucket>();
 378   if (c) {
 379     c->Init(target, level, xoffset, yoffset, zoffset, width, height, depth,
 380             format, bucket_id);
 381   }
 382 }
 383
 384 void CompressedTexSubImage3D(GLenum target,
 385                              GLint level,
 386                              GLint xoffset,
 387                              GLint yoffset,
 388                              GLint zoffset,
 389                              GLsizei width,
 390                              GLsizei height,
 391                              GLsizei depth,
 392                              GLenum format,
 393                              GLsizei imageSize,
 394                              uint32_t data_shm_id,
 395                              uint32_t data_shm_offset) {
 396   gles2::cmds::CompressedTexSubImage3D* c =
 397       GetCmdSpace<gles2::cmds::CompressedTexSubImage3D>();
 398   if (c) {
 399     c->Init(target, level, xoffset, yoffset, zoffset, width, height, depth,
 400             format, imageSize, data_shm_id, data_shm_offset);
 401   }
 402 }
 403
 404 void CopyBufferSubData(GLenum readtarget,
 405                        GLenum writetarget,
 406                        GLintptr readoffset,
 407                        GLintptr writeoffset,
 408                        GLsizeiptr size) {
 409   gles2::cmds::CopyBufferSubData* c =
 410       GetCmdSpace<gles2::cmds::CopyBufferSubData>();
 411   if (c) {
 412     c->Init(readtarget, writetarget, readoffset, writeoffset, size);
 413   }
 414 }
 415
 416 void CopyTexImage2D(GLenum target,
 417                     GLint level,
 418                     GLenum internalformat,
 419                     GLint x,
 420                     GLint y,
 421                     GLsizei width,
 422                     GLsizei height) {
 423   gles2::cmds::CopyTexImage2D* c = GetCmdSpace<gles2::cmds::CopyTexImage2D>();
 424   if (c) {
 425     c->Init(target, level, internalformat, x, y, width, height);
 426   }
 427 }
 428
 429 void CopyTexSubImage2D(GLenum target,
 430                        GLint level,
 431                        GLint xoffset,
 432                        GLint yoffset,
 433                        GLint x,
 434                        GLint y,
 435                        GLsizei width,
 436                        GLsizei height) {
 437   gles2::cmds::CopyTexSubImage2D* c =
 438       GetCmdSpace<gles2::cmds::CopyTexSubImage2D>();
 439   if (c) {
 440     c->Init(target, level, xoffset, yoffset, x, y, width, height);
 441   }
 442 }
 443
 444 void CopyTexSubImage3D(GLenum target,
 445                        GLint level,
 446                        GLint xoffset,
 447                        GLint yoffset,
 448                        GLint zoffset,
 449                        GLint x,
 450                        GLint y,
 451                        GLsizei width,
 452                        GLsizei height) {
 453   gles2::cmds::CopyTexSubImage3D* c =
 454       GetCmdSpace<gles2::cmds::CopyTexSubImage3D>();
 455   if (c) {
 456     c->Init(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 457   }
 458 }
 459
 460 void CreateProgram(uint32_t client_id) {
 461   gles2::cmds::CreateProgram* c = GetCmdSpace<gles2::cmds::CreateProgram>();
 462   if (c) {
 463     c->Init(client_id);
 464   }
 465 }
 466
 467 void CreateShader(GLenum type, uint32_t client_id) {
 468   gles2::cmds::CreateShader* c = GetCmdSpace<gles2::cmds::CreateShader>();
 469   if (c) {
 470     c->Init(type, client_id);
 471   }
 472 }
 473
 474 void CullFace(GLenum mode) {
 475   gles2::cmds::CullFace* c = GetCmdSpace<gles2::cmds::CullFace>();
 476   if (c) {
 477     c->Init(mode);
 478   }
 479 }
 480
 481 void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) {
 482   const uint32_t size = gles2::cmds::DeleteBuffersImmediate::ComputeSize(n);
 483   gles2::cmds::DeleteBuffersImmediate* c =
 484       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteBuffersImmediate>(size);
 485   if (c) {
 486     c->Init(n, buffers);
 487   }
 488 }
 489
 490 void DeleteFramebuffersImmediate(GLsizei n, const GLuint* framebuffers) {
 491   const uint32_t size =
 492       gles2::cmds::DeleteFramebuffersImmediate::ComputeSize(n);
 493   gles2::cmds::DeleteFramebuffersImmediate* c =
 494       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteFramebuffersImmediate>(
 495           size);
 496   if (c) {
 497     c->Init(n, framebuffers);
 498   }
 499 }
 500
 501 void DeleteProgram(GLuint program) {
 502   gles2::cmds::DeleteProgram* c = GetCmdSpace<gles2::cmds::DeleteProgram>();
 503   if (c) {
 504     c->Init(program);
 505   }
 506 }
 507
 508 void DeleteRenderbuffersImmediate(GLsizei n, const GLuint* renderbuffers) {
 509   const uint32_t size =
 510       gles2::cmds::DeleteRenderbuffersImmediate::ComputeSize(n);
 511   gles2::cmds::DeleteRenderbuffersImmediate* c =
 512       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteRenderbuffersImmediate>(
 513           size);
 514   if (c) {
 515     c->Init(n, renderbuffers);
 516   }
 517 }
 518
 519 void DeleteSamplersImmediate(GLsizei n, const GLuint* samplers) {
 520   const uint32_t size = gles2::cmds::DeleteSamplersImmediate::ComputeSize(n);
 521   gles2::cmds::DeleteSamplersImmediate* c =
 522       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteSamplersImmediate>(size);
 523   if (c) {
 524     c->Init(n, samplers);
 525   }
 526 }
 527
 528 void DeleteSync(GLuint sync) {
 529   gles2::cmds::DeleteSync* c = GetCmdSpace<gles2::cmds::DeleteSync>();
 530   if (c) {
 531     c->Init(sync);
 532   }
 533 }
 534
 535 void DeleteShader(GLuint shader) {
 536   gles2::cmds::DeleteShader* c = GetCmdSpace<gles2::cmds::DeleteShader>();
 537   if (c) {
 538     c->Init(shader);
 539   }
 540 }
 541
 542 void DeleteTexturesImmediate(GLsizei n, const GLuint* textures) {
 543   const uint32_t size = gles2::cmds::DeleteTexturesImmediate::ComputeSize(n);
 544   gles2::cmds::DeleteTexturesImmediate* c =
 545       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteTexturesImmediate>(size);
 546   if (c) {
 547     c->Init(n, textures);
 548   }
 549 }
 550
 551 void DeleteTransformFeedbacksImmediate(GLsizei n, const GLuint* ids) {
 552   const uint32_t size =
 553       gles2::cmds::DeleteTransformFeedbacksImmediate::ComputeSize(n);
 554   gles2::cmds::DeleteTransformFeedbacksImmediate* c =
 555       GetImmediateCmdSpaceTotalSize<
 556           gles2::cmds::DeleteTransformFeedbacksImmediate>(size);
 557   if (c) {
 558     c->Init(n, ids);
 559   }
 560 }
 561
 562 void DepthFunc(GLenum func) {
 563   gles2::cmds::DepthFunc* c = GetCmdSpace<gles2::cmds::DepthFunc>();
 564   if (c) {
 565     c->Init(func);
 566   }
 567 }
 568
 569 void DepthMask(GLboolean flag) {
 570   gles2::cmds::DepthMask* c = GetCmdSpace<gles2::cmds::DepthMask>();
 571   if (c) {
 572     c->Init(flag);
 573   }
 574 }
 575
 576 void DepthRangef(GLclampf zNear, GLclampf zFar) {
 577   gles2::cmds::DepthRangef* c = GetCmdSpace<gles2::cmds::DepthRangef>();
 578   if (c) {
 579     c->Init(zNear, zFar);
 580   }
 581 }
 582
 583 void DetachShader(GLuint program, GLuint shader) {
 584   gles2::cmds::DetachShader* c = GetCmdSpace<gles2::cmds::DetachShader>();
 585   if (c) {
 586     c->Init(program, shader);
 587   }
 588 }
 589
 590 void Disable(GLenum cap) {
 591   gles2::cmds::Disable* c = GetCmdSpace<gles2::cmds::Disable>();
 592   if (c) {
 593     c->Init(cap);
 594   }
 595 }
 596
 597 void DisableVertexAttribArray(GLuint index) {
 598   gles2::cmds::DisableVertexAttribArray* c =
 599       GetCmdSpace<gles2::cmds::DisableVertexAttribArray>();
 600   if (c) {
 601     c->Init(index);
 602   }
 603 }
 604
 605 void DrawArrays(GLenum mode, GLint first, GLsizei count) {
 606   gles2::cmds::DrawArrays* c = GetCmdSpace<gles2::cmds::DrawArrays>();
 607   if (c) {
 608     c->Init(mode, first, count);
 609   }
 610 }
 611
 612 void DrawElements(GLenum mode,
 613                   GLsizei count,
 614                   GLenum type,
 615                   GLuint index_offset) {
 616   gles2::cmds::DrawElements* c = GetCmdSpace<gles2::cmds::DrawElements>();
 617   if (c) {
 618     c->Init(mode, count, type, index_offset);
 619   }
 620 }
 621
 622 void Enable(GLenum cap) {
 623   gles2::cmds::Enable* c = GetCmdSpace<gles2::cmds::Enable>();
 624   if (c) {
 625     c->Init(cap);
 626   }
 627 }
 628
 629 void EnableVertexAttribArray(GLuint index) {
 630   gles2::cmds::EnableVertexAttribArray* c =
 631       GetCmdSpace<gles2::cmds::EnableVertexAttribArray>();
 632   if (c) {
 633     c->Init(index);
 634   }
 635 }
 636
 637 void FenceSync(uint32_t client_id) {
 638   gles2::cmds::FenceSync* c = GetCmdSpace<gles2::cmds::FenceSync>();
 639   if (c) {
 640     c->Init(client_id);
 641   }
 642 }
 643
 644 void Finish() {
 645   gles2::cmds::Finish* c = GetCmdSpace<gles2::cmds::Finish>();
 646   if (c) {
 647     c->Init();
 648   }
 649 }
 650
 651 void Flush() {
 652   gles2::cmds::Flush* c = GetCmdSpace<gles2::cmds::Flush>();
 653   if (c) {
 654     c->Init();
 655   }
 656 }
 657
 658 void FramebufferRenderbuffer(GLenum target,
 659                              GLenum attachment,
 660                              GLenum renderbuffertarget,
 661                              GLuint renderbuffer) {
 662   gles2::cmds::FramebufferRenderbuffer* c =
 663       GetCmdSpace<gles2::cmds::FramebufferRenderbuffer>();
 664   if (c) {
 665     c->Init(target, attachment, renderbuffertarget, renderbuffer);
 666   }
 667 }
 668
 669 void FramebufferTexture2D(GLenum target,
 670                           GLenum attachment,
 671                           GLenum textarget,
 672                           GLuint texture) {
 673   gles2::cmds::FramebufferTexture2D* c =
 674       GetCmdSpace<gles2::cmds::FramebufferTexture2D>();
 675   if (c) {
 676     c->Init(target, attachment, textarget, texture);
 677   }
 678 }
 679
 680 void FramebufferTextureLayer(GLenum target,
 681                              GLenum attachment,
 682                              GLuint texture,
 683                              GLint level,
 684                              GLint layer) {
 685   gles2::cmds::FramebufferTextureLayer* c =
 686       GetCmdSpace<gles2::cmds::FramebufferTextureLayer>();
 687   if (c) {
 688     c->Init(target, attachment, texture, level, layer);
 689   }
 690 }
 691
 692 void FrontFace(GLenum mode) {
 693   gles2::cmds::FrontFace* c = GetCmdSpace<gles2::cmds::FrontFace>();
 694   if (c) {
 695     c->Init(mode);
 696   }
 697 }
 698
 699 void GenBuffersImmediate(GLsizei n, GLuint* buffers) {
 700   const uint32_t size = gles2::cmds::GenBuffersImmediate::ComputeSize(n);
 701   gles2::cmds::GenBuffersImmediate* c =
 702       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenBuffersImmediate>(size);
 703   if (c) {
 704     c->Init(n, buffers);
 705   }
 706 }
 707
 708 void GenerateMipmap(GLenum target) {
 709   gles2::cmds::GenerateMipmap* c = GetCmdSpace<gles2::cmds::GenerateMipmap>();
 710   if (c) {
 711     c->Init(target);
 712   }
 713 }
 714
 715 void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) {
 716   const uint32_t size = gles2::cmds::GenFramebuffersImmediate::ComputeSize(n);
 717   gles2::cmds::GenFramebuffersImmediate* c =
 718       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenFramebuffersImmediate>(
 719           size);
 720   if (c) {
 721     c->Init(n, framebuffers);
 722   }
 723 }
 724
 725 void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) {
 726   const uint32_t size = gles2::cmds::GenRenderbuffersImmediate::ComputeSize(n);
 727   gles2::cmds::GenRenderbuffersImmediate* c =
 728       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenRenderbuffersImmediate>(
 729           size);
 730   if (c) {
 731     c->Init(n, renderbuffers);
 732   }
 733 }
 734
 735 void GenSamplersImmediate(GLsizei n, GLuint* samplers) {
 736   const uint32_t size = gles2::cmds::GenSamplersImmediate::ComputeSize(n);
 737   gles2::cmds::GenSamplersImmediate* c =
 738       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenSamplersImmediate>(size);
 739   if (c) {
 740     c->Init(n, samplers);
 741   }
 742 }
 743
 744 void GenTexturesImmediate(GLsizei n, GLuint* textures) {
 745   const uint32_t size = gles2::cmds::GenTexturesImmediate::ComputeSize(n);
 746   gles2::cmds::GenTexturesImmediate* c =
 747       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenTexturesImmediate>(size);
 748   if (c) {
 749     c->Init(n, textures);
 750   }
 751 }
 752
 753 void GenTransformFeedbacksImmediate(GLsizei n, GLuint* ids) {
 754   const uint32_t size =
 755       gles2::cmds::GenTransformFeedbacksImmediate::ComputeSize(n);
 756   gles2::cmds::GenTransformFeedbacksImmediate* c =
 757       GetImmediateCmdSpaceTotalSize<
 758           gles2::cmds::GenTransformFeedbacksImmediate>(size);
 759   if (c) {
 760     c->Init(n, ids);
 761   }
 762 }
 763
 764 void GetActiveAttrib(GLuint program,
 765                      GLuint index,
 766                      uint32_t name_bucket_id,
 767                      uint32_t result_shm_id,
 768                      uint32_t result_shm_offset) {
 769   gles2::cmds::GetActiveAttrib* c = GetCmdSpace<gles2::cmds::GetActiveAttrib>();
 770   if (c) {
 771     c->Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
 772   }
 773 }
 774
 775 void GetActiveUniform(GLuint program,
 776                       GLuint index,
 777                       uint32_t name_bucket_id,
 778                       uint32_t result_shm_id,
 779                       uint32_t result_shm_offset) {
 780   gles2::cmds::GetActiveUniform* c =
 781       GetCmdSpace<gles2::cmds::GetActiveUniform>();
 782   if (c) {
 783     c->Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
 784   }
 785 }
 786
 787 void GetActiveUniformBlockiv(GLuint program,
 788                              GLuint index,
 789                              GLenum pname,
 790                              uint32_t params_shm_id,
 791                              uint32_t params_shm_offset) {
 792   gles2::cmds::GetActiveUniformBlockiv* c =
 793       GetCmdSpace<gles2::cmds::GetActiveUniformBlockiv>();
 794   if (c) {
 795     c->Init(program, index, pname, params_shm_id, params_shm_offset);
 796   }
 797 }
 798
 799 void GetActiveUniformBlockName(GLuint program,
 800                                GLuint index,
 801                                uint32_t name_bucket_id,
 802                                uint32_t result_shm_id,
 803                                uint32_t result_shm_offset) {
 804   gles2::cmds::GetActiveUniformBlockName* c =
 805       GetCmdSpace<gles2::cmds::GetActiveUniformBlockName>();
 806   if (c) {
 807     c->Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
 808   }
 809 }
 810
 811 void GetActiveUniformsiv(GLuint program,
 812                          uint32_t indices_bucket_id,
 813                          GLenum pname,
 814                          uint32_t params_shm_id,
 815                          uint32_t params_shm_offset) {
 816   gles2::cmds::GetActiveUniformsiv* c =
 817       GetCmdSpace<gles2::cmds::GetActiveUniformsiv>();
 818   if (c) {
 819     c->Init(program, indices_bucket_id, pname, params_shm_id,
 820             params_shm_offset);
 821   }
 822 }
 823
 824 void GetAttachedShaders(GLuint program,
 825                         uint32_t result_shm_id,
 826                         uint32_t result_shm_offset,
 827                         uint32_t result_size) {
 828   gles2::cmds::GetAttachedShaders* c =
 829       GetCmdSpace<gles2::cmds::GetAttachedShaders>();
 830   if (c) {
 831     c->Init(program, result_shm_id, result_shm_offset, result_size);
 832   }
 833 }
 834
 835 void GetAttribLocation(GLuint program,
 836                        uint32_t name_bucket_id,
 837                        uint32_t location_shm_id,
 838                        uint32_t location_shm_offset) {
 839   gles2::cmds::GetAttribLocation* c =
 840       GetCmdSpace<gles2::cmds::GetAttribLocation>();
 841   if (c) {
 842     c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
 843   }
 844 }
 845
 846 void GetBooleanv(GLenum pname,
 847                  uint32_t params_shm_id,
 848                  uint32_t params_shm_offset) {
 849   gles2::cmds::GetBooleanv* c = GetCmdSpace<gles2::cmds::GetBooleanv>();
 850   if (c) {
 851     c->Init(pname, params_shm_id, params_shm_offset);
 852   }
 853 }
 854
 855 void GetBufferParameteriv(GLenum target,
 856                           GLenum pname,
 857                           uint32_t params_shm_id,
 858                           uint32_t params_shm_offset) {
 859   gles2::cmds::GetBufferParameteriv* c =
 860       GetCmdSpace<gles2::cmds::GetBufferParameteriv>();
 861   if (c) {
 862     c->Init(target, pname, params_shm_id, params_shm_offset);
 863   }
 864 }
 865
 866 void GetError(uint32_t result_shm_id, uint32_t result_shm_offset) {
 867   gles2::cmds::GetError* c = GetCmdSpace<gles2::cmds::GetError>();
 868   if (c) {
 869     c->Init(result_shm_id, result_shm_offset);
 870   }
 871 }
 872
 873 void GetFloatv(GLenum pname,
 874                uint32_t params_shm_id,
 875                uint32_t params_shm_offset) {
 876   gles2::cmds::GetFloatv* c = GetCmdSpace<gles2::cmds::GetFloatv>();
 877   if (c) {
 878     c->Init(pname, params_shm_id, params_shm_offset);
 879   }
 880 }
 881
 882 void GetFragDataLocation(GLuint program,
 883                          uint32_t name_bucket_id,
 884                          uint32_t location_shm_id,
 885                          uint32_t location_shm_offset) {
 886   gles2::cmds::GetFragDataLocation* c =
 887       GetCmdSpace<gles2::cmds::GetFragDataLocation>();
 888   if (c) {
 889     c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
 890   }
 891 }
 892
 893 void GetFramebufferAttachmentParameteriv(GLenum target,
 894                                          GLenum attachment,
 895                                          GLenum pname,
 896                                          uint32_t params_shm_id,
 897                                          uint32_t params_shm_offset) {
 898   gles2::cmds::GetFramebufferAttachmentParameteriv* c =
 899       GetCmdSpace<gles2::cmds::GetFramebufferAttachmentParameteriv>();
 900   if (c) {
 901     c->Init(target, attachment, pname, params_shm_id, params_shm_offset);
 902   }
 903 }
 904
 905 void GetInteger64v(GLenum pname,
 906                    uint32_t params_shm_id,
 907                    uint32_t params_shm_offset) {
 908   gles2::cmds::GetInteger64v* c = GetCmdSpace<gles2::cmds::GetInteger64v>();
 909   if (c) {
 910     c->Init(pname, params_shm_id, params_shm_offset);
 911   }
 912 }
 913
 914 void GetIntegeri_v(GLenum pname,
 915                    GLuint index,
 916                    uint32_t data_shm_id,
 917                    uint32_t data_shm_offset) {
 918   gles2::cmds::GetIntegeri_v* c = GetCmdSpace<gles2::cmds::GetIntegeri_v>();
 919   if (c) {
 920     c->Init(pname, index, data_shm_id, data_shm_offset);
 921   }
 922 }
 923
 924 void GetInteger64i_v(GLenum pname,
 925                      GLuint index,
 926                      uint32_t data_shm_id,
 927                      uint32_t data_shm_offset) {
 928   gles2::cmds::GetInteger64i_v* c = GetCmdSpace<gles2::cmds::GetInteger64i_v>();
 929   if (c) {
 930     c->Init(pname, index, data_shm_id, data_shm_offset);
 931   }
 932 }
 933
 934 void GetIntegerv(GLenum pname,
 935                  uint32_t params_shm_id,
 936                  uint32_t params_shm_offset) {
 937   gles2::cmds::GetIntegerv* c = GetCmdSpace<gles2::cmds::GetIntegerv>();
 938   if (c) {
 939     c->Init(pname, params_shm_id, params_shm_offset);
 940   }
 941 }
 942
 943 void GetInternalformativ(GLenum target,
 944                          GLenum format,
 945                          GLenum pname,
 946                          uint32_t params_shm_id,
 947                          uint32_t params_shm_offset) {
 948   gles2::cmds::GetInternalformativ* c =
 949       GetCmdSpace<gles2::cmds::GetInternalformativ>();
 950   if (c) {
 951     c->Init(target, format, pname, params_shm_id, params_shm_offset);
 952   }
 953 }
 954
 955 void GetProgramiv(GLuint program,
 956                   GLenum pname,
 957                   uint32_t params_shm_id,
 958                   uint32_t params_shm_offset) {
 959   gles2::cmds::GetProgramiv* c = GetCmdSpace<gles2::cmds::GetProgramiv>();
 960   if (c) {
 961     c->Init(program, pname, params_shm_id, params_shm_offset);
 962   }
 963 }
 964
 965 void GetProgramInfoLog(GLuint program, uint32_t bucket_id) {
 966   gles2::cmds::GetProgramInfoLog* c =
 967       GetCmdSpace<gles2::cmds::GetProgramInfoLog>();
 968   if (c) {
 969     c->Init(program, bucket_id);
 970   }
 971 }
 972
 973 void GetRenderbufferParameteriv(GLenum target,
 974                                 GLenum pname,
 975                                 uint32_t params_shm_id,
 976                                 uint32_t params_shm_offset) {
 977   gles2::cmds::GetRenderbufferParameteriv* c =
 978       GetCmdSpace<gles2::cmds::GetRenderbufferParameteriv>();
 979   if (c) {
 980     c->Init(target, pname, params_shm_id, params_shm_offset);
 981   }
 982 }
 983
 984 void GetSamplerParameterfv(GLuint sampler,
 985                            GLenum pname,
 986                            uint32_t params_shm_id,
 987                            uint32_t params_shm_offset) {
 988   gles2::cmds::GetSamplerParameterfv* c =
 989       GetCmdSpace<gles2::cmds::GetSamplerParameterfv>();
 990   if (c) {
 991     c->Init(sampler, pname, params_shm_id, params_shm_offset);
 992   }
 993 }
 994
 995 void GetSamplerParameteriv(GLuint sampler,
 996                            GLenum pname,
 997                            uint32_t params_shm_id,
 998                            uint32_t params_shm_offset) {
 999   gles2::cmds::GetSamplerParameteriv* c =
1000       GetCmdSpace<gles2::cmds::GetSamplerParameteriv>();
1001   if (c) {
1002     c->Init(sampler, pname, params_shm_id, params_shm_offset);
1003   }
1004 }
1005
1006 void GetShaderiv(GLuint shader,
1007                  GLenum pname,
1008                  uint32_t params_shm_id,
1009                  uint32_t params_shm_offset) {
1010   gles2::cmds::GetShaderiv* c = GetCmdSpace<gles2::cmds::GetShaderiv>();
1011   if (c) {
1012     c->Init(shader, pname, params_shm_id, params_shm_offset);
1013   }
1014 }
1015
1016 void GetShaderInfoLog(GLuint shader, uint32_t bucket_id) {
1017   gles2::cmds::GetShaderInfoLog* c =
1018       GetCmdSpace<gles2::cmds::GetShaderInfoLog>();
1019   if (c) {
1020     c->Init(shader, bucket_id);
1021   }
1022 }
1023
1024 void GetShaderPrecisionFormat(GLenum shadertype,
1025                               GLenum precisiontype,
1026                               uint32_t result_shm_id,
1027                               uint32_t result_shm_offset) {
1028   gles2::cmds::GetShaderPrecisionFormat* c =
1029       GetCmdSpace<gles2::cmds::GetShaderPrecisionFormat>();
1030   if (c) {
1031     c->Init(shadertype, precisiontype, result_shm_id, result_shm_offset);
1032   }
1033 }
1034
1035 void GetShaderSource(GLuint shader, uint32_t bucket_id) {
1036   gles2::cmds::GetShaderSource* c = GetCmdSpace<gles2::cmds::GetShaderSource>();
1037   if (c) {
1038     c->Init(shader, bucket_id);
1039   }
1040 }
1041
1042 void GetString(GLenum name, uint32_t bucket_id) {
1043   gles2::cmds::GetString* c = GetCmdSpace<gles2::cmds::GetString>();
1044   if (c) {
1045     c->Init(name, bucket_id);
1046   }
1047 }
1048
1049 void GetSynciv(GLuint sync,
1050                GLenum pname,
1051                uint32_t values_shm_id,
1052                uint32_t values_shm_offset) {
1053   gles2::cmds::GetSynciv* c = GetCmdSpace<gles2::cmds::GetSynciv>();
1054   if (c) {
1055     c->Init(sync, pname, values_shm_id, values_shm_offset);
1056   }
1057 }
1058
1059 void GetTexParameterfv(GLenum target,
1060                        GLenum pname,
1061                        uint32_t params_shm_id,
1062                        uint32_t params_shm_offset) {
1063   gles2::cmds::GetTexParameterfv* c =
1064       GetCmdSpace<gles2::cmds::GetTexParameterfv>();
1065   if (c) {
1066     c->Init(target, pname, params_shm_id, params_shm_offset);
1067   }
1068 }
1069
1070 void GetTexParameteriv(GLenum target,
1071                        GLenum pname,
1072                        uint32_t params_shm_id,
1073                        uint32_t params_shm_offset) {
1074   gles2::cmds::GetTexParameteriv* c =
1075       GetCmdSpace<gles2::cmds::GetTexParameteriv>();
1076   if (c) {
1077     c->Init(target, pname, params_shm_id, params_shm_offset);
1078   }
1079 }
1080
1081 void GetTransformFeedbackVarying(GLuint program,
1082                                  GLuint index,
1083                                  uint32_t name_bucket_id,
1084                                  uint32_t result_shm_id,
1085                                  uint32_t result_shm_offset) {
1086   gles2::cmds::GetTransformFeedbackVarying* c =
1087       GetCmdSpace<gles2::cmds::GetTransformFeedbackVarying>();
1088   if (c) {
1089     c->Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
1090   }
1091 }
1092
1093 void GetUniformBlockIndex(GLuint program,
1094                           uint32_t name_bucket_id,
1095                           uint32_t index_shm_id,
1096                           uint32_t index_shm_offset) {
1097   gles2::cmds::GetUniformBlockIndex* c =
1098       GetCmdSpace<gles2::cmds::GetUniformBlockIndex>();
1099   if (c) {
1100     c->Init(program, name_bucket_id, index_shm_id, index_shm_offset);
1101   }
1102 }
1103
1104 void GetUniformfv(GLuint program,
1105                   GLint location,
1106                   uint32_t params_shm_id,
1107                   uint32_t params_shm_offset) {
1108   gles2::cmds::GetUniformfv* c = GetCmdSpace<gles2::cmds::GetUniformfv>();
1109   if (c) {
1110     c->Init(program, location, params_shm_id, params_shm_offset);
1111   }
1112 }
1113
1114 void GetUniformiv(GLuint program,
1115                   GLint location,
1116                   uint32_t params_shm_id,
1117                   uint32_t params_shm_offset) {
1118   gles2::cmds::GetUniformiv* c = GetCmdSpace<gles2::cmds::GetUniformiv>();
1119   if (c) {
1120     c->Init(program, location, params_shm_id, params_shm_offset);
1121   }
1122 }
1123
1124 void GetUniformuiv(GLuint program,
1125                    GLint location,
1126                    uint32_t params_shm_id,
1127                    uint32_t params_shm_offset) {
1128   gles2::cmds::GetUniformuiv* c = GetCmdSpace<gles2::cmds::GetUniformuiv>();
1129   if (c) {
1130     c->Init(program, location, params_shm_id, params_shm_offset);
1131   }
1132 }
1133
1134 void GetUniformIndices(GLuint program,
1135                        uint32_t names_bucket_id,
1136                        uint32_t indices_shm_id,
1137                        uint32_t indices_shm_offset) {
1138   gles2::cmds::GetUniformIndices* c =
1139       GetCmdSpace<gles2::cmds::GetUniformIndices>();
1140   if (c) {
1141     c->Init(program, names_bucket_id, indices_shm_id, indices_shm_offset);
1142   }
1143 }
1144
1145 void GetUniformLocation(GLuint program,
1146                         uint32_t name_bucket_id,
1147                         uint32_t location_shm_id,
1148                         uint32_t location_shm_offset) {
1149   gles2::cmds::GetUniformLocation* c =
1150       GetCmdSpace<gles2::cmds::GetUniformLocation>();
1151   if (c) {
1152     c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
1153   }
1154 }
1155
1156 void GetVertexAttribfv(GLuint index,
1157                        GLenum pname,
1158                        uint32_t params_shm_id,
1159                        uint32_t params_shm_offset) {
1160   gles2::cmds::GetVertexAttribfv* c =
1161       GetCmdSpace<gles2::cmds::GetVertexAttribfv>();
1162   if (c) {
1163     c->Init(index, pname, params_shm_id, params_shm_offset);
1164   }
1165 }
1166
1167 void GetVertexAttribiv(GLuint index,
1168                        GLenum pname,
1169                        uint32_t params_shm_id,
1170                        uint32_t params_shm_offset) {
1171   gles2::cmds::GetVertexAttribiv* c =
1172       GetCmdSpace<gles2::cmds::GetVertexAttribiv>();
1173   if (c) {
1174     c->Init(index, pname, params_shm_id, params_shm_offset);
1175   }
1176 }
1177
1178 void GetVertexAttribIiv(GLuint index,
1179                         GLenum pname,
1180                         uint32_t params_shm_id,
1181                         uint32_t params_shm_offset) {
1182   gles2::cmds::GetVertexAttribIiv* c =
1183       GetCmdSpace<gles2::cmds::GetVertexAttribIiv>();
1184   if (c) {
1185     c->Init(index, pname, params_shm_id, params_shm_offset);
1186   }
1187 }
1188
1189 void GetVertexAttribIuiv(GLuint index,
1190                          GLenum pname,
1191                          uint32_t params_shm_id,
1192                          uint32_t params_shm_offset) {
1193   gles2::cmds::GetVertexAttribIuiv* c =
1194       GetCmdSpace<gles2::cmds::GetVertexAttribIuiv>();
1195   if (c) {
1196     c->Init(index, pname, params_shm_id, params_shm_offset);
1197   }
1198 }
1199
1200 void GetVertexAttribPointerv(GLuint index,
1201                              GLenum pname,
1202                              uint32_t pointer_shm_id,
1203                              uint32_t pointer_shm_offset) {
1204   gles2::cmds::GetVertexAttribPointerv* c =
1205       GetCmdSpace<gles2::cmds::GetVertexAttribPointerv>();
1206   if (c) {
1207     c->Init(index, pname, pointer_shm_id, pointer_shm_offset);
1208   }
1209 }
1210
1211 void Hint(GLenum target, GLenum mode) {
1212   gles2::cmds::Hint* c = GetCmdSpace<gles2::cmds::Hint>();
1213   if (c) {
1214     c->Init(target, mode);
1215   }
1216 }
1217
1218 void InvalidateFramebufferImmediate(GLenum target,
1219                                     GLsizei count,
1220                                     const GLenum* attachments) {
1221   const uint32_t size =
1222       gles2::cmds::InvalidateFramebufferImmediate::ComputeSize(count);
1223   gles2::cmds::InvalidateFramebufferImmediate* c =
1224       GetImmediateCmdSpaceTotalSize<
1225           gles2::cmds::InvalidateFramebufferImmediate>(size);
1226   if (c) {
1227     c->Init(target, count, attachments);
1228   }
1229 }
1230
1231 void InvalidateSubFramebufferImmediate(GLenum target,
1232                                        GLsizei count,
1233                                        const GLenum* attachments,
1234                                        GLint x,
1235                                        GLint y,
1236                                        GLsizei width,
1237                                        GLsizei height) {
1238   const uint32_t size =
1239       gles2::cmds::InvalidateSubFramebufferImmediate::ComputeSize(count);
1240   gles2::cmds::InvalidateSubFramebufferImmediate* c =
1241       GetImmediateCmdSpaceTotalSize<
1242           gles2::cmds::InvalidateSubFramebufferImmediate>(size);
1243   if (c) {
1244     c->Init(target, count, attachments, x, y, width, height);
1245   }
1246 }
1247
1248 void IsBuffer(GLuint buffer,
1249               uint32_t result_shm_id,
1250               uint32_t result_shm_offset) {
1251   gles2::cmds::IsBuffer* c = GetCmdSpace<gles2::cmds::IsBuffer>();
1252   if (c) {
1253     c->Init(buffer, result_shm_id, result_shm_offset);
1254   }
1255 }
1256
1257 void IsEnabled(GLenum cap, uint32_t result_shm_id, uint32_t result_shm_offset) {
1258   gles2::cmds::IsEnabled* c = GetCmdSpace<gles2::cmds::IsEnabled>();
1259   if (c) {
1260     c->Init(cap, result_shm_id, result_shm_offset);
1261   }
1262 }
1263
1264 void IsFramebuffer(GLuint framebuffer,
1265                    uint32_t result_shm_id,
1266                    uint32_t result_shm_offset) {
1267   gles2::cmds::IsFramebuffer* c = GetCmdSpace<gles2::cmds::IsFramebuffer>();
1268   if (c) {
1269     c->Init(framebuffer, result_shm_id, result_shm_offset);
1270   }
1271 }
1272
1273 void IsProgram(GLuint program,
1274                uint32_t result_shm_id,
1275                uint32_t result_shm_offset) {
1276   gles2::cmds::IsProgram* c = GetCmdSpace<gles2::cmds::IsProgram>();
1277   if (c) {
1278     c->Init(program, result_shm_id, result_shm_offset);
1279   }
1280 }
1281
1282 void IsRenderbuffer(GLuint renderbuffer,
1283                     uint32_t result_shm_id,
1284                     uint32_t result_shm_offset) {
1285   gles2::cmds::IsRenderbuffer* c = GetCmdSpace<gles2::cmds::IsRenderbuffer>();
1286   if (c) {
1287     c->Init(renderbuffer, result_shm_id, result_shm_offset);
1288   }
1289 }
1290
1291 void IsSampler(GLuint sampler,
1292                uint32_t result_shm_id,
1293                uint32_t result_shm_offset) {
1294   gles2::cmds::IsSampler* c = GetCmdSpace<gles2::cmds::IsSampler>();
1295   if (c) {
1296     c->Init(sampler, result_shm_id, result_shm_offset);
1297   }
1298 }
1299
1300 void IsShader(GLuint shader,
1301               uint32_t result_shm_id,
1302               uint32_t result_shm_offset) {
1303   gles2::cmds::IsShader* c = GetCmdSpace<gles2::cmds::IsShader>();
1304   if (c) {
1305     c->Init(shader, result_shm_id, result_shm_offset);
1306   }
1307 }
1308
1309 void IsSync(GLuint sync, uint32_t result_shm_id, uint32_t result_shm_offset) {
1310   gles2::cmds::IsSync* c = GetCmdSpace<gles2::cmds::IsSync>();
1311   if (c) {
1312     c->Init(sync, result_shm_id, result_shm_offset);
1313   }
1314 }
1315
1316 void IsTexture(GLuint texture,
1317                uint32_t result_shm_id,
1318                uint32_t result_shm_offset) {
1319   gles2::cmds::IsTexture* c = GetCmdSpace<gles2::cmds::IsTexture>();
1320   if (c) {
1321     c->Init(texture, result_shm_id, result_shm_offset);
1322   }
1323 }
1324
1325 void IsTransformFeedback(GLuint transformfeedback,
1326                          uint32_t result_shm_id,
1327                          uint32_t result_shm_offset) {
1328   gles2::cmds::IsTransformFeedback* c =
1329       GetCmdSpace<gles2::cmds::IsTransformFeedback>();
1330   if (c) {
1331     c->Init(transformfeedback, result_shm_id, result_shm_offset);
1332   }
1333 }
1334
1335 void LineWidth(GLfloat width) {
1336   gles2::cmds::LineWidth* c = GetCmdSpace<gles2::cmds::LineWidth>();
1337   if (c) {
1338     c->Init(width);
1339   }
1340 }
1341
1342 void LinkProgram(GLuint program) {
1343   gles2::cmds::LinkProgram* c = GetCmdSpace<gles2::cmds::LinkProgram>();
1344   if (c) {
1345     c->Init(program);
1346   }
1347 }
1348
1349 void PauseTransformFeedback() {
1350   gles2::cmds::PauseTransformFeedback* c =
1351       GetCmdSpace<gles2::cmds::PauseTransformFeedback>();
1352   if (c) {
1353     c->Init();
1354   }
1355 }
1356
1357 void PixelStorei(GLenum pname, GLint param) {
1358   gles2::cmds::PixelStorei* c = GetCmdSpace<gles2::cmds::PixelStorei>();
1359   if (c) {
1360     c->Init(pname, param);
1361   }
1362 }
1363
1364 void PolygonOffset(GLfloat factor, GLfloat units) {
1365   gles2::cmds::PolygonOffset* c = GetCmdSpace<gles2::cmds::PolygonOffset>();
1366   if (c) {
1367     c->Init(factor, units);
1368   }
1369 }
1370
1371 void ReadBuffer(GLenum src) {
1372   gles2::cmds::ReadBuffer* c = GetCmdSpace<gles2::cmds::ReadBuffer>();
1373   if (c) {
1374     c->Init(src);
1375   }
1376 }
1377
1378 void ReadPixels(GLint x,
1379                 GLint y,
1380                 GLsizei width,
1381                 GLsizei height,
1382                 GLenum format,
1383                 GLenum type,
1384                 uint32_t pixels_shm_id,
1385                 uint32_t pixels_shm_offset,
1386                 uint32_t result_shm_id,
1387                 uint32_t result_shm_offset,
1388                 GLboolean async) {
1389   gles2::cmds::ReadPixels* c = GetCmdSpace<gles2::cmds::ReadPixels>();
1390   if (c) {
1391     c->Init(x, y, width, height, format, type, pixels_shm_id, pixels_shm_offset,
1392             result_shm_id, result_shm_offset, async);
1393   }
1394 }
1395
1396 void ReleaseShaderCompiler() {
1397   gles2::cmds::ReleaseShaderCompiler* c =
1398       GetCmdSpace<gles2::cmds::ReleaseShaderCompiler>();
1399   if (c) {
1400     c->Init();
1401   }
1402 }
1403
1404 void RenderbufferStorage(GLenum target,
1405                          GLenum internalformat,
1406                          GLsizei width,
1407                          GLsizei height) {
1408   gles2::cmds::RenderbufferStorage* c =
1409       GetCmdSpace<gles2::cmds::RenderbufferStorage>();
1410   if (c) {
1411     c->Init(target, internalformat, width, height);
1412   }
1413 }
1414
1415 void ResumeTransformFeedback() {
1416   gles2::cmds::ResumeTransformFeedback* c =
1417       GetCmdSpace<gles2::cmds::ResumeTransformFeedback>();
1418   if (c) {
1419     c->Init();
1420   }
1421 }
1422
1423 void SampleCoverage(GLclampf value, GLboolean invert) {
1424   gles2::cmds::SampleCoverage* c = GetCmdSpace<gles2::cmds::SampleCoverage>();
1425   if (c) {
1426     c->Init(value, invert);
1427   }
1428 }
1429
1430 void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
1431   gles2::cmds::SamplerParameterf* c =
1432       GetCmdSpace<gles2::cmds::SamplerParameterf>();
1433   if (c) {
1434     c->Init(sampler, pname, param);
1435   }
1436 }
1437
1438 void SamplerParameterfvImmediate(GLuint sampler,
1439                                  GLenum pname,
1440                                  const GLfloat* params) {
1441   const uint32_t size = gles2::cmds::SamplerParameterfvImmediate::ComputeSize();
1442   gles2::cmds::SamplerParameterfvImmediate* c =
1443       GetImmediateCmdSpaceTotalSize<gles2::cmds::SamplerParameterfvImmediate>(
1444           size);
1445   if (c) {
1446     c->Init(sampler, pname, params);
1447   }
1448 }
1449
1450 void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
1451   gles2::cmds::SamplerParameteri* c =
1452       GetCmdSpace<gles2::cmds::SamplerParameteri>();
1453   if (c) {
1454     c->Init(sampler, pname, param);
1455   }
1456 }
1457
1458 void SamplerParameterivImmediate(GLuint sampler,
1459                                  GLenum pname,
1460                                  const GLint* params) {
1461   const uint32_t size = gles2::cmds::SamplerParameterivImmediate::ComputeSize();
1462   gles2::cmds::SamplerParameterivImmediate* c =
1463       GetImmediateCmdSpaceTotalSize<gles2::cmds::SamplerParameterivImmediate>(
1464           size);
1465   if (c) {
1466     c->Init(sampler, pname, params);
1467   }
1468 }
1469
1470 void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
1471   gles2::cmds::Scissor* c = GetCmdSpace<gles2::cmds::Scissor>();
1472   if (c) {
1473     c->Init(x, y, width, height);
1474   }
1475 }
1476
1477 void ShaderBinary(GLsizei n,
1478                   uint32_t shaders_shm_id,
1479                   uint32_t shaders_shm_offset,
1480                   GLenum binaryformat,
1481                   uint32_t binary_shm_id,
1482                   uint32_t binary_shm_offset,
1483                   GLsizei length) {
1484   gles2::cmds::ShaderBinary* c = GetCmdSpace<gles2::cmds::ShaderBinary>();
1485   if (c) {
1486     c->Init(n, shaders_shm_id, shaders_shm_offset, binaryformat, binary_shm_id,
1487             binary_shm_offset, length);
1488   }
1489 }
1490
1491 void ShaderSourceBucket(GLuint shader, uint32_t str_bucket_id) {
1492   gles2::cmds::ShaderSourceBucket* c =
1493       GetCmdSpace<gles2::cmds::ShaderSourceBucket>();
1494   if (c) {
1495     c->Init(shader, str_bucket_id);
1496   }
1497 }
1498
1499 void StencilFunc(GLenum func, GLint ref, GLuint mask) {
1500   gles2::cmds::StencilFunc* c = GetCmdSpace<gles2::cmds::StencilFunc>();
1501   if (c) {
1502     c->Init(func, ref, mask);
1503   }
1504 }
1505
1506 void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
1507   gles2::cmds::StencilFuncSeparate* c =
1508       GetCmdSpace<gles2::cmds::StencilFuncSeparate>();
1509   if (c) {
1510     c->Init(face, func, ref, mask);
1511   }
1512 }
1513
1514 void StencilMask(GLuint mask) {
1515   gles2::cmds::StencilMask* c = GetCmdSpace<gles2::cmds::StencilMask>();
1516   if (c) {
1517     c->Init(mask);
1518   }
1519 }
1520
1521 void StencilMaskSeparate(GLenum face, GLuint mask) {
1522   gles2::cmds::StencilMaskSeparate* c =
1523       GetCmdSpace<gles2::cmds::StencilMaskSeparate>();
1524   if (c) {
1525     c->Init(face, mask);
1526   }
1527 }
1528
1529 void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1530   gles2::cmds::StencilOp* c = GetCmdSpace<gles2::cmds::StencilOp>();
1531   if (c) {
1532     c->Init(fail, zfail, zpass);
1533   }
1534 }
1535
1536 void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
1537   gles2::cmds::StencilOpSeparate* c =
1538       GetCmdSpace<gles2::cmds::StencilOpSeparate>();
1539   if (c) {
1540     c->Init(face, fail, zfail, zpass);
1541   }
1542 }
1543
1544 void TexImage2D(GLenum target,
1545                 GLint level,
1546                 GLint internalformat,
1547                 GLsizei width,
1548                 GLsizei height,
1549                 GLenum format,
1550                 GLenum type,
1551                 uint32_t pixels_shm_id,
1552                 uint32_t pixels_shm_offset) {
1553   gles2::cmds::TexImage2D* c = GetCmdSpace<gles2::cmds::TexImage2D>();
1554   if (c) {
1555     c->Init(target, level, internalformat, width, height, format, type,
1556             pixels_shm_id, pixels_shm_offset);
1557   }
1558 }
1559
1560 void TexImage3D(GLenum target,
1561                 GLint level,
1562                 GLint internalformat,
1563                 GLsizei width,
1564                 GLsizei height,
1565                 GLsizei depth,
1566                 GLenum format,
1567                 GLenum type,
1568                 uint32_t pixels_shm_id,
1569                 uint32_t pixels_shm_offset) {
1570   gles2::cmds::TexImage3D* c = GetCmdSpace<gles2::cmds::TexImage3D>();
1571   if (c) {
1572     c->Init(target, level, internalformat, width, height, depth, format, type,
1573             pixels_shm_id, pixels_shm_offset);
1574   }
1575 }
1576
1577 void TexParameterf(GLenum target, GLenum pname, GLfloat param) {
1578   gles2::cmds::TexParameterf* c = GetCmdSpace<gles2::cmds::TexParameterf>();
1579   if (c) {
1580     c->Init(target, pname, param);
1581   }
1582 }
1583
1584 void TexParameterfvImmediate(GLenum target,
1585                              GLenum pname,
1586                              const GLfloat* params) {
1587   const uint32_t size = gles2::cmds::TexParameterfvImmediate::ComputeSize();
1588   gles2::cmds::TexParameterfvImmediate* c =
1589       GetImmediateCmdSpaceTotalSize<gles2::cmds::TexParameterfvImmediate>(size);
1590   if (c) {
1591     c->Init(target, pname, params);
1592   }
1593 }
1594
1595 void TexParameteri(GLenum target, GLenum pname, GLint param) {
1596   gles2::cmds::TexParameteri* c = GetCmdSpace<gles2::cmds::TexParameteri>();
1597   if (c) {
1598     c->Init(target, pname, param);
1599   }
1600 }
1601
1602 void TexParameterivImmediate(GLenum target, GLenum pname, const GLint* params) {
1603   const uint32_t size = gles2::cmds::TexParameterivImmediate::ComputeSize();
1604   gles2::cmds::TexParameterivImmediate* c =
1605       GetImmediateCmdSpaceTotalSize<gles2::cmds::TexParameterivImmediate>(size);
1606   if (c) {
1607     c->Init(target, pname, params);
1608   }
1609 }
1610
1611 void TexStorage3D(GLenum target,
1612                   GLsizei levels,
1613                   GLenum internalFormat,
1614                   GLsizei width,
1615                   GLsizei height,
1616                   GLsizei depth) {
1617   gles2::cmds::TexStorage3D* c = GetCmdSpace<gles2::cmds::TexStorage3D>();
1618   if (c) {
1619     c->Init(target, levels, internalFormat, width, height, depth);
1620   }
1621 }
1622
1623 void TexSubImage2D(GLenum target,
1624                    GLint level,
1625                    GLint xoffset,
1626                    GLint yoffset,
1627                    GLsizei width,
1628                    GLsizei height,
1629                    GLenum format,
1630                    GLenum type,
1631                    uint32_t pixels_shm_id,
1632                    uint32_t pixels_shm_offset,
1633                    GLboolean internal) {
1634   gles2::cmds::TexSubImage2D* c = GetCmdSpace<gles2::cmds::TexSubImage2D>();
1635   if (c) {
1636     c->Init(target, level, xoffset, yoffset, width, height, format, type,
1637             pixels_shm_id, pixels_shm_offset, internal);
1638   }
1639 }
1640
1641 void TexSubImage3D(GLenum target,
1642                    GLint level,
1643                    GLint xoffset,
1644                    GLint yoffset,
1645                    GLint zoffset,
1646                    GLsizei width,
1647                    GLsizei height,
1648                    GLsizei depth,
1649                    GLenum format,
1650                    GLenum type,
1651                    uint32_t pixels_shm_id,
1652                    uint32_t pixels_shm_offset,
1653                    GLboolean internal) {
1654   gles2::cmds::TexSubImage3D* c = GetCmdSpace<gles2::cmds::TexSubImage3D>();
1655   if (c) {
1656     c->Init(target, level, xoffset, yoffset, zoffset, width, height, depth,
1657             format, type, pixels_shm_id, pixels_shm_offset, internal);
1658   }
1659 }
1660
1661 void TransformFeedbackVaryingsBucket(GLuint program,
1662                                      uint32_t varyings_bucket_id,
1663                                      GLenum buffermode) {
1664   gles2::cmds::TransformFeedbackVaryingsBucket* c =
1665       GetCmdSpace<gles2::cmds::TransformFeedbackVaryingsBucket>();
1666   if (c) {
1667     c->Init(program, varyings_bucket_id, buffermode);
1668   }
1669 }
1670
1671 void Uniform1f(GLint location, GLfloat x) {
1672   gles2::cmds::Uniform1f* c = GetCmdSpace<gles2::cmds::Uniform1f>();
1673   if (c) {
1674     c->Init(location, x);
1675   }
1676 }
1677
1678 void Uniform1fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1679   const uint32_t size = gles2::cmds::Uniform1fvImmediate::ComputeSize(count);
1680   gles2::cmds::Uniform1fvImmediate* c =
1681       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1fvImmediate>(size);
1682   if (c) {
1683     c->Init(location, count, v);
1684   }
1685 }
1686
1687 void Uniform1i(GLint location, GLint x) {
1688   gles2::cmds::Uniform1i* c = GetCmdSpace<gles2::cmds::Uniform1i>();
1689   if (c) {
1690     c->Init(location, x);
1691   }
1692 }
1693
1694 void Uniform1ivImmediate(GLint location, GLsizei count, const GLint* v) {
1695   const uint32_t size = gles2::cmds::Uniform1ivImmediate::ComputeSize(count);
1696   gles2::cmds::Uniform1ivImmediate* c =
1697       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1ivImmediate>(size);
1698   if (c) {
1699     c->Init(location, count, v);
1700   }
1701 }
1702
1703 void Uniform1ui(GLint location, GLuint x) {
1704   gles2::cmds::Uniform1ui* c = GetCmdSpace<gles2::cmds::Uniform1ui>();
1705   if (c) {
1706     c->Init(location, x);
1707   }
1708 }
1709
1710 void Uniform1uivImmediate(GLint location, GLsizei count, const GLuint* v) {
1711   const uint32_t size = gles2::cmds::Uniform1uivImmediate::ComputeSize(count);
1712   gles2::cmds::Uniform1uivImmediate* c =
1713       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform1uivImmediate>(size);
1714   if (c) {
1715     c->Init(location, count, v);
1716   }
1717 }
1718
1719 void Uniform2f(GLint location, GLfloat x, GLfloat y) {
1720   gles2::cmds::Uniform2f* c = GetCmdSpace<gles2::cmds::Uniform2f>();
1721   if (c) {
1722     c->Init(location, x, y);
1723   }
1724 }
1725
1726 void Uniform2fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1727   const uint32_t size = gles2::cmds::Uniform2fvImmediate::ComputeSize(count);
1728   gles2::cmds::Uniform2fvImmediate* c =
1729       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2fvImmediate>(size);
1730   if (c) {
1731     c->Init(location, count, v);
1732   }
1733 }
1734
1735 void Uniform2i(GLint location, GLint x, GLint y) {
1736   gles2::cmds::Uniform2i* c = GetCmdSpace<gles2::cmds::Uniform2i>();
1737   if (c) {
1738     c->Init(location, x, y);
1739   }
1740 }
1741
1742 void Uniform2ivImmediate(GLint location, GLsizei count, const GLint* v) {
1743   const uint32_t size = gles2::cmds::Uniform2ivImmediate::ComputeSize(count);
1744   gles2::cmds::Uniform2ivImmediate* c =
1745       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2ivImmediate>(size);
1746   if (c) {
1747     c->Init(location, count, v);
1748   }
1749 }
1750
1751 void Uniform2ui(GLint location, GLuint x, GLuint y) {
1752   gles2::cmds::Uniform2ui* c = GetCmdSpace<gles2::cmds::Uniform2ui>();
1753   if (c) {
1754     c->Init(location, x, y);
1755   }
1756 }
1757
1758 void Uniform2uivImmediate(GLint location, GLsizei count, const GLuint* v) {
1759   const uint32_t size = gles2::cmds::Uniform2uivImmediate::ComputeSize(count);
1760   gles2::cmds::Uniform2uivImmediate* c =
1761       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform2uivImmediate>(size);
1762   if (c) {
1763     c->Init(location, count, v);
1764   }
1765 }
1766
1767 void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
1768   gles2::cmds::Uniform3f* c = GetCmdSpace<gles2::cmds::Uniform3f>();
1769   if (c) {
1770     c->Init(location, x, y, z);
1771   }
1772 }
1773
1774 void Uniform3fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1775   const uint32_t size = gles2::cmds::Uniform3fvImmediate::ComputeSize(count);
1776   gles2::cmds::Uniform3fvImmediate* c =
1777       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3fvImmediate>(size);
1778   if (c) {
1779     c->Init(location, count, v);
1780   }
1781 }
1782
1783 void Uniform3i(GLint location, GLint x, GLint y, GLint z) {
1784   gles2::cmds::Uniform3i* c = GetCmdSpace<gles2::cmds::Uniform3i>();
1785   if (c) {
1786     c->Init(location, x, y, z);
1787   }
1788 }
1789
1790 void Uniform3ivImmediate(GLint location, GLsizei count, const GLint* v) {
1791   const uint32_t size = gles2::cmds::Uniform3ivImmediate::ComputeSize(count);
1792   gles2::cmds::Uniform3ivImmediate* c =
1793       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3ivImmediate>(size);
1794   if (c) {
1795     c->Init(location, count, v);
1796   }
1797 }
1798
1799 void Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
1800   gles2::cmds::Uniform3ui* c = GetCmdSpace<gles2::cmds::Uniform3ui>();
1801   if (c) {
1802     c->Init(location, x, y, z);
1803   }
1804 }
1805
1806 void Uniform3uivImmediate(GLint location, GLsizei count, const GLuint* v) {
1807   const uint32_t size = gles2::cmds::Uniform3uivImmediate::ComputeSize(count);
1808   gles2::cmds::Uniform3uivImmediate* c =
1809       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform3uivImmediate>(size);
1810   if (c) {
1811     c->Init(location, count, v);
1812   }
1813 }
1814
1815 void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
1816   gles2::cmds::Uniform4f* c = GetCmdSpace<gles2::cmds::Uniform4f>();
1817   if (c) {
1818     c->Init(location, x, y, z, w);
1819   }
1820 }
1821
1822 void Uniform4fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
1823   const uint32_t size = gles2::cmds::Uniform4fvImmediate::ComputeSize(count);
1824   gles2::cmds::Uniform4fvImmediate* c =
1825       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4fvImmediate>(size);
1826   if (c) {
1827     c->Init(location, count, v);
1828   }
1829 }
1830
1831 void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
1832   gles2::cmds::Uniform4i* c = GetCmdSpace<gles2::cmds::Uniform4i>();
1833   if (c) {
1834     c->Init(location, x, y, z, w);
1835   }
1836 }
1837
1838 void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) {
1839   const uint32_t size = gles2::cmds::Uniform4ivImmediate::ComputeSize(count);
1840   gles2::cmds::Uniform4ivImmediate* c =
1841       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4ivImmediate>(size);
1842   if (c) {
1843     c->Init(location, count, v);
1844   }
1845 }
1846
1847 void Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w) {
1848   gles2::cmds::Uniform4ui* c = GetCmdSpace<gles2::cmds::Uniform4ui>();
1849   if (c) {
1850     c->Init(location, x, y, z, w);
1851   }
1852 }
1853
1854 void Uniform4uivImmediate(GLint location, GLsizei count, const GLuint* v) {
1855   const uint32_t size = gles2::cmds::Uniform4uivImmediate::ComputeSize(count);
1856   gles2::cmds::Uniform4uivImmediate* c =
1857       GetImmediateCmdSpaceTotalSize<gles2::cmds::Uniform4uivImmediate>(size);
1858   if (c) {
1859     c->Init(location, count, v);
1860   }
1861 }
1862
1863 void UniformBlockBinding(GLuint program, GLuint index, GLuint binding) {
1864   gles2::cmds::UniformBlockBinding* c =
1865       GetCmdSpace<gles2::cmds::UniformBlockBinding>();
1866   if (c) {
1867     c->Init(program, index, binding);
1868   }
1869 }
1870
1871 void UniformMatrix2fvImmediate(GLint location,
1872                                GLsizei count,
1873                                const GLfloat* value) {
1874   const uint32_t size =
1875       gles2::cmds::UniformMatrix2fvImmediate::ComputeSize(count);
1876   gles2::cmds::UniformMatrix2fvImmediate* c =
1877       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix2fvImmediate>(
1878           size);
1879   if (c) {
1880     c->Init(location, count, value);
1881   }
1882 }
1883
1884 void UniformMatrix2x3fvImmediate(GLint location,
1885                                  GLsizei count,
1886                                  const GLfloat* value) {
1887   const uint32_t size =
1888       gles2::cmds::UniformMatrix2x3fvImmediate::ComputeSize(count);
1889   gles2::cmds::UniformMatrix2x3fvImmediate* c =
1890       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix2x3fvImmediate>(
1891           size);
1892   if (c) {
1893     c->Init(location, count, value);
1894   }
1895 }
1896
1897 void UniformMatrix2x4fvImmediate(GLint location,
1898                                  GLsizei count,
1899                                  const GLfloat* value) {
1900   const uint32_t size =
1901       gles2::cmds::UniformMatrix2x4fvImmediate::ComputeSize(count);
1902   gles2::cmds::UniformMatrix2x4fvImmediate* c =
1903       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix2x4fvImmediate>(
1904           size);
1905   if (c) {
1906     c->Init(location, count, value);
1907   }
1908 }
1909
1910 void UniformMatrix3fvImmediate(GLint location,
1911                                GLsizei count,
1912                                const GLfloat* value) {
1913   const uint32_t size =
1914       gles2::cmds::UniformMatrix3fvImmediate::ComputeSize(count);
1915   gles2::cmds::UniformMatrix3fvImmediate* c =
1916       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix3fvImmediate>(
1917           size);
1918   if (c) {
1919     c->Init(location, count, value);
1920   }
1921 }
1922
1923 void UniformMatrix3x2fvImmediate(GLint location,
1924                                  GLsizei count,
1925                                  const GLfloat* value) {
1926   const uint32_t size =
1927       gles2::cmds::UniformMatrix3x2fvImmediate::ComputeSize(count);
1928   gles2::cmds::UniformMatrix3x2fvImmediate* c =
1929       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix3x2fvImmediate>(
1930           size);
1931   if (c) {
1932     c->Init(location, count, value);
1933   }
1934 }
1935
1936 void UniformMatrix3x4fvImmediate(GLint location,
1937                                  GLsizei count,
1938                                  const GLfloat* value) {
1939   const uint32_t size =
1940       gles2::cmds::UniformMatrix3x4fvImmediate::ComputeSize(count);
1941   gles2::cmds::UniformMatrix3x4fvImmediate* c =
1942       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix3x4fvImmediate>(
1943           size);
1944   if (c) {
1945     c->Init(location, count, value);
1946   }
1947 }
1948
1949 void UniformMatrix4fvImmediate(GLint location,
1950                                GLsizei count,
1951                                const GLfloat* value) {
1952   const uint32_t size =
1953       gles2::cmds::UniformMatrix4fvImmediate::ComputeSize(count);
1954   gles2::cmds::UniformMatrix4fvImmediate* c =
1955       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix4fvImmediate>(
1956           size);
1957   if (c) {
1958     c->Init(location, count, value);
1959   }
1960 }
1961
1962 void UniformMatrix4x2fvImmediate(GLint location,
1963                                  GLsizei count,
1964                                  const GLfloat* value) {
1965   const uint32_t size =
1966       gles2::cmds::UniformMatrix4x2fvImmediate::ComputeSize(count);
1967   gles2::cmds::UniformMatrix4x2fvImmediate* c =
1968       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix4x2fvImmediate>(
1969           size);
1970   if (c) {
1971     c->Init(location, count, value);
1972   }
1973 }
1974
1975 void UniformMatrix4x3fvImmediate(GLint location,
1976                                  GLsizei count,
1977                                  const GLfloat* value) {
1978   const uint32_t size =
1979       gles2::cmds::UniformMatrix4x3fvImmediate::ComputeSize(count);
1980   gles2::cmds::UniformMatrix4x3fvImmediate* c =
1981       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix4x3fvImmediate>(
1982           size);
1983   if (c) {
1984     c->Init(location, count, value);
1985   }
1986 }
1987
1988 void UseProgram(GLuint program) {
1989   gles2::cmds::UseProgram* c = GetCmdSpace<gles2::cmds::UseProgram>();
1990   if (c) {
1991     c->Init(program);
1992   }
1993 }
1994
1995 void ValidateProgram(GLuint program) {
1996   gles2::cmds::ValidateProgram* c = GetCmdSpace<gles2::cmds::ValidateProgram>();
1997   if (c) {
1998     c->Init(program);
1999   }
2000 }
2001
2002 void VertexAttrib1f(GLuint indx, GLfloat x) {
2003   gles2::cmds::VertexAttrib1f* c = GetCmdSpace<gles2::cmds::VertexAttrib1f>();
2004   if (c) {
2005     c->Init(indx, x);
2006   }
2007 }
2008
2009 void VertexAttrib1fvImmediate(GLuint indx, const GLfloat* values) {
2010   const uint32_t size = gles2::cmds::VertexAttrib1fvImmediate::ComputeSize();
2011   gles2::cmds::VertexAttrib1fvImmediate* c =
2012       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib1fvImmediate>(
2013           size);
2014   if (c) {
2015     c->Init(indx, values);
2016   }
2017 }
2018
2019 void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
2020   gles2::cmds::VertexAttrib2f* c = GetCmdSpace<gles2::cmds::VertexAttrib2f>();
2021   if (c) {
2022     c->Init(indx, x, y);
2023   }
2024 }
2025
2026 void VertexAttrib2fvImmediate(GLuint indx, const GLfloat* values) {
2027   const uint32_t size = gles2::cmds::VertexAttrib2fvImmediate::ComputeSize();
2028   gles2::cmds::VertexAttrib2fvImmediate* c =
2029       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib2fvImmediate>(
2030           size);
2031   if (c) {
2032     c->Init(indx, values);
2033   }
2034 }
2035
2036 void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
2037   gles2::cmds::VertexAttrib3f* c = GetCmdSpace<gles2::cmds::VertexAttrib3f>();
2038   if (c) {
2039     c->Init(indx, x, y, z);
2040   }
2041 }
2042
2043 void VertexAttrib3fvImmediate(GLuint indx, const GLfloat* values) {
2044   const uint32_t size = gles2::cmds::VertexAttrib3fvImmediate::ComputeSize();
2045   gles2::cmds::VertexAttrib3fvImmediate* c =
2046       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib3fvImmediate>(
2047           size);
2048   if (c) {
2049     c->Init(indx, values);
2050   }
2051 }
2052
2053 void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
2054   gles2::cmds::VertexAttrib4f* c = GetCmdSpace<gles2::cmds::VertexAttrib4f>();
2055   if (c) {
2056     c->Init(indx, x, y, z, w);
2057   }
2058 }
2059
2060 void VertexAttrib4fvImmediate(GLuint indx, const GLfloat* values) {
2061   const uint32_t size = gles2::cmds::VertexAttrib4fvImmediate::ComputeSize();
2062   gles2::cmds::VertexAttrib4fvImmediate* c =
2063       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttrib4fvImmediate>(
2064           size);
2065   if (c) {
2066     c->Init(indx, values);
2067   }
2068 }
2069
2070 void VertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
2071   gles2::cmds::VertexAttribI4i* c = GetCmdSpace<gles2::cmds::VertexAttribI4i>();
2072   if (c) {
2073     c->Init(indx, x, y, z, w);
2074   }
2075 }
2076
2077 void VertexAttribI4ivImmediate(GLuint indx, const GLint* values) {
2078   const uint32_t size = gles2::cmds::VertexAttribI4ivImmediate::ComputeSize();
2079   gles2::cmds::VertexAttribI4ivImmediate* c =
2080       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttribI4ivImmediate>(
2081           size);
2082   if (c) {
2083     c->Init(indx, values);
2084   }
2085 }
2086
2087 void VertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) {
2088   gles2::cmds::VertexAttribI4ui* c =
2089       GetCmdSpace<gles2::cmds::VertexAttribI4ui>();
2090   if (c) {
2091     c->Init(indx, x, y, z, w);
2092   }
2093 }
2094
2095 void VertexAttribI4uivImmediate(GLuint indx, const GLuint* values) {
2096   const uint32_t size = gles2::cmds::VertexAttribI4uivImmediate::ComputeSize();
2097   gles2::cmds::VertexAttribI4uivImmediate* c =
2098       GetImmediateCmdSpaceTotalSize<gles2::cmds::VertexAttribI4uivImmediate>(
2099           size);
2100   if (c) {
2101     c->Init(indx, values);
2102   }
2103 }
2104
2105 void VertexAttribIPointer(GLuint indx,
2106                           GLint size,
2107                           GLenum type,
2108                           GLsizei stride,
2109                           GLuint offset) {
2110   gles2::cmds::VertexAttribIPointer* c =
2111       GetCmdSpace<gles2::cmds::VertexAttribIPointer>();
2112   if (c) {
2113     c->Init(indx, size, type, stride, offset);
2114   }
2115 }
2116
2117 void VertexAttribPointer(GLuint indx,
2118                          GLint size,
2119                          GLenum type,
2120                          GLboolean normalized,
2121                          GLsizei stride,
2122                          GLuint offset) {
2123   gles2::cmds::VertexAttribPointer* c =
2124       GetCmdSpace<gles2::cmds::VertexAttribPointer>();
2125   if (c) {
2126     c->Init(indx, size, type, normalized, stride, offset);
2127   }
2128 }
2129
2130 void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
2131   gles2::cmds::Viewport* c = GetCmdSpace<gles2::cmds::Viewport>();
2132   if (c) {
2133     c->Init(x, y, width, height);
2134   }
2135 }
2136
2137 void WaitSync(GLuint sync,
2138               GLbitfield flags,
2139               GLuint timeout_0,
2140               GLuint timeout_1) {
2141   gles2::cmds::WaitSync* c = GetCmdSpace<gles2::cmds::WaitSync>();
2142   if (c) {
2143     c->Init(sync, flags, timeout_0, timeout_1);
2144   }
2145 }
2146
2147 void BlitFramebufferCHROMIUM(GLint srcX0,
2148                              GLint srcY0,
2149                              GLint srcX1,
2150                              GLint srcY1,
2151                              GLint dstX0,
2152                              GLint dstY0,
2153                              GLint dstX1,
2154                              GLint dstY1,
2155                              GLbitfield mask,
2156                              GLenum filter) {
2157   gles2::cmds::BlitFramebufferCHROMIUM* c =
2158       GetCmdSpace<gles2::cmds::BlitFramebufferCHROMIUM>();
2159   if (c) {
2160     c->Init(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
2161             filter);
2162   }
2163 }
2164
2165 void RenderbufferStorageMultisampleCHROMIUM(GLenum target,
2166                                             GLsizei samples,
2167                                             GLenum internalformat,
2168                                             GLsizei width,
2169                                             GLsizei height) {
2170   gles2::cmds::RenderbufferStorageMultisampleCHROMIUM* c =
2171       GetCmdSpace<gles2::cmds::RenderbufferStorageMultisampleCHROMIUM>();
2172   if (c) {
2173     c->Init(target, samples, internalformat, width, height);
2174   }
2175 }
2176
2177 void RenderbufferStorageMultisampleEXT(GLenum target,
2178                                        GLsizei samples,
2179                                        GLenum internalformat,
2180                                        GLsizei width,
2181                                        GLsizei height) {
2182   gles2::cmds::RenderbufferStorageMultisampleEXT* c =
2183       GetCmdSpace<gles2::cmds::RenderbufferStorageMultisampleEXT>();
2184   if (c) {
2185     c->Init(target, samples, internalformat, width, height);
2186   }
2187 }
2188
2189 void FramebufferTexture2DMultisampleEXT(GLenum target,
2190                                         GLenum attachment,
2191                                         GLenum textarget,
2192                                         GLuint texture,
2193                                         GLsizei samples) {
2194   gles2::cmds::FramebufferTexture2DMultisampleEXT* c =
2195       GetCmdSpace<gles2::cmds::FramebufferTexture2DMultisampleEXT>();
2196   if (c) {
2197     c->Init(target, attachment, textarget, texture, samples);
2198   }
2199 }
2200
2201 void TexStorage2DEXT(GLenum target,
2202                      GLsizei levels,
2203                      GLenum internalFormat,
2204                      GLsizei width,
2205                      GLsizei height) {
2206   gles2::cmds::TexStorage2DEXT* c = GetCmdSpace<gles2::cmds::TexStorage2DEXT>();
2207   if (c) {
2208     c->Init(target, levels, internalFormat, width, height);
2209   }
2210 }
2211
2212 void GenQueriesEXTImmediate(GLsizei n, GLuint* queries) {
2213   const uint32_t size = gles2::cmds::GenQueriesEXTImmediate::ComputeSize(n);
2214   gles2::cmds::GenQueriesEXTImmediate* c =
2215       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenQueriesEXTImmediate>(size);
2216   if (c) {
2217     c->Init(n, queries);
2218   }
2219 }
2220
2221 void DeleteQueriesEXTImmediate(GLsizei n, const GLuint* queries) {
2222   const uint32_t size = gles2::cmds::DeleteQueriesEXTImmediate::ComputeSize(n);
2223   gles2::cmds::DeleteQueriesEXTImmediate* c =
2224       GetImmediateCmdSpaceTotalSize<gles2::cmds::DeleteQueriesEXTImmediate>(
2225           size);
2226   if (c) {
2227     c->Init(n, queries);
2228   }
2229 }
2230
2231 void BeginQueryEXT(GLenum target,
2232                    GLuint id,
2233                    uint32_t sync_data_shm_id,
2234                    uint32_t sync_data_shm_offset) {
2235   gles2::cmds::BeginQueryEXT* c = GetCmdSpace<gles2::cmds::BeginQueryEXT>();
2236   if (c) {
2237     c->Init(target, id, sync_data_shm_id, sync_data_shm_offset);
2238   }
2239 }
2240
2241 void BeginTransformFeedback(GLenum primitivemode) {
2242   gles2::cmds::BeginTransformFeedback* c =
2243       GetCmdSpace<gles2::cmds::BeginTransformFeedback>();
2244   if (c) {
2245     c->Init(primitivemode);
2246   }
2247 }
2248
2249 void EndQueryEXT(GLenum target, GLuint submit_count) {
2250   gles2::cmds::EndQueryEXT* c = GetCmdSpace<gles2::cmds::EndQueryEXT>();
2251   if (c) {
2252     c->Init(target, submit_count);
2253   }
2254 }
2255
2256 void EndTransformFeedback() {
2257   gles2::cmds::EndTransformFeedback* c =
2258       GetCmdSpace<gles2::cmds::EndTransformFeedback>();
2259   if (c) {
2260     c->Init();
2261   }
2262 }
2263
2264 void InsertEventMarkerEXT(GLuint bucket_id) {
2265   gles2::cmds::InsertEventMarkerEXT* c =
2266       GetCmdSpace<gles2::cmds::InsertEventMarkerEXT>();
2267   if (c) {
2268     c->Init(bucket_id);
2269   }
2270 }
2271
2272 void PushGroupMarkerEXT(GLuint bucket_id) {
2273   gles2::cmds::PushGroupMarkerEXT* c =
2274       GetCmdSpace<gles2::cmds::PushGroupMarkerEXT>();
2275   if (c) {
2276     c->Init(bucket_id);
2277   }
2278 }
2279
2280 void PopGroupMarkerEXT() {
2281   gles2::cmds::PopGroupMarkerEXT* c =
2282       GetCmdSpace<gles2::cmds::PopGroupMarkerEXT>();
2283   if (c) {
2284     c->Init();
2285   }
2286 }
2287
2288 void GenVertexArraysOESImmediate(GLsizei n, GLuint* arrays) {
2289   const uint32_t size =
2290       gles2::cmds::GenVertexArraysOESImmediate::ComputeSize(n);
2291   gles2::cmds::GenVertexArraysOESImmediate* c =
2292       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenVertexArraysOESImmediate>(
2293           size);
2294   if (c) {
2295     c->Init(n, arrays);
2296   }
2297 }
2298
2299 void DeleteVertexArraysOESImmediate(GLsizei n, const GLuint* arrays) {
2300   const uint32_t size =
2301       gles2::cmds::DeleteVertexArraysOESImmediate::ComputeSize(n);
2302   gles2::cmds::DeleteVertexArraysOESImmediate* c =
2303       GetImmediateCmdSpaceTotalSize<
2304           gles2::cmds::DeleteVertexArraysOESImmediate>(size);
2305   if (c) {
2306     c->Init(n, arrays);
2307   }
2308 }
2309
2310 void IsVertexArrayOES(GLuint array,
2311                       uint32_t result_shm_id,
2312                       uint32_t result_shm_offset) {
2313   gles2::cmds::IsVertexArrayOES* c =
2314       GetCmdSpace<gles2::cmds::IsVertexArrayOES>();
2315   if (c) {
2316     c->Init(array, result_shm_id, result_shm_offset);
2317   }
2318 }
2319
2320 void BindVertexArrayOES(GLuint array) {
2321   gles2::cmds::BindVertexArrayOES* c =
2322       GetCmdSpace<gles2::cmds::BindVertexArrayOES>();
2323   if (c) {
2324     c->Init(array);
2325   }
2326 }
2327
2328 void SwapBuffers() {
2329   gles2::cmds::SwapBuffers* c = GetCmdSpace<gles2::cmds::SwapBuffers>();
2330   if (c) {
2331     c->Init();
2332   }
2333 }
2334
2335 void GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
2336                                  GLsizei count,
2337                                  GLenum type,
2338                                  GLuint offset,
2339                                  uint32_t result_shm_id,
2340                                  uint32_t result_shm_offset) {
2341   gles2::cmds::GetMaxValueInBufferCHROMIUM* c =
2342       GetCmdSpace<gles2::cmds::GetMaxValueInBufferCHROMIUM>();
2343   if (c) {
2344     c->Init(buffer_id, count, type, offset, result_shm_id, result_shm_offset);
2345   }
2346 }
2347
2348 void EnableFeatureCHROMIUM(GLuint bucket_id,
2349                            uint32_t result_shm_id,
2350                            uint32_t result_shm_offset) {
2351   gles2::cmds::EnableFeatureCHROMIUM* c =
2352       GetCmdSpace<gles2::cmds::EnableFeatureCHROMIUM>();
2353   if (c) {
2354     c->Init(bucket_id, result_shm_id, result_shm_offset);
2355   }
2356 }
2357
2358 void MapBufferRange(GLenum target,
2359                     GLintptr offset,
2360                     GLsizeiptr size,
2361                     GLbitfield access,
2362                     uint32_t data_shm_id,
2363                     uint32_t data_shm_offset,
2364                     uint32_t result_shm_id,
2365                     uint32_t result_shm_offset) {
2366   gles2::cmds::MapBufferRange* c = GetCmdSpace<gles2::cmds::MapBufferRange>();
2367   if (c) {
2368     c->Init(target, offset, size, access, data_shm_id, data_shm_offset,
2369             result_shm_id, result_shm_offset);
2370   }
2371 }
2372
2373 void UnmapBuffer(GLenum target) {
2374   gles2::cmds::UnmapBuffer* c = GetCmdSpace<gles2::cmds::UnmapBuffer>();
2375   if (c) {
2376     c->Init(target);
2377   }
2378 }
2379
2380 void ResizeCHROMIUM(GLuint width, GLuint height, GLfloat scale_factor) {
2381   gles2::cmds::ResizeCHROMIUM* c = GetCmdSpace<gles2::cmds::ResizeCHROMIUM>();
2382   if (c) {
2383     c->Init(width, height, scale_factor);
2384   }
2385 }
2386
2387 void GetRequestableExtensionsCHROMIUM(uint32_t bucket_id) {
2388   gles2::cmds::GetRequestableExtensionsCHROMIUM* c =
2389       GetCmdSpace<gles2::cmds::GetRequestableExtensionsCHROMIUM>();
2390   if (c) {
2391     c->Init(bucket_id);
2392   }
2393 }
2394
2395 void RequestExtensionCHROMIUM(uint32_t bucket_id) {
2396   gles2::cmds::RequestExtensionCHROMIUM* c =
2397       GetCmdSpace<gles2::cmds::RequestExtensionCHROMIUM>();
2398   if (c) {
2399     c->Init(bucket_id);
2400   }
2401 }
2402
2403 void GetProgramInfoCHROMIUM(GLuint program, uint32_t bucket_id) {
2404   gles2::cmds::GetProgramInfoCHROMIUM* c =
2405       GetCmdSpace<gles2::cmds::GetProgramInfoCHROMIUM>();
2406   if (c) {
2407     c->Init(program, bucket_id);
2408   }
2409 }
2410
2411 void GetUniformBlocksCHROMIUM(GLuint program, uint32_t bucket_id) {
2412   gles2::cmds::GetUniformBlocksCHROMIUM* c =
2413       GetCmdSpace<gles2::cmds::GetUniformBlocksCHROMIUM>();
2414   if (c) {
2415     c->Init(program, bucket_id);
2416   }
2417 }
2418
2419 void GetTransformFeedbackVaryingsCHROMIUM(GLuint program, uint32_t bucket_id) {
2420   gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM* c =
2421       GetCmdSpace<gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM>();
2422   if (c) {
2423     c->Init(program, bucket_id);
2424   }
2425 }
2426
2427 void GetUniformsES3CHROMIUM(GLuint program, uint32_t bucket_id) {
2428   gles2::cmds::GetUniformsES3CHROMIUM* c =
2429       GetCmdSpace<gles2::cmds::GetUniformsES3CHROMIUM>();
2430   if (c) {
2431     c->Init(program, bucket_id);
2432   }
2433 }
2434
2435 void GetTranslatedShaderSourceANGLE(GLuint shader, uint32_t bucket_id) {
2436   gles2::cmds::GetTranslatedShaderSourceANGLE* c =
2437       GetCmdSpace<gles2::cmds::GetTranslatedShaderSourceANGLE>();
2438   if (c) {
2439     c->Init(shader, bucket_id);
2440   }
2441 }
2442
2443 void PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
2444   gles2::cmds::PostSubBufferCHROMIUM* c =
2445       GetCmdSpace<gles2::cmds::PostSubBufferCHROMIUM>();
2446   if (c) {
2447     c->Init(x, y, width, height);
2448   }
2449 }
2450
2451 void TexImageIOSurface2DCHROMIUM(GLenum target,
2452                                  GLsizei width,
2453                                  GLsizei height,
2454                                  GLuint ioSurfaceId,
2455                                  GLuint plane) {
2456   gles2::cmds::TexImageIOSurface2DCHROMIUM* c =
2457       GetCmdSpace<gles2::cmds::TexImageIOSurface2DCHROMIUM>();
2458   if (c) {
2459     c->Init(target, width, height, ioSurfaceId, plane);
2460   }
2461 }
2462
2463 void CopyTextureCHROMIUM(GLenum target,
2464                          GLenum source_id,
2465                          GLenum dest_id,
2466                          GLint internalformat,
2467                          GLenum dest_type) {
2468   gles2::cmds::CopyTextureCHROMIUM* c =
2469       GetCmdSpace<gles2::cmds::CopyTextureCHROMIUM>();
2470   if (c) {
2471     c->Init(target, source_id, dest_id, internalformat, dest_type);
2472   }
2473 }
2474
2475 void CopySubTextureCHROMIUM(GLenum target,
2476                             GLenum source_id,
2477                             GLenum dest_id,
2478                             GLint xoffset,
2479                             GLint yoffset,
2480                             GLint x,
2481                             GLint y,
2482                             GLsizei width,
2483                             GLsizei height) {
2484   gles2::cmds::CopySubTextureCHROMIUM* c =
2485       GetCmdSpace<gles2::cmds::CopySubTextureCHROMIUM>();
2486   if (c) {
2487     c->Init(target, source_id, dest_id, xoffset, yoffset, x, y, width, height);
2488   }
2489 }
2490
2491 void CompressedCopyTextureCHROMIUM(GLenum target,
2492                                    GLenum source_id,
2493                                    GLenum dest_id) {
2494   gles2::cmds::CompressedCopyTextureCHROMIUM* c =
2495       GetCmdSpace<gles2::cmds::CompressedCopyTextureCHROMIUM>();
2496   if (c) {
2497     c->Init(target, source_id, dest_id);
2498   }
2499 }
2500
2501 void DrawArraysInstancedANGLE(GLenum mode,
2502                               GLint first,
2503                               GLsizei count,
2504                               GLsizei primcount) {
2505   gles2::cmds::DrawArraysInstancedANGLE* c =
2506       GetCmdSpace<gles2::cmds::DrawArraysInstancedANGLE>();
2507   if (c) {
2508     c->Init(mode, first, count, primcount);
2509   }
2510 }
2511
2512 void DrawElementsInstancedANGLE(GLenum mode,
2513                                 GLsizei count,
2514                                 GLenum type,
2515                                 GLuint index_offset,
2516                                 GLsizei primcount) {
2517   gles2::cmds::DrawElementsInstancedANGLE* c =
2518       GetCmdSpace<gles2::cmds::DrawElementsInstancedANGLE>();
2519   if (c) {
2520     c->Init(mode, count, type, index_offset, primcount);
2521   }
2522 }
2523
2524 void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
2525   gles2::cmds::VertexAttribDivisorANGLE* c =
2526       GetCmdSpace<gles2::cmds::VertexAttribDivisorANGLE>();
2527   if (c) {
2528     c->Init(index, divisor);
2529   }
2530 }
2531
2532 void ProduceTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
2533   const uint32_t size =
2534       gles2::cmds::ProduceTextureCHROMIUMImmediate::ComputeSize();
2535   gles2::cmds::ProduceTextureCHROMIUMImmediate* c =
2536       GetImmediateCmdSpaceTotalSize<
2537           gles2::cmds::ProduceTextureCHROMIUMImmediate>(size);
2538   if (c) {
2539     c->Init(target, mailbox);
2540   }
2541 }
2542
2543 void ProduceTextureDirectCHROMIUMImmediate(GLuint texture,
2544                                            GLenum target,
2545                                            const GLbyte* mailbox) {
2546   const uint32_t size =
2547       gles2::cmds::ProduceTextureDirectCHROMIUMImmediate::ComputeSize();
2548   gles2::cmds::ProduceTextureDirectCHROMIUMImmediate* c =
2549       GetImmediateCmdSpaceTotalSize<
2550           gles2::cmds::ProduceTextureDirectCHROMIUMImmediate>(size);
2551   if (c) {
2552     c->Init(texture, target, mailbox);
2553   }
2554 }
2555
2556 void ConsumeTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
2557   const uint32_t size =
2558       gles2::cmds::ConsumeTextureCHROMIUMImmediate::ComputeSize();
2559   gles2::cmds::ConsumeTextureCHROMIUMImmediate* c =
2560       GetImmediateCmdSpaceTotalSize<
2561           gles2::cmds::ConsumeTextureCHROMIUMImmediate>(size);
2562   if (c) {
2563     c->Init(target, mailbox);
2564   }
2565 }
2566
2567 void BindUniformLocationCHROMIUMBucket(GLuint program,
2568                                        GLint location,
2569                                        uint32_t name_bucket_id) {
2570   gles2::cmds::BindUniformLocationCHROMIUMBucket* c =
2571       GetCmdSpace<gles2::cmds::BindUniformLocationCHROMIUMBucket>();
2572   if (c) {
2573     c->Init(program, location, name_bucket_id);
2574   }
2575 }
2576
2577 void GenValuebuffersCHROMIUMImmediate(GLsizei n, GLuint* buffers) {
2578   const uint32_t size =
2579       gles2::cmds::GenValuebuffersCHROMIUMImmediate::ComputeSize(n);
2580   gles2::cmds::GenValuebuffersCHROMIUMImmediate* c =
2581       GetImmediateCmdSpaceTotalSize<
2582           gles2::cmds::GenValuebuffersCHROMIUMImmediate>(size);
2583   if (c) {
2584     c->Init(n, buffers);
2585   }
2586 }
2587
2588 void DeleteValuebuffersCHROMIUMImmediate(GLsizei n,
2589                                          const GLuint* valuebuffers) {
2590   const uint32_t size =
2591       gles2::cmds::DeleteValuebuffersCHROMIUMImmediate::ComputeSize(n);
2592   gles2::cmds::DeleteValuebuffersCHROMIUMImmediate* c =
2593       GetImmediateCmdSpaceTotalSize<
2594           gles2::cmds::DeleteValuebuffersCHROMIUMImmediate>(size);
2595   if (c) {
2596     c->Init(n, valuebuffers);
2597   }
2598 }
2599
2600 void IsValuebufferCHROMIUM(GLuint valuebuffer,
2601                            uint32_t result_shm_id,
2602                            uint32_t result_shm_offset) {
2603   gles2::cmds::IsValuebufferCHROMIUM* c =
2604       GetCmdSpace<gles2::cmds::IsValuebufferCHROMIUM>();
2605   if (c) {
2606     c->Init(valuebuffer, result_shm_id, result_shm_offset);
2607   }
2608 }
2609
2610 void BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
2611   gles2::cmds::BindValuebufferCHROMIUM* c =
2612       GetCmdSpace<gles2::cmds::BindValuebufferCHROMIUM>();
2613   if (c) {
2614     c->Init(target, valuebuffer);
2615   }
2616 }
2617
2618 void SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
2619   gles2::cmds::SubscribeValueCHROMIUM* c =
2620       GetCmdSpace<gles2::cmds::SubscribeValueCHROMIUM>();
2621   if (c) {
2622     c->Init(target, subscription);
2623   }
2624 }
2625
2626 void PopulateSubscribedValuesCHROMIUM(GLenum target) {
2627   gles2::cmds::PopulateSubscribedValuesCHROMIUM* c =
2628       GetCmdSpace<gles2::cmds::PopulateSubscribedValuesCHROMIUM>();
2629   if (c) {
2630     c->Init(target);
2631   }
2632 }
2633
2634 void UniformValuebufferCHROMIUM(GLint location,
2635                                 GLenum target,
2636                                 GLenum subscription) {
2637   gles2::cmds::UniformValuebufferCHROMIUM* c =
2638       GetCmdSpace<gles2::cmds::UniformValuebufferCHROMIUM>();
2639   if (c) {
2640     c->Init(location, target, subscription);
2641   }
2642 }
2643
2644 void BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
2645   gles2::cmds::BindTexImage2DCHROMIUM* c =
2646       GetCmdSpace<gles2::cmds::BindTexImage2DCHROMIUM>();
2647   if (c) {
2648     c->Init(target, imageId);
2649   }
2650 }
2651
2652 void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
2653   gles2::cmds::ReleaseTexImage2DCHROMIUM* c =
2654       GetCmdSpace<gles2::cmds::ReleaseTexImage2DCHROMIUM>();
2655   if (c) {
2656     c->Init(target, imageId);
2657   }
2658 }
2659
2660 void TraceBeginCHROMIUM(GLuint category_bucket_id, GLuint name_bucket_id) {
2661   gles2::cmds::TraceBeginCHROMIUM* c =
2662       GetCmdSpace<gles2::cmds::TraceBeginCHROMIUM>();
2663   if (c) {
2664     c->Init(category_bucket_id, name_bucket_id);
2665   }
2666 }
2667
2668 void TraceEndCHROMIUM() {
2669   gles2::cmds::TraceEndCHROMIUM* c =
2670       GetCmdSpace<gles2::cmds::TraceEndCHROMIUM>();
2671   if (c) {
2672     c->Init();
2673   }
2674 }
2675
2676 void AsyncTexSubImage2DCHROMIUM(GLenum target,
2677                                 GLint level,
2678                                 GLint xoffset,
2679                                 GLint yoffset,
2680                                 GLsizei width,
2681                                 GLsizei height,
2682                                 GLenum format,
2683                                 GLenum type,
2684                                 uint32_t data_shm_id,
2685                                 uint32_t data_shm_offset,
2686                                 uint32_t async_upload_token,
2687                                 uint32_t sync_data_shm_id,
2688                                 uint32_t sync_data_shm_offset) {
2689   gles2::cmds::AsyncTexSubImage2DCHROMIUM* c =
2690       GetCmdSpace<gles2::cmds::AsyncTexSubImage2DCHROMIUM>();
2691   if (c) {
2692     c->Init(target, level, xoffset, yoffset, width, height, format, type,
2693             data_shm_id, data_shm_offset, async_upload_token, sync_data_shm_id,
2694             sync_data_shm_offset);
2695   }
2696 }
2697
2698 void AsyncTexImage2DCHROMIUM(GLenum target,
2699                              GLint level,
2700                              GLint internalformat,
2701                              GLsizei width,
2702                              GLsizei height,
2703                              GLenum format,
2704                              GLenum type,
2705                              uint32_t pixels_shm_id,
2706                              uint32_t pixels_shm_offset,
2707                              uint32_t async_upload_token,
2708                              uint32_t sync_data_shm_id,
2709                              uint32_t sync_data_shm_offset) {
2710   gles2::cmds::AsyncTexImage2DCHROMIUM* c =
2711       GetCmdSpace<gles2::cmds::AsyncTexImage2DCHROMIUM>();
2712   if (c) {
2713     c->Init(target, level, internalformat, width, height, format, type,
2714             pixels_shm_id, pixels_shm_offset, async_upload_token,
2715             sync_data_shm_id, sync_data_shm_offset);
2716   }
2717 }
2718
2719 void WaitAsyncTexImage2DCHROMIUM(GLenum target) {
2720   gles2::cmds::WaitAsyncTexImage2DCHROMIUM* c =
2721       GetCmdSpace<gles2::cmds::WaitAsyncTexImage2DCHROMIUM>();
2722   if (c) {
2723     c->Init(target);
2724   }
2725 }
2726
2727 void WaitAllAsyncTexImage2DCHROMIUM() {
2728   gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM* c =
2729       GetCmdSpace<gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM>();
2730   if (c) {
2731     c->Init();
2732   }
2733 }
2734
2735 void DiscardFramebufferEXTImmediate(GLenum target,
2736                                     GLsizei count,
2737                                     const GLenum* attachments) {
2738   const uint32_t size =
2739       gles2::cmds::DiscardFramebufferEXTImmediate::ComputeSize(count);
2740   gles2::cmds::DiscardFramebufferEXTImmediate* c =
2741       GetImmediateCmdSpaceTotalSize<
2742           gles2::cmds::DiscardFramebufferEXTImmediate>(size);
2743   if (c) {
2744     c->Init(target, count, attachments);
2745   }
2746 }
2747
2748 void LoseContextCHROMIUM(GLenum current, GLenum other) {
2749   gles2::cmds::LoseContextCHROMIUM* c =
2750       GetCmdSpace<gles2::cmds::LoseContextCHROMIUM>();
2751   if (c) {
2752     c->Init(current, other);
2753   }
2754 }
2755
2756 void WaitSyncPointCHROMIUM(GLuint sync_point) {
2757   gles2::cmds::WaitSyncPointCHROMIUM* c =
2758       GetCmdSpace<gles2::cmds::WaitSyncPointCHROMIUM>();
2759   if (c) {
2760     c->Init(sync_point);
2761   }
2762 }
2763
2764 void DrawBuffersEXTImmediate(GLsizei count, const GLenum* bufs) {
2765   const uint32_t size =
2766       gles2::cmds::DrawBuffersEXTImmediate::ComputeSize(count);
2767   gles2::cmds::DrawBuffersEXTImmediate* c =
2768       GetImmediateCmdSpaceTotalSize<gles2::cmds::DrawBuffersEXTImmediate>(size);
2769   if (c) {
2770     c->Init(count, bufs);
2771   }
2772 }
2773
2774 void DiscardBackbufferCHROMIUM() {
2775   gles2::cmds::DiscardBackbufferCHROMIUM* c =
2776       GetCmdSpace<gles2::cmds::DiscardBackbufferCHROMIUM>();
2777   if (c) {
2778     c->Init();
2779   }
2780 }
2781
2782 void ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
2783                                   GLenum plane_transform,
2784                                   GLuint overlay_texture_id,
2785                                   GLint bounds_x,
2786                                   GLint bounds_y,
2787                                   GLint bounds_width,
2788                                   GLint bounds_height,
2789                                   GLfloat uv_x,
2790                                   GLfloat uv_y,
2791                                   GLfloat uv_width,
2792                                   GLfloat uv_height) {
2793   gles2::cmds::ScheduleOverlayPlaneCHROMIUM* c =
2794       GetCmdSpace<gles2::cmds::ScheduleOverlayPlaneCHROMIUM>();
2795   if (c) {
2796     c->Init(plane_z_order, plane_transform, overlay_texture_id, bounds_x,
2797             bounds_y, bounds_width, bounds_height, uv_x, uv_y, uv_width,
2798             uv_height);
2799   }
2800 }
2801
2802 void SwapInterval(GLint interval) {
2803   gles2::cmds::SwapInterval* c = GetCmdSpace<gles2::cmds::SwapInterval>();
2804   if (c) {
2805     c->Init(interval);
2806   }
2807 }
2808
2809 void MatrixLoadfCHROMIUMImmediate(GLenum matrixMode, const GLfloat* m) {
2810   const uint32_t size =
2811       gles2::cmds::MatrixLoadfCHROMIUMImmediate::ComputeSize();
2812   gles2::cmds::MatrixLoadfCHROMIUMImmediate* c =
2813       GetImmediateCmdSpaceTotalSize<gles2::cmds::MatrixLoadfCHROMIUMImmediate>(
2814           size);
2815   if (c) {
2816     c->Init(matrixMode, m);
2817   }
2818 }
2819
2820 void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
2821   gles2::cmds::MatrixLoadIdentityCHROMIUM* c =
2822       GetCmdSpace<gles2::cmds::MatrixLoadIdentityCHROMIUM>();
2823   if (c) {
2824     c->Init(matrixMode);
2825   }
2826 }
2827
2828 void BlendBarrierKHR() {
2829   gles2::cmds::BlendBarrierKHR* c = GetCmdSpace<gles2::cmds::BlendBarrierKHR>();
2830   if (c) {
2831     c->Init();
2832   }
2833 }
2834
2835 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_