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