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 QueryCounterEXT(GLuint id,
2232                      GLenum target,
2233                      uint32_t sync_data_shm_id,
2234                      uint32_t sync_data_shm_offset,
2235                      GLuint submit_count) {
2236   gles2::cmds::QueryCounterEXT* c = GetCmdSpace<gles2::cmds::QueryCounterEXT>();
2237   if (c) {
2238     c->Init(id, target, sync_data_shm_id, sync_data_shm_offset, submit_count);
2239   }
2240 }
2241
2242 void BeginQueryEXT(GLenum target,
2243                    GLuint id,
2244                    uint32_t sync_data_shm_id,
2245                    uint32_t sync_data_shm_offset) {
2246   gles2::cmds::BeginQueryEXT* c = GetCmdSpace<gles2::cmds::BeginQueryEXT>();
2247   if (c) {
2248     c->Init(target, id, sync_data_shm_id, sync_data_shm_offset);
2249   }
2250 }
2251
2252 void BeginTransformFeedback(GLenum primitivemode) {
2253   gles2::cmds::BeginTransformFeedback* c =
2254       GetCmdSpace<gles2::cmds::BeginTransformFeedback>();
2255   if (c) {
2256     c->Init(primitivemode);
2257   }
2258 }
2259
2260 void EndQueryEXT(GLenum target, GLuint submit_count) {
2261   gles2::cmds::EndQueryEXT* c = GetCmdSpace<gles2::cmds::EndQueryEXT>();
2262   if (c) {
2263     c->Init(target, submit_count);
2264   }
2265 }
2266
2267 void EndTransformFeedback() {
2268   gles2::cmds::EndTransformFeedback* c =
2269       GetCmdSpace<gles2::cmds::EndTransformFeedback>();
2270   if (c) {
2271     c->Init();
2272   }
2273 }
2274
2275 void InsertEventMarkerEXT(GLuint bucket_id) {
2276   gles2::cmds::InsertEventMarkerEXT* c =
2277       GetCmdSpace<gles2::cmds::InsertEventMarkerEXT>();
2278   if (c) {
2279     c->Init(bucket_id);
2280   }
2281 }
2282
2283 void PushGroupMarkerEXT(GLuint bucket_id) {
2284   gles2::cmds::PushGroupMarkerEXT* c =
2285       GetCmdSpace<gles2::cmds::PushGroupMarkerEXT>();
2286   if (c) {
2287     c->Init(bucket_id);
2288   }
2289 }
2290
2291 void PopGroupMarkerEXT() {
2292   gles2::cmds::PopGroupMarkerEXT* c =
2293       GetCmdSpace<gles2::cmds::PopGroupMarkerEXT>();
2294   if (c) {
2295     c->Init();
2296   }
2297 }
2298
2299 void GenVertexArraysOESImmediate(GLsizei n, GLuint* arrays) {
2300   const uint32_t size =
2301       gles2::cmds::GenVertexArraysOESImmediate::ComputeSize(n);
2302   gles2::cmds::GenVertexArraysOESImmediate* c =
2303       GetImmediateCmdSpaceTotalSize<gles2::cmds::GenVertexArraysOESImmediate>(
2304           size);
2305   if (c) {
2306     c->Init(n, arrays);
2307   }
2308 }
2309
2310 void DeleteVertexArraysOESImmediate(GLsizei n, const GLuint* arrays) {
2311   const uint32_t size =
2312       gles2::cmds::DeleteVertexArraysOESImmediate::ComputeSize(n);
2313   gles2::cmds::DeleteVertexArraysOESImmediate* c =
2314       GetImmediateCmdSpaceTotalSize<
2315           gles2::cmds::DeleteVertexArraysOESImmediate>(size);
2316   if (c) {
2317     c->Init(n, arrays);
2318   }
2319 }
2320
2321 void IsVertexArrayOES(GLuint array,
2322                       uint32_t result_shm_id,
2323                       uint32_t result_shm_offset) {
2324   gles2::cmds::IsVertexArrayOES* c =
2325       GetCmdSpace<gles2::cmds::IsVertexArrayOES>();
2326   if (c) {
2327     c->Init(array, result_shm_id, result_shm_offset);
2328   }
2329 }
2330
2331 void BindVertexArrayOES(GLuint array) {
2332   gles2::cmds::BindVertexArrayOES* c =
2333       GetCmdSpace<gles2::cmds::BindVertexArrayOES>();
2334   if (c) {
2335     c->Init(array);
2336   }
2337 }
2338
2339 void SwapBuffers() {
2340   gles2::cmds::SwapBuffers* c = GetCmdSpace<gles2::cmds::SwapBuffers>();
2341   if (c) {
2342     c->Init();
2343   }
2344 }
2345
2346 void GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
2347                                  GLsizei count,
2348                                  GLenum type,
2349                                  GLuint offset,
2350                                  uint32_t result_shm_id,
2351                                  uint32_t result_shm_offset) {
2352   gles2::cmds::GetMaxValueInBufferCHROMIUM* c =
2353       GetCmdSpace<gles2::cmds::GetMaxValueInBufferCHROMIUM>();
2354   if (c) {
2355     c->Init(buffer_id, count, type, offset, result_shm_id, result_shm_offset);
2356   }
2357 }
2358
2359 void EnableFeatureCHROMIUM(GLuint bucket_id,
2360                            uint32_t result_shm_id,
2361                            uint32_t result_shm_offset) {
2362   gles2::cmds::EnableFeatureCHROMIUM* c =
2363       GetCmdSpace<gles2::cmds::EnableFeatureCHROMIUM>();
2364   if (c) {
2365     c->Init(bucket_id, result_shm_id, result_shm_offset);
2366   }
2367 }
2368
2369 void MapBufferRange(GLenum target,
2370                     GLintptr offset,
2371                     GLsizeiptr size,
2372                     GLbitfield access,
2373                     uint32_t data_shm_id,
2374                     uint32_t data_shm_offset,
2375                     uint32_t result_shm_id,
2376                     uint32_t result_shm_offset) {
2377   gles2::cmds::MapBufferRange* c = GetCmdSpace<gles2::cmds::MapBufferRange>();
2378   if (c) {
2379     c->Init(target, offset, size, access, data_shm_id, data_shm_offset,
2380             result_shm_id, result_shm_offset);
2381   }
2382 }
2383
2384 void UnmapBuffer(GLenum target) {
2385   gles2::cmds::UnmapBuffer* c = GetCmdSpace<gles2::cmds::UnmapBuffer>();
2386   if (c) {
2387     c->Init(target);
2388   }
2389 }
2390
2391 void ResizeCHROMIUM(GLuint width, GLuint height, GLfloat scale_factor) {
2392   gles2::cmds::ResizeCHROMIUM* c = GetCmdSpace<gles2::cmds::ResizeCHROMIUM>();
2393   if (c) {
2394     c->Init(width, height, scale_factor);
2395   }
2396 }
2397
2398 void GetRequestableExtensionsCHROMIUM(uint32_t bucket_id) {
2399   gles2::cmds::GetRequestableExtensionsCHROMIUM* c =
2400       GetCmdSpace<gles2::cmds::GetRequestableExtensionsCHROMIUM>();
2401   if (c) {
2402     c->Init(bucket_id);
2403   }
2404 }
2405
2406 void RequestExtensionCHROMIUM(uint32_t bucket_id) {
2407   gles2::cmds::RequestExtensionCHROMIUM* c =
2408       GetCmdSpace<gles2::cmds::RequestExtensionCHROMIUM>();
2409   if (c) {
2410     c->Init(bucket_id);
2411   }
2412 }
2413
2414 void GetProgramInfoCHROMIUM(GLuint program, uint32_t bucket_id) {
2415   gles2::cmds::GetProgramInfoCHROMIUM* c =
2416       GetCmdSpace<gles2::cmds::GetProgramInfoCHROMIUM>();
2417   if (c) {
2418     c->Init(program, bucket_id);
2419   }
2420 }
2421
2422 void GetUniformBlocksCHROMIUM(GLuint program, uint32_t bucket_id) {
2423   gles2::cmds::GetUniformBlocksCHROMIUM* c =
2424       GetCmdSpace<gles2::cmds::GetUniformBlocksCHROMIUM>();
2425   if (c) {
2426     c->Init(program, bucket_id);
2427   }
2428 }
2429
2430 void GetTransformFeedbackVaryingsCHROMIUM(GLuint program, uint32_t bucket_id) {
2431   gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM* c =
2432       GetCmdSpace<gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM>();
2433   if (c) {
2434     c->Init(program, bucket_id);
2435   }
2436 }
2437
2438 void GetUniformsES3CHROMIUM(GLuint program, uint32_t bucket_id) {
2439   gles2::cmds::GetUniformsES3CHROMIUM* c =
2440       GetCmdSpace<gles2::cmds::GetUniformsES3CHROMIUM>();
2441   if (c) {
2442     c->Init(program, bucket_id);
2443   }
2444 }
2445
2446 void GetTranslatedShaderSourceANGLE(GLuint shader, uint32_t bucket_id) {
2447   gles2::cmds::GetTranslatedShaderSourceANGLE* c =
2448       GetCmdSpace<gles2::cmds::GetTranslatedShaderSourceANGLE>();
2449   if (c) {
2450     c->Init(shader, bucket_id);
2451   }
2452 }
2453
2454 void PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
2455   gles2::cmds::PostSubBufferCHROMIUM* c =
2456       GetCmdSpace<gles2::cmds::PostSubBufferCHROMIUM>();
2457   if (c) {
2458     c->Init(x, y, width, height);
2459   }
2460 }
2461
2462 void TexImageIOSurface2DCHROMIUM(GLenum target,
2463                                  GLsizei width,
2464                                  GLsizei height,
2465                                  GLuint ioSurfaceId,
2466                                  GLuint plane) {
2467   gles2::cmds::TexImageIOSurface2DCHROMIUM* c =
2468       GetCmdSpace<gles2::cmds::TexImageIOSurface2DCHROMIUM>();
2469   if (c) {
2470     c->Init(target, width, height, ioSurfaceId, plane);
2471   }
2472 }
2473
2474 void CopyTextureCHROMIUM(GLenum target,
2475                          GLenum source_id,
2476                          GLenum dest_id,
2477                          GLint internalformat,
2478                          GLenum dest_type,
2479                          GLboolean unpack_flip_y,
2480                          GLboolean unpack_premultiply_alpha,
2481                          GLboolean unpack_unmultiply_alpha) {
2482   gles2::cmds::CopyTextureCHROMIUM* c =
2483       GetCmdSpace<gles2::cmds::CopyTextureCHROMIUM>();
2484   if (c) {
2485     c->Init(target, source_id, dest_id, internalformat, dest_type,
2486             unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
2487   }
2488 }
2489
2490 void CopySubTextureCHROMIUM(GLenum target,
2491                             GLenum source_id,
2492                             GLenum dest_id,
2493                             GLint xoffset,
2494                             GLint yoffset,
2495                             GLint x,
2496                             GLint y,
2497                             GLsizei width,
2498                             GLsizei height,
2499                             GLboolean unpack_flip_y,
2500                             GLboolean unpack_premultiply_alpha,
2501                             GLboolean unpack_unmultiply_alpha) {
2502   gles2::cmds::CopySubTextureCHROMIUM* c =
2503       GetCmdSpace<gles2::cmds::CopySubTextureCHROMIUM>();
2504   if (c) {
2505     c->Init(target, source_id, dest_id, xoffset, yoffset, x, y, width, height,
2506             unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
2507   }
2508 }
2509
2510 void CompressedCopyTextureCHROMIUM(GLenum target,
2511                                    GLenum source_id,
2512                                    GLenum dest_id) {
2513   gles2::cmds::CompressedCopyTextureCHROMIUM* c =
2514       GetCmdSpace<gles2::cmds::CompressedCopyTextureCHROMIUM>();
2515   if (c) {
2516     c->Init(target, source_id, dest_id);
2517   }
2518 }
2519
2520 void DrawArraysInstancedANGLE(GLenum mode,
2521                               GLint first,
2522                               GLsizei count,
2523                               GLsizei primcount) {
2524   gles2::cmds::DrawArraysInstancedANGLE* c =
2525       GetCmdSpace<gles2::cmds::DrawArraysInstancedANGLE>();
2526   if (c) {
2527     c->Init(mode, first, count, primcount);
2528   }
2529 }
2530
2531 void DrawElementsInstancedANGLE(GLenum mode,
2532                                 GLsizei count,
2533                                 GLenum type,
2534                                 GLuint index_offset,
2535                                 GLsizei primcount) {
2536   gles2::cmds::DrawElementsInstancedANGLE* c =
2537       GetCmdSpace<gles2::cmds::DrawElementsInstancedANGLE>();
2538   if (c) {
2539     c->Init(mode, count, type, index_offset, primcount);
2540   }
2541 }
2542
2543 void VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
2544   gles2::cmds::VertexAttribDivisorANGLE* c =
2545       GetCmdSpace<gles2::cmds::VertexAttribDivisorANGLE>();
2546   if (c) {
2547     c->Init(index, divisor);
2548   }
2549 }
2550
2551 void ProduceTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
2552   const uint32_t size =
2553       gles2::cmds::ProduceTextureCHROMIUMImmediate::ComputeSize();
2554   gles2::cmds::ProduceTextureCHROMIUMImmediate* c =
2555       GetImmediateCmdSpaceTotalSize<
2556           gles2::cmds::ProduceTextureCHROMIUMImmediate>(size);
2557   if (c) {
2558     c->Init(target, mailbox);
2559   }
2560 }
2561
2562 void ProduceTextureDirectCHROMIUMImmediate(GLuint texture,
2563                                            GLenum target,
2564                                            const GLbyte* mailbox) {
2565   const uint32_t size =
2566       gles2::cmds::ProduceTextureDirectCHROMIUMImmediate::ComputeSize();
2567   gles2::cmds::ProduceTextureDirectCHROMIUMImmediate* c =
2568       GetImmediateCmdSpaceTotalSize<
2569           gles2::cmds::ProduceTextureDirectCHROMIUMImmediate>(size);
2570   if (c) {
2571     c->Init(texture, target, mailbox);
2572   }
2573 }
2574
2575 void ConsumeTextureCHROMIUMImmediate(GLenum target, const GLbyte* mailbox) {
2576   const uint32_t size =
2577       gles2::cmds::ConsumeTextureCHROMIUMImmediate::ComputeSize();
2578   gles2::cmds::ConsumeTextureCHROMIUMImmediate* c =
2579       GetImmediateCmdSpaceTotalSize<
2580           gles2::cmds::ConsumeTextureCHROMIUMImmediate>(size);
2581   if (c) {
2582     c->Init(target, mailbox);
2583   }
2584 }
2585
2586 void BindUniformLocationCHROMIUMBucket(GLuint program,
2587                                        GLint location,
2588                                        uint32_t name_bucket_id) {
2589   gles2::cmds::BindUniformLocationCHROMIUMBucket* c =
2590       GetCmdSpace<gles2::cmds::BindUniformLocationCHROMIUMBucket>();
2591   if (c) {
2592     c->Init(program, location, name_bucket_id);
2593   }
2594 }
2595
2596 void GenValuebuffersCHROMIUMImmediate(GLsizei n, GLuint* buffers) {
2597   const uint32_t size =
2598       gles2::cmds::GenValuebuffersCHROMIUMImmediate::ComputeSize(n);
2599   gles2::cmds::GenValuebuffersCHROMIUMImmediate* c =
2600       GetImmediateCmdSpaceTotalSize<
2601           gles2::cmds::GenValuebuffersCHROMIUMImmediate>(size);
2602   if (c) {
2603     c->Init(n, buffers);
2604   }
2605 }
2606
2607 void DeleteValuebuffersCHROMIUMImmediate(GLsizei n,
2608                                          const GLuint* valuebuffers) {
2609   const uint32_t size =
2610       gles2::cmds::DeleteValuebuffersCHROMIUMImmediate::ComputeSize(n);
2611   gles2::cmds::DeleteValuebuffersCHROMIUMImmediate* c =
2612       GetImmediateCmdSpaceTotalSize<
2613           gles2::cmds::DeleteValuebuffersCHROMIUMImmediate>(size);
2614   if (c) {
2615     c->Init(n, valuebuffers);
2616   }
2617 }
2618
2619 void IsValuebufferCHROMIUM(GLuint valuebuffer,
2620                            uint32_t result_shm_id,
2621                            uint32_t result_shm_offset) {
2622   gles2::cmds::IsValuebufferCHROMIUM* c =
2623       GetCmdSpace<gles2::cmds::IsValuebufferCHROMIUM>();
2624   if (c) {
2625     c->Init(valuebuffer, result_shm_id, result_shm_offset);
2626   }
2627 }
2628
2629 void BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
2630   gles2::cmds::BindValuebufferCHROMIUM* c =
2631       GetCmdSpace<gles2::cmds::BindValuebufferCHROMIUM>();
2632   if (c) {
2633     c->Init(target, valuebuffer);
2634   }
2635 }
2636
2637 void SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
2638   gles2::cmds::SubscribeValueCHROMIUM* c =
2639       GetCmdSpace<gles2::cmds::SubscribeValueCHROMIUM>();
2640   if (c) {
2641     c->Init(target, subscription);
2642   }
2643 }
2644
2645 void PopulateSubscribedValuesCHROMIUM(GLenum target) {
2646   gles2::cmds::PopulateSubscribedValuesCHROMIUM* c =
2647       GetCmdSpace<gles2::cmds::PopulateSubscribedValuesCHROMIUM>();
2648   if (c) {
2649     c->Init(target);
2650   }
2651 }
2652
2653 void UniformValuebufferCHROMIUM(GLint location,
2654                                 GLenum target,
2655                                 GLenum subscription) {
2656   gles2::cmds::UniformValuebufferCHROMIUM* c =
2657       GetCmdSpace<gles2::cmds::UniformValuebufferCHROMIUM>();
2658   if (c) {
2659     c->Init(location, target, subscription);
2660   }
2661 }
2662
2663 void BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
2664   gles2::cmds::BindTexImage2DCHROMIUM* c =
2665       GetCmdSpace<gles2::cmds::BindTexImage2DCHROMIUM>();
2666   if (c) {
2667     c->Init(target, imageId);
2668   }
2669 }
2670
2671 void ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
2672   gles2::cmds::ReleaseTexImage2DCHROMIUM* c =
2673       GetCmdSpace<gles2::cmds::ReleaseTexImage2DCHROMIUM>();
2674   if (c) {
2675     c->Init(target, imageId);
2676   }
2677 }
2678
2679 void TraceBeginCHROMIUM(GLuint category_bucket_id, GLuint name_bucket_id) {
2680   gles2::cmds::TraceBeginCHROMIUM* c =
2681       GetCmdSpace<gles2::cmds::TraceBeginCHROMIUM>();
2682   if (c) {
2683     c->Init(category_bucket_id, name_bucket_id);
2684   }
2685 }
2686
2687 void TraceEndCHROMIUM() {
2688   gles2::cmds::TraceEndCHROMIUM* c =
2689       GetCmdSpace<gles2::cmds::TraceEndCHROMIUM>();
2690   if (c) {
2691     c->Init();
2692   }
2693 }
2694
2695 void AsyncTexSubImage2DCHROMIUM(GLenum target,
2696                                 GLint level,
2697                                 GLint xoffset,
2698                                 GLint yoffset,
2699                                 GLsizei width,
2700                                 GLsizei height,
2701                                 GLenum format,
2702                                 GLenum type,
2703                                 uint32_t data_shm_id,
2704                                 uint32_t data_shm_offset,
2705                                 uint32_t async_upload_token,
2706                                 uint32_t sync_data_shm_id,
2707                                 uint32_t sync_data_shm_offset) {
2708   gles2::cmds::AsyncTexSubImage2DCHROMIUM* c =
2709       GetCmdSpace<gles2::cmds::AsyncTexSubImage2DCHROMIUM>();
2710   if (c) {
2711     c->Init(target, level, xoffset, yoffset, width, height, format, type,
2712             data_shm_id, data_shm_offset, async_upload_token, sync_data_shm_id,
2713             sync_data_shm_offset);
2714   }
2715 }
2716
2717 void AsyncTexImage2DCHROMIUM(GLenum target,
2718                              GLint level,
2719                              GLint internalformat,
2720                              GLsizei width,
2721                              GLsizei height,
2722                              GLenum format,
2723                              GLenum type,
2724                              uint32_t pixels_shm_id,
2725                              uint32_t pixels_shm_offset,
2726                              uint32_t async_upload_token,
2727                              uint32_t sync_data_shm_id,
2728                              uint32_t sync_data_shm_offset) {
2729   gles2::cmds::AsyncTexImage2DCHROMIUM* c =
2730       GetCmdSpace<gles2::cmds::AsyncTexImage2DCHROMIUM>();
2731   if (c) {
2732     c->Init(target, level, internalformat, width, height, format, type,
2733             pixels_shm_id, pixels_shm_offset, async_upload_token,
2734             sync_data_shm_id, sync_data_shm_offset);
2735   }
2736 }
2737
2738 void WaitAsyncTexImage2DCHROMIUM(GLenum target) {
2739   gles2::cmds::WaitAsyncTexImage2DCHROMIUM* c =
2740       GetCmdSpace<gles2::cmds::WaitAsyncTexImage2DCHROMIUM>();
2741   if (c) {
2742     c->Init(target);
2743   }
2744 }
2745
2746 void WaitAllAsyncTexImage2DCHROMIUM() {
2747   gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM* c =
2748       GetCmdSpace<gles2::cmds::WaitAllAsyncTexImage2DCHROMIUM>();
2749   if (c) {
2750     c->Init();
2751   }
2752 }
2753
2754 void DiscardFramebufferEXTImmediate(GLenum target,
2755                                     GLsizei count,
2756                                     const GLenum* attachments) {
2757   const uint32_t size =
2758       gles2::cmds::DiscardFramebufferEXTImmediate::ComputeSize(count);
2759   gles2::cmds::DiscardFramebufferEXTImmediate* c =
2760       GetImmediateCmdSpaceTotalSize<
2761           gles2::cmds::DiscardFramebufferEXTImmediate>(size);
2762   if (c) {
2763     c->Init(target, count, attachments);
2764   }
2765 }
2766
2767 void LoseContextCHROMIUM(GLenum current, GLenum other) {
2768   gles2::cmds::LoseContextCHROMIUM* c =
2769       GetCmdSpace<gles2::cmds::LoseContextCHROMIUM>();
2770   if (c) {
2771     c->Init(current, other);
2772   }
2773 }
2774
2775 void WaitSyncPointCHROMIUM(GLuint sync_point) {
2776   gles2::cmds::WaitSyncPointCHROMIUM* c =
2777       GetCmdSpace<gles2::cmds::WaitSyncPointCHROMIUM>();
2778   if (c) {
2779     c->Init(sync_point);
2780   }
2781 }
2782
2783 void DrawBuffersEXTImmediate(GLsizei count, const GLenum* bufs) {
2784   const uint32_t size =
2785       gles2::cmds::DrawBuffersEXTImmediate::ComputeSize(count);
2786   gles2::cmds::DrawBuffersEXTImmediate* c =
2787       GetImmediateCmdSpaceTotalSize<gles2::cmds::DrawBuffersEXTImmediate>(size);
2788   if (c) {
2789     c->Init(count, bufs);
2790   }
2791 }
2792
2793 void DiscardBackbufferCHROMIUM() {
2794   gles2::cmds::DiscardBackbufferCHROMIUM* c =
2795       GetCmdSpace<gles2::cmds::DiscardBackbufferCHROMIUM>();
2796   if (c) {
2797     c->Init();
2798   }
2799 }
2800
2801 void ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
2802                                   GLenum plane_transform,
2803                                   GLuint overlay_texture_id,
2804                                   GLint bounds_x,
2805                                   GLint bounds_y,
2806                                   GLint bounds_width,
2807                                   GLint bounds_height,
2808                                   GLfloat uv_x,
2809                                   GLfloat uv_y,
2810                                   GLfloat uv_width,
2811                                   GLfloat uv_height) {
2812   gles2::cmds::ScheduleOverlayPlaneCHROMIUM* c =
2813       GetCmdSpace<gles2::cmds::ScheduleOverlayPlaneCHROMIUM>();
2814   if (c) {
2815     c->Init(plane_z_order, plane_transform, overlay_texture_id, bounds_x,
2816             bounds_y, bounds_width, bounds_height, uv_x, uv_y, uv_width,
2817             uv_height);
2818   }
2819 }
2820
2821 void SwapInterval(GLint interval) {
2822   gles2::cmds::SwapInterval* c = GetCmdSpace<gles2::cmds::SwapInterval>();
2823   if (c) {
2824     c->Init(interval);
2825   }
2826 }
2827
2828 void FlushDriverCachesCHROMIUM() {
2829   gles2::cmds::FlushDriverCachesCHROMIUM* c =
2830       GetCmdSpace<gles2::cmds::FlushDriverCachesCHROMIUM>();
2831   if (c) {
2832     c->Init();
2833   }
2834 }
2835
2836 void MatrixLoadfCHROMIUMImmediate(GLenum matrixMode, const GLfloat* m) {
2837   const uint32_t size =
2838       gles2::cmds::MatrixLoadfCHROMIUMImmediate::ComputeSize();
2839   gles2::cmds::MatrixLoadfCHROMIUMImmediate* c =
2840       GetImmediateCmdSpaceTotalSize<gles2::cmds::MatrixLoadfCHROMIUMImmediate>(
2841           size);
2842   if (c) {
2843     c->Init(matrixMode, m);
2844   }
2845 }
2846
2847 void MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
2848   gles2::cmds::MatrixLoadIdentityCHROMIUM* c =
2849       GetCmdSpace<gles2::cmds::MatrixLoadIdentityCHROMIUM>();
2850   if (c) {
2851     c->Init(matrixMode);
2852   }
2853 }
2854
2855 void GenPathsCHROMIUM(GLuint first_client_id, GLsizei range) {
2856   gles2::cmds::GenPathsCHROMIUM* c =
2857       GetCmdSpace<gles2::cmds::GenPathsCHROMIUM>();
2858   if (c) {
2859     c->Init(first_client_id, range);
2860   }
2861 }
2862
2863 void DeletePathsCHROMIUM(GLuint first_client_id, GLsizei range) {
2864   gles2::cmds::DeletePathsCHROMIUM* c =
2865       GetCmdSpace<gles2::cmds::DeletePathsCHROMIUM>();
2866   if (c) {
2867     c->Init(first_client_id, range);
2868   }
2869 }
2870
2871 void IsPathCHROMIUM(GLuint path,
2872                     uint32_t result_shm_id,
2873                     uint32_t result_shm_offset) {
2874   gles2::cmds::IsPathCHROMIUM* c = GetCmdSpace<gles2::cmds::IsPathCHROMIUM>();
2875   if (c) {
2876     c->Init(path, result_shm_id, result_shm_offset);
2877   }
2878 }
2879
2880 void PathCommandsCHROMIUM(GLuint path,
2881                           GLsizei numCommands,
2882                           uint32_t commands_shm_id,
2883                           uint32_t commands_shm_offset,
2884                           GLsizei numCoords,
2885                           GLenum coordType,
2886                           uint32_t coords_shm_id,
2887                           uint32_t coords_shm_offset) {
2888   gles2::cmds::PathCommandsCHROMIUM* c =
2889       GetCmdSpace<gles2::cmds::PathCommandsCHROMIUM>();
2890   if (c) {
2891     c->Init(path, numCommands, commands_shm_id, commands_shm_offset, numCoords,
2892             coordType, coords_shm_id, coords_shm_offset);
2893   }
2894 }
2895
2896 void PathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value) {
2897   gles2::cmds::PathParameterfCHROMIUM* c =
2898       GetCmdSpace<gles2::cmds::PathParameterfCHROMIUM>();
2899   if (c) {
2900     c->Init(path, pname, value);
2901   }
2902 }
2903
2904 void PathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value) {
2905   gles2::cmds::PathParameteriCHROMIUM* c =
2906       GetCmdSpace<gles2::cmds::PathParameteriCHROMIUM>();
2907   if (c) {
2908     c->Init(path, pname, value);
2909   }
2910 }
2911
2912 void PathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask) {
2913   gles2::cmds::PathStencilFuncCHROMIUM* c =
2914       GetCmdSpace<gles2::cmds::PathStencilFuncCHROMIUM>();
2915   if (c) {
2916     c->Init(func, ref, mask);
2917   }
2918 }
2919
2920 void StencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask) {
2921   gles2::cmds::StencilFillPathCHROMIUM* c =
2922       GetCmdSpace<gles2::cmds::StencilFillPathCHROMIUM>();
2923   if (c) {
2924     c->Init(path, fillMode, mask);
2925   }
2926 }
2927
2928 void StencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask) {
2929   gles2::cmds::StencilStrokePathCHROMIUM* c =
2930       GetCmdSpace<gles2::cmds::StencilStrokePathCHROMIUM>();
2931   if (c) {
2932     c->Init(path, reference, mask);
2933   }
2934 }
2935
2936 void CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
2937   gles2::cmds::CoverFillPathCHROMIUM* c =
2938       GetCmdSpace<gles2::cmds::CoverFillPathCHROMIUM>();
2939   if (c) {
2940     c->Init(path, coverMode);
2941   }
2942 }
2943
2944 void CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
2945   gles2::cmds::CoverStrokePathCHROMIUM* c =
2946       GetCmdSpace<gles2::cmds::CoverStrokePathCHROMIUM>();
2947   if (c) {
2948     c->Init(path, coverMode);
2949   }
2950 }
2951
2952 void StencilThenCoverFillPathCHROMIUM(GLuint path,
2953                                       GLenum fillMode,
2954                                       GLuint mask,
2955                                       GLenum coverMode) {
2956   gles2::cmds::StencilThenCoverFillPathCHROMIUM* c =
2957       GetCmdSpace<gles2::cmds::StencilThenCoverFillPathCHROMIUM>();
2958   if (c) {
2959     c->Init(path, fillMode, mask, coverMode);
2960   }
2961 }
2962
2963 void StencilThenCoverStrokePathCHROMIUM(GLuint path,
2964                                         GLint reference,
2965                                         GLuint mask,
2966                                         GLenum coverMode) {
2967   gles2::cmds::StencilThenCoverStrokePathCHROMIUM* c =
2968       GetCmdSpace<gles2::cmds::StencilThenCoverStrokePathCHROMIUM>();
2969   if (c) {
2970     c->Init(path, reference, mask, coverMode);
2971   }
2972 }
2973
2974 void BlendBarrierKHR() {
2975   gles2::cmds::BlendBarrierKHR* c = GetCmdSpace<gles2::cmds::BlendBarrierKHR>();
2976   if (c) {
2977     c->Init();
2978   }
2979 }
2980
2981 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_