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