gpu/command_buffer/client/gles2_cmd_helper_autogen.h

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