mojo/gpu/mojo_gles2_impl_autogen.cc

   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 #include "mojo/gpu/mojo_gles2_impl_autogen.h"
  12
  13 #include "base/logging.h"
  14 #include "third_party/mojo/src/mojo/public/c/gles2/chromium_miscellaneous.h"
  15 #include "third_party/mojo/src/mojo/public/c/gles2/chromium_sub_image.h"
  16 #include "third_party/mojo/src/mojo/public/c/gles2/chromium_sync_point.h"
  17 #include "third_party/mojo/src/mojo/public/c/gles2/chromium_texture_mailbox.h"
  18 #include "third_party/mojo/src/mojo/public/c/gles2/gles2.h"
  19 #include "third_party/mojo/src/mojo/public/c/gles2/occlusion_query_ext.h"
  20
  21 namespace mojo {
  22
  23 void MojoGLES2Impl::ActiveTexture(GLenum texture) {
  24   MojoGLES2MakeCurrent(context_);
  25   glActiveTexture(texture);
  26 }
  27 void MojoGLES2Impl::AttachShader(GLuint program, GLuint shader) {
  28   MojoGLES2MakeCurrent(context_);
  29   glAttachShader(program, shader);
  30 }
  31 void MojoGLES2Impl::BindAttribLocation(GLuint program,
  32                                        GLuint index,
  33                                        const char* name) {
  34   MojoGLES2MakeCurrent(context_);
  35   glBindAttribLocation(program, index, name);
  36 }
  37 void MojoGLES2Impl::BindBuffer(GLenum target, GLuint buffer) {
  38   MojoGLES2MakeCurrent(context_);
  39   glBindBuffer(target, buffer);
  40 }
  41 void MojoGLES2Impl::BindBufferBase(GLenum target, GLuint index, GLuint buffer) {
  42   NOTREACHED() << "Unimplemented BindBufferBase.";
  43 }
  44 void MojoGLES2Impl::BindBufferRange(GLenum target,
  45                                     GLuint index,
  46                                     GLuint buffer,
  47                                     GLintptr offset,
  48                                     GLsizeiptr size) {
  49   NOTREACHED() << "Unimplemented BindBufferRange.";
  50 }
  51 void MojoGLES2Impl::BindFramebuffer(GLenum target, GLuint framebuffer) {
  52   MojoGLES2MakeCurrent(context_);
  53   glBindFramebuffer(target, framebuffer);
  54 }
  55 void MojoGLES2Impl::BindRenderbuffer(GLenum target, GLuint renderbuffer) {
  56   MojoGLES2MakeCurrent(context_);
  57   glBindRenderbuffer(target, renderbuffer);
  58 }
  59 void MojoGLES2Impl::BindSampler(GLuint unit, GLuint sampler) {
  60   NOTREACHED() << "Unimplemented BindSampler.";
  61 }
  62 void MojoGLES2Impl::BindTexture(GLenum target, GLuint texture) {
  63   MojoGLES2MakeCurrent(context_);
  64   glBindTexture(target, texture);
  65 }
  66 void MojoGLES2Impl::BindTransformFeedback(GLenum target,
  67                                           GLuint transformfeedback) {
  68   NOTREACHED() << "Unimplemented BindTransformFeedback.";
  69 }
  70 void MojoGLES2Impl::BlendColor(GLclampf red,
  71                                GLclampf green,
  72                                GLclampf blue,
  73                                GLclampf alpha) {
  74   MojoGLES2MakeCurrent(context_);
  75   glBlendColor(red, green, blue, alpha);
  76 }
  77 void MojoGLES2Impl::BlendEquation(GLenum mode) {
  78   MojoGLES2MakeCurrent(context_);
  79   glBlendEquation(mode);
  80 }
  81 void MojoGLES2Impl::BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
  82   MojoGLES2MakeCurrent(context_);
  83   glBlendEquationSeparate(modeRGB, modeAlpha);
  84 }
  85 void MojoGLES2Impl::BlendFunc(GLenum sfactor, GLenum dfactor) {
  86   MojoGLES2MakeCurrent(context_);
  87   glBlendFunc(sfactor, dfactor);
  88 }
  89 void MojoGLES2Impl::BlendFuncSeparate(GLenum srcRGB,
  90                                       GLenum dstRGB,
  91                                       GLenum srcAlpha,
  92                                       GLenum dstAlpha) {
  93   MojoGLES2MakeCurrent(context_);
  94   glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
  95 }
  96 void MojoGLES2Impl::BufferData(GLenum target,
  97                                GLsizeiptr size,
  98                                const void* data,
  99                                GLenum usage) {
 100   MojoGLES2MakeCurrent(context_);
 101   glBufferData(target, size, data, usage);
 102 }
 103 void MojoGLES2Impl::BufferSubData(GLenum target,
 104                                   GLintptr offset,
 105                                   GLsizeiptr size,
 106                                   const void* data) {
 107   MojoGLES2MakeCurrent(context_);
 108   glBufferSubData(target, offset, size, data);
 109 }
 110 GLenum MojoGLES2Impl::CheckFramebufferStatus(GLenum target) {
 111   MojoGLES2MakeCurrent(context_);
 112   return glCheckFramebufferStatus(target);
 113 }
 114 void MojoGLES2Impl::Clear(GLbitfield mask) {
 115   MojoGLES2MakeCurrent(context_);
 116   glClear(mask);
 117 }
 118 void MojoGLES2Impl::ClearBufferfi(GLenum buffer,
 119                                   GLint drawbuffers,
 120                                   GLfloat depth,
 121                                   GLint stencil) {
 122   NOTREACHED() << "Unimplemented ClearBufferfi.";
 123 }
 124 void MojoGLES2Impl::ClearBufferfv(GLenum buffer,
 125                                   GLint drawbuffers,
 126                                   const GLfloat* value) {
 127   NOTREACHED() << "Unimplemented ClearBufferfv.";
 128 }
 129 void MojoGLES2Impl::ClearBufferiv(GLenum buffer,
 130                                   GLint drawbuffers,
 131                                   const GLint* value) {
 132   NOTREACHED() << "Unimplemented ClearBufferiv.";
 133 }
 134 void MojoGLES2Impl::ClearBufferuiv(GLenum buffer,
 135                                    GLint drawbuffers,
 136                                    const GLuint* value) {
 137   NOTREACHED() << "Unimplemented ClearBufferuiv.";
 138 }
 139 void MojoGLES2Impl::ClearColor(GLclampf red,
 140                                GLclampf green,
 141                                GLclampf blue,
 142                                GLclampf alpha) {
 143   MojoGLES2MakeCurrent(context_);
 144   glClearColor(red, green, blue, alpha);
 145 }
 146 void MojoGLES2Impl::ClearDepthf(GLclampf depth) {
 147   MojoGLES2MakeCurrent(context_);
 148   glClearDepthf(depth);
 149 }
 150 void MojoGLES2Impl::ClearStencil(GLint s) {
 151   MojoGLES2MakeCurrent(context_);
 152   glClearStencil(s);
 153 }
 154 GLenum MojoGLES2Impl::ClientWaitSync(GLsync sync,
 155                                      GLbitfield flags,
 156                                      GLuint64 timeout) {
 157   NOTREACHED() << "Unimplemented ClientWaitSync.";
 158   return 0;
 159 }
 160 void MojoGLES2Impl::ColorMask(GLboolean red,
 161                               GLboolean green,
 162                               GLboolean blue,
 163                               GLboolean alpha) {
 164   MojoGLES2MakeCurrent(context_);
 165   glColorMask(red, green, blue, alpha);
 166 }
 167 void MojoGLES2Impl::CompileShader(GLuint shader) {
 168   MojoGLES2MakeCurrent(context_);
 169   glCompileShader(shader);
 170 }
 171 void MojoGLES2Impl::CompressedTexImage2D(GLenum target,
 172                                          GLint level,
 173                                          GLenum internalformat,
 174                                          GLsizei width,
 175                                          GLsizei height,
 176                                          GLint border,
 177                                          GLsizei imageSize,
 178                                          const void* data) {
 179   MojoGLES2MakeCurrent(context_);
 180   glCompressedTexImage2D(target, level, internalformat, width, height, border,
 181                          imageSize, data);
 182 }
 183 void MojoGLES2Impl::CompressedTexSubImage2D(GLenum target,
 184                                             GLint level,
 185                                             GLint xoffset,
 186                                             GLint yoffset,
 187                                             GLsizei width,
 188                                             GLsizei height,
 189                                             GLenum format,
 190                                             GLsizei imageSize,
 191                                             const void* data) {
 192   MojoGLES2MakeCurrent(context_);
 193   glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
 194                             format, imageSize, data);
 195 }
 196 void MojoGLES2Impl::CopyBufferSubData(GLenum readtarget,
 197                                       GLenum writetarget,
 198                                       GLintptr readoffset,
 199                                       GLintptr writeoffset,
 200                                       GLsizeiptr size) {
 201   NOTREACHED() << "Unimplemented CopyBufferSubData.";
 202 }
 203 void MojoGLES2Impl::CopyTexImage2D(GLenum target,
 204                                    GLint level,
 205                                    GLenum internalformat,
 206                                    GLint x,
 207                                    GLint y,
 208                                    GLsizei width,
 209                                    GLsizei height,
 210                                    GLint border) {
 211   MojoGLES2MakeCurrent(context_);
 212   glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 213 }
 214 void MojoGLES2Impl::CopyTexSubImage2D(GLenum target,
 215                                       GLint level,
 216                                       GLint xoffset,
 217                                       GLint yoffset,
 218                                       GLint x,
 219                                       GLint y,
 220                                       GLsizei width,
 221                                       GLsizei height) {
 222   MojoGLES2MakeCurrent(context_);
 223   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 224 }
 225 void MojoGLES2Impl::CopyTexSubImage3D(GLenum target,
 226                                       GLint level,
 227                                       GLint xoffset,
 228                                       GLint yoffset,
 229                                       GLint zoffset,
 230                                       GLint x,
 231                                       GLint y,
 232                                       GLsizei width,
 233                                       GLsizei height) {
 234   NOTREACHED() << "Unimplemented CopyTexSubImage3D.";
 235 }
 236 GLuint MojoGLES2Impl::CreateProgram() {
 237   MojoGLES2MakeCurrent(context_);
 238   return glCreateProgram();
 239 }
 240 GLuint MojoGLES2Impl::CreateShader(GLenum type) {
 241   MojoGLES2MakeCurrent(context_);
 242   return glCreateShader(type);
 243 }
 244 void MojoGLES2Impl::CullFace(GLenum mode) {
 245   MojoGLES2MakeCurrent(context_);
 246   glCullFace(mode);
 247 }
 248 void MojoGLES2Impl::DeleteBuffers(GLsizei n, const GLuint* buffers) {
 249   MojoGLES2MakeCurrent(context_);
 250   glDeleteBuffers(n, buffers);
 251 }
 252 void MojoGLES2Impl::DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
 253   MojoGLES2MakeCurrent(context_);
 254   glDeleteFramebuffers(n, framebuffers);
 255 }
 256 void MojoGLES2Impl::DeleteProgram(GLuint program) {
 257   MojoGLES2MakeCurrent(context_);
 258   glDeleteProgram(program);
 259 }
 260 void MojoGLES2Impl::DeleteRenderbuffers(GLsizei n,
 261                                         const GLuint* renderbuffers) {
 262   MojoGLES2MakeCurrent(context_);
 263   glDeleteRenderbuffers(n, renderbuffers);
 264 }
 265 void MojoGLES2Impl::DeleteSamplers(GLsizei n, const GLuint* samplers) {
 266   NOTREACHED() << "Unimplemented DeleteSamplers.";
 267 }
 268 void MojoGLES2Impl::DeleteSync(GLsync sync) {
 269   NOTREACHED() << "Unimplemented DeleteSync.";
 270 }
 271 void MojoGLES2Impl::DeleteShader(GLuint shader) {
 272   MojoGLES2MakeCurrent(context_);
 273   glDeleteShader(shader);
 274 }
 275 void MojoGLES2Impl::DeleteTextures(GLsizei n, const GLuint* textures) {
 276   MojoGLES2MakeCurrent(context_);
 277   glDeleteTextures(n, textures);
 278 }
 279 void MojoGLES2Impl::DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
 280   NOTREACHED() << "Unimplemented DeleteTransformFeedbacks.";
 281 }
 282 void MojoGLES2Impl::DepthFunc(GLenum func) {
 283   MojoGLES2MakeCurrent(context_);
 284   glDepthFunc(func);
 285 }
 286 void MojoGLES2Impl::DepthMask(GLboolean flag) {
 287   MojoGLES2MakeCurrent(context_);
 288   glDepthMask(flag);
 289 }
 290 void MojoGLES2Impl::DepthRangef(GLclampf zNear, GLclampf zFar) {
 291   MojoGLES2MakeCurrent(context_);
 292   glDepthRangef(zNear, zFar);
 293 }
 294 void MojoGLES2Impl::DetachShader(GLuint program, GLuint shader) {
 295   MojoGLES2MakeCurrent(context_);
 296   glDetachShader(program, shader);
 297 }
 298 void MojoGLES2Impl::Disable(GLenum cap) {
 299   MojoGLES2MakeCurrent(context_);
 300   glDisable(cap);
 301 }
 302 void MojoGLES2Impl::DisableVertexAttribArray(GLuint index) {
 303   MojoGLES2MakeCurrent(context_);
 304   glDisableVertexAttribArray(index);
 305 }
 306 void MojoGLES2Impl::DrawArrays(GLenum mode, GLint first, GLsizei count) {
 307   MojoGLES2MakeCurrent(context_);
 308   glDrawArrays(mode, first, count);
 309 }
 310 void MojoGLES2Impl::DrawElements(GLenum mode,
 311                                  GLsizei count,
 312                                  GLenum type,
 313                                  const void* indices) {
 314   MojoGLES2MakeCurrent(context_);
 315   glDrawElements(mode, count, type, indices);
 316 }
 317 void MojoGLES2Impl::DrawRangeElements(GLenum mode,
 318                                       GLuint start,
 319                                       GLuint end,
 320                                       GLsizei count,
 321                                       GLenum type,
 322                                       const void* indices) {
 323   NOTREACHED() << "Unimplemented DrawRangeElements.";
 324 }
 325 void MojoGLES2Impl::Enable(GLenum cap) {
 326   MojoGLES2MakeCurrent(context_);
 327   glEnable(cap);
 328 }
 329 void MojoGLES2Impl::EnableVertexAttribArray(GLuint index) {
 330   MojoGLES2MakeCurrent(context_);
 331   glEnableVertexAttribArray(index);
 332 }
 333 GLsync MojoGLES2Impl::FenceSync(GLenum condition, GLbitfield flags) {
 334   NOTREACHED() << "Unimplemented FenceSync.";
 335   return 0;
 336 }
 337 void MojoGLES2Impl::Finish() {
 338   MojoGLES2MakeCurrent(context_);
 339   glFinish();
 340 }
 341 void MojoGLES2Impl::Flush() {
 342   MojoGLES2MakeCurrent(context_);
 343   glFlush();
 344 }
 345 void MojoGLES2Impl::FramebufferRenderbuffer(GLenum target,
 346                                             GLenum attachment,
 347                                             GLenum renderbuffertarget,
 348                                             GLuint renderbuffer) {
 349   MojoGLES2MakeCurrent(context_);
 350   glFramebufferRenderbuffer(target, attachment, renderbuffertarget,
 351                             renderbuffer);
 352 }
 353 void MojoGLES2Impl::FramebufferTexture2D(GLenum target,
 354                                          GLenum attachment,
 355                                          GLenum textarget,
 356                                          GLuint texture,
 357                                          GLint level) {
 358   MojoGLES2MakeCurrent(context_);
 359   glFramebufferTexture2D(target, attachment, textarget, texture, level);
 360 }
 361 void MojoGLES2Impl::FramebufferTextureLayer(GLenum target,
 362                                             GLenum attachment,
 363                                             GLuint texture,
 364                                             GLint level,
 365                                             GLint layer) {
 366   NOTREACHED() << "Unimplemented FramebufferTextureLayer.";
 367 }
 368 void MojoGLES2Impl::FrontFace(GLenum mode) {
 369   MojoGLES2MakeCurrent(context_);
 370   glFrontFace(mode);
 371 }
 372 void MojoGLES2Impl::GenBuffers(GLsizei n, GLuint* buffers) {
 373   MojoGLES2MakeCurrent(context_);
 374   glGenBuffers(n, buffers);
 375 }
 376 void MojoGLES2Impl::GenerateMipmap(GLenum target) {
 377   MojoGLES2MakeCurrent(context_);
 378   glGenerateMipmap(target);
 379 }
 380 void MojoGLES2Impl::GenFramebuffers(GLsizei n, GLuint* framebuffers) {
 381   MojoGLES2MakeCurrent(context_);
 382   glGenFramebuffers(n, framebuffers);
 383 }
 384 void MojoGLES2Impl::GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 385   MojoGLES2MakeCurrent(context_);
 386   glGenRenderbuffers(n, renderbuffers);
 387 }
 388 void MojoGLES2Impl::GenSamplers(GLsizei n, GLuint* samplers) {
 389   NOTREACHED() << "Unimplemented GenSamplers.";
 390 }
 391 void MojoGLES2Impl::GenTextures(GLsizei n, GLuint* textures) {
 392   MojoGLES2MakeCurrent(context_);
 393   glGenTextures(n, textures);
 394 }
 395 void MojoGLES2Impl::GenTransformFeedbacks(GLsizei n, GLuint* ids) {
 396   NOTREACHED() << "Unimplemented GenTransformFeedbacks.";
 397 }
 398 void MojoGLES2Impl::GetActiveAttrib(GLuint program,
 399                                     GLuint index,
 400                                     GLsizei bufsize,
 401                                     GLsizei* length,
 402                                     GLint* size,
 403                                     GLenum* type,
 404                                     char* name) {
 405   MojoGLES2MakeCurrent(context_);
 406   glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 407 }
 408 void MojoGLES2Impl::GetActiveUniform(GLuint program,
 409                                      GLuint index,
 410                                      GLsizei bufsize,
 411                                      GLsizei* length,
 412                                      GLint* size,
 413                                      GLenum* type,
 414                                      char* name) {
 415   MojoGLES2MakeCurrent(context_);
 416   glGetActiveUniform(program, index, bufsize, length, size, type, name);
 417 }
 418 void MojoGLES2Impl::GetActiveUniformBlockiv(GLuint program,
 419                                             GLuint index,
 420                                             GLenum pname,
 421                                             GLint* params) {
 422   NOTREACHED() << "Unimplemented GetActiveUniformBlockiv.";
 423 }
 424 void MojoGLES2Impl::GetActiveUniformBlockName(GLuint program,
 425                                               GLuint index,
 426                                               GLsizei bufsize,
 427                                               GLsizei* length,
 428                                               char* name) {
 429   NOTREACHED() << "Unimplemented GetActiveUniformBlockName.";
 430 }
 431 void MojoGLES2Impl::GetActiveUniformsiv(GLuint program,
 432                                         GLsizei count,
 433                                         const GLuint* indices,
 434                                         GLenum pname,
 435                                         GLint* params) {
 436   NOTREACHED() << "Unimplemented GetActiveUniformsiv.";
 437 }
 438 void MojoGLES2Impl::GetAttachedShaders(GLuint program,
 439                                        GLsizei maxcount,
 440                                        GLsizei* count,
 441                                        GLuint* shaders) {
 442   MojoGLES2MakeCurrent(context_);
 443   glGetAttachedShaders(program, maxcount, count, shaders);
 444 }
 445 GLint MojoGLES2Impl::GetAttribLocation(GLuint program, const char* name) {
 446   MojoGLES2MakeCurrent(context_);
 447   return glGetAttribLocation(program, name);
 448 }
 449 void MojoGLES2Impl::GetBooleanv(GLenum pname, GLboolean* params) {
 450   MojoGLES2MakeCurrent(context_);
 451   glGetBooleanv(pname, params);
 452 }
 453 void MojoGLES2Impl::GetBufferParameteriv(GLenum target,
 454                                          GLenum pname,
 455                                          GLint* params) {
 456   MojoGLES2MakeCurrent(context_);
 457   glGetBufferParameteriv(target, pname, params);
 458 }
 459 GLenum MojoGLES2Impl::GetError() {
 460   MojoGLES2MakeCurrent(context_);
 461   return glGetError();
 462 }
 463 void MojoGLES2Impl::GetFloatv(GLenum pname, GLfloat* params) {
 464   MojoGLES2MakeCurrent(context_);
 465   glGetFloatv(pname, params);
 466 }
 467 GLint MojoGLES2Impl::GetFragDataLocation(GLuint program, const char* name) {
 468   NOTREACHED() << "Unimplemented GetFragDataLocation.";
 469   return 0;
 470 }
 471 void MojoGLES2Impl::GetFramebufferAttachmentParameteriv(GLenum target,
 472                                                         GLenum attachment,
 473                                                         GLenum pname,
 474                                                         GLint* params) {
 475   MojoGLES2MakeCurrent(context_);
 476   glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 477 }
 478 void MojoGLES2Impl::GetInteger64v(GLenum pname, GLint64* params) {
 479   NOTREACHED() << "Unimplemented GetInteger64v.";
 480 }
 481 void MojoGLES2Impl::GetIntegeri_v(GLenum pname, GLuint index, GLint* data) {
 482   NOTREACHED() << "Unimplemented GetIntegeri_v.";
 483 }
 484 void MojoGLES2Impl::GetInteger64i_v(GLenum pname, GLuint index, GLint64* data) {
 485   NOTREACHED() << "Unimplemented GetInteger64i_v.";
 486 }
 487 void MojoGLES2Impl::GetIntegerv(GLenum pname, GLint* params) {
 488   MojoGLES2MakeCurrent(context_);
 489   glGetIntegerv(pname, params);
 490 }
 491 void MojoGLES2Impl::GetInternalformativ(GLenum target,
 492                                         GLenum format,
 493                                         GLenum pname,
 494                                         GLsizei bufSize,
 495                                         GLint* params) {
 496   NOTREACHED() << "Unimplemented GetInternalformativ.";
 497 }
 498 void MojoGLES2Impl::GetProgramiv(GLuint program, GLenum pname, GLint* params) {
 499   MojoGLES2MakeCurrent(context_);
 500   glGetProgramiv(program, pname, params);
 501 }
 502 void MojoGLES2Impl::GetProgramInfoLog(GLuint program,
 503                                       GLsizei bufsize,
 504                                       GLsizei* length,
 505                                       char* infolog) {
 506   MojoGLES2MakeCurrent(context_);
 507   glGetProgramInfoLog(program, bufsize, length, infolog);
 508 }
 509 void MojoGLES2Impl::GetRenderbufferParameteriv(GLenum target,
 510                                                GLenum pname,
 511                                                GLint* params) {
 512   MojoGLES2MakeCurrent(context_);
 513   glGetRenderbufferParameteriv(target, pname, params);
 514 }
 515 void MojoGLES2Impl::GetSamplerParameterfv(GLuint sampler,
 516                                           GLenum pname,
 517                                           GLfloat* params) {
 518   NOTREACHED() << "Unimplemented GetSamplerParameterfv.";
 519 }
 520 void MojoGLES2Impl::GetSamplerParameteriv(GLuint sampler,
 521                                           GLenum pname,
 522                                           GLint* params) {
 523   NOTREACHED() << "Unimplemented GetSamplerParameteriv.";
 524 }
 525 void MojoGLES2Impl::GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 526   MojoGLES2MakeCurrent(context_);
 527   glGetShaderiv(shader, pname, params);
 528 }
 529 void MojoGLES2Impl::GetShaderInfoLog(GLuint shader,
 530                                      GLsizei bufsize,
 531                                      GLsizei* length,
 532                                      char* infolog) {
 533   MojoGLES2MakeCurrent(context_);
 534   glGetShaderInfoLog(shader, bufsize, length, infolog);
 535 }
 536 void MojoGLES2Impl::GetShaderPrecisionFormat(GLenum shadertype,
 537                                              GLenum precisiontype,
 538                                              GLint* range,
 539                                              GLint* precision) {
 540   MojoGLES2MakeCurrent(context_);
 541   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 542 }
 543 void MojoGLES2Impl::GetShaderSource(GLuint shader,
 544                                     GLsizei bufsize,
 545                                     GLsizei* length,
 546                                     char* source) {
 547   MojoGLES2MakeCurrent(context_);
 548   glGetShaderSource(shader, bufsize, length, source);
 549 }
 550 const GLubyte* MojoGLES2Impl::GetString(GLenum name) {
 551   MojoGLES2MakeCurrent(context_);
 552   return glGetString(name);
 553 }
 554 void MojoGLES2Impl::GetSynciv(GLsync sync,
 555                               GLenum pname,
 556                               GLsizei bufsize,
 557                               GLsizei* length,
 558                               GLint* values) {
 559   NOTREACHED() << "Unimplemented GetSynciv.";
 560 }
 561 void MojoGLES2Impl::GetTexParameterfv(GLenum target,
 562                                       GLenum pname,
 563                                       GLfloat* params) {
 564   MojoGLES2MakeCurrent(context_);
 565   glGetTexParameterfv(target, pname, params);
 566 }
 567 void MojoGLES2Impl::GetTexParameteriv(GLenum target,
 568                                       GLenum pname,
 569                                       GLint* params) {
 570   MojoGLES2MakeCurrent(context_);
 571   glGetTexParameteriv(target, pname, params);
 572 }
 573 void MojoGLES2Impl::GetTransformFeedbackVarying(GLuint program,
 574                                                 GLuint index,
 575                                                 GLsizei bufsize,
 576                                                 GLsizei* length,
 577                                                 GLsizei* size,
 578                                                 GLenum* type,
 579                                                 char* name) {
 580   NOTREACHED() << "Unimplemented GetTransformFeedbackVarying.";
 581 }
 582 GLuint MojoGLES2Impl::GetUniformBlockIndex(GLuint program, const char* name) {
 583   NOTREACHED() << "Unimplemented GetUniformBlockIndex.";
 584   return 0;
 585 }
 586 void MojoGLES2Impl::GetUniformfv(GLuint program,
 587                                  GLint location,
 588                                  GLfloat* params) {
 589   MojoGLES2MakeCurrent(context_);
 590   glGetUniformfv(program, location, params);
 591 }
 592 void MojoGLES2Impl::GetUniformiv(GLuint program,
 593                                  GLint location,
 594                                  GLint* params) {
 595   MojoGLES2MakeCurrent(context_);
 596   glGetUniformiv(program, location, params);
 597 }
 598 void MojoGLES2Impl::GetUniformIndices(GLuint program,
 599                                       GLsizei count,
 600                                       const char* const* names,
 601                                       GLuint* indices) {
 602   NOTREACHED() << "Unimplemented GetUniformIndices.";
 603 }
 604 GLint MojoGLES2Impl::GetUniformLocation(GLuint program, const char* name) {
 605   MojoGLES2MakeCurrent(context_);
 606   return glGetUniformLocation(program, name);
 607 }
 608 void MojoGLES2Impl::GetVertexAttribfv(GLuint index,
 609                                       GLenum pname,
 610                                       GLfloat* params) {
 611   MojoGLES2MakeCurrent(context_);
 612   glGetVertexAttribfv(index, pname, params);
 613 }
 614 void MojoGLES2Impl::GetVertexAttribiv(GLuint index,
 615                                       GLenum pname,
 616                                       GLint* params) {
 617   MojoGLES2MakeCurrent(context_);
 618   glGetVertexAttribiv(index, pname, params);
 619 }
 620 void MojoGLES2Impl::GetVertexAttribPointerv(GLuint index,
 621                                             GLenum pname,
 622                                             void** pointer) {
 623   MojoGLES2MakeCurrent(context_);
 624   glGetVertexAttribPointerv(index, pname, pointer);
 625 }
 626 void MojoGLES2Impl::Hint(GLenum target, GLenum mode) {
 627   MojoGLES2MakeCurrent(context_);
 628   glHint(target, mode);
 629 }
 630 void MojoGLES2Impl::InvalidateFramebuffer(GLenum target,
 631                                           GLsizei count,
 632                                           const GLenum* attachments) {
 633   NOTREACHED() << "Unimplemented InvalidateFramebuffer.";
 634 }
 635 void MojoGLES2Impl::InvalidateSubFramebuffer(GLenum target,
 636                                              GLsizei count,
 637                                              const GLenum* attachments,
 638                                              GLint x,
 639                                              GLint y,
 640                                              GLsizei width,
 641                                              GLsizei height) {
 642   NOTREACHED() << "Unimplemented InvalidateSubFramebuffer.";
 643 }
 644 GLboolean MojoGLES2Impl::IsBuffer(GLuint buffer) {
 645   MojoGLES2MakeCurrent(context_);
 646   return glIsBuffer(buffer);
 647 }
 648 GLboolean MojoGLES2Impl::IsEnabled(GLenum cap) {
 649   MojoGLES2MakeCurrent(context_);
 650   return glIsEnabled(cap);
 651 }
 652 GLboolean MojoGLES2Impl::IsFramebuffer(GLuint framebuffer) {
 653   MojoGLES2MakeCurrent(context_);
 654   return glIsFramebuffer(framebuffer);
 655 }
 656 GLboolean MojoGLES2Impl::IsProgram(GLuint program) {
 657   MojoGLES2MakeCurrent(context_);
 658   return glIsProgram(program);
 659 }
 660 GLboolean MojoGLES2Impl::IsRenderbuffer(GLuint renderbuffer) {
 661   MojoGLES2MakeCurrent(context_);
 662   return glIsRenderbuffer(renderbuffer);
 663 }
 664 GLboolean MojoGLES2Impl::IsSampler(GLuint sampler) {
 665   NOTREACHED() << "Unimplemented IsSampler.";
 666   return 0;
 667 }
 668 GLboolean MojoGLES2Impl::IsShader(GLuint shader) {
 669   MojoGLES2MakeCurrent(context_);
 670   return glIsShader(shader);
 671 }
 672 GLboolean MojoGLES2Impl::IsSync(GLsync sync) {
 673   NOTREACHED() << "Unimplemented IsSync.";
 674   return 0;
 675 }
 676 GLboolean MojoGLES2Impl::IsTexture(GLuint texture) {
 677   MojoGLES2MakeCurrent(context_);
 678   return glIsTexture(texture);
 679 }
 680 GLboolean MojoGLES2Impl::IsTransformFeedback(GLuint transformfeedback) {
 681   NOTREACHED() << "Unimplemented IsTransformFeedback.";
 682   return 0;
 683 }
 684 void MojoGLES2Impl::LineWidth(GLfloat width) {
 685   MojoGLES2MakeCurrent(context_);
 686   glLineWidth(width);
 687 }
 688 void MojoGLES2Impl::LinkProgram(GLuint program) {
 689   MojoGLES2MakeCurrent(context_);
 690   glLinkProgram(program);
 691 }
 692 void MojoGLES2Impl::PauseTransformFeedback() {
 693   NOTREACHED() << "Unimplemented PauseTransformFeedback.";
 694 }
 695 void MojoGLES2Impl::PixelStorei(GLenum pname, GLint param) {
 696   MojoGLES2MakeCurrent(context_);
 697   glPixelStorei(pname, param);
 698 }
 699 void MojoGLES2Impl::PolygonOffset(GLfloat factor, GLfloat units) {
 700   MojoGLES2MakeCurrent(context_);
 701   glPolygonOffset(factor, units);
 702 }
 703 void MojoGLES2Impl::ReadBuffer(GLenum src) {
 704   NOTREACHED() << "Unimplemented ReadBuffer.";
 705 }
 706 void MojoGLES2Impl::ReadPixels(GLint x,
 707                                GLint y,
 708                                GLsizei width,
 709                                GLsizei height,
 710                                GLenum format,
 711                                GLenum type,
 712                                void* pixels) {
 713   MojoGLES2MakeCurrent(context_);
 714   glReadPixels(x, y, width, height, format, type, pixels);
 715 }
 716 void MojoGLES2Impl::ReleaseShaderCompiler() {
 717   MojoGLES2MakeCurrent(context_);
 718   glReleaseShaderCompiler();
 719 }
 720 void MojoGLES2Impl::RenderbufferStorage(GLenum target,
 721                                         GLenum internalformat,
 722                                         GLsizei width,
 723                                         GLsizei height) {
 724   MojoGLES2MakeCurrent(context_);
 725   glRenderbufferStorage(target, internalformat, width, height);
 726 }
 727 void MojoGLES2Impl::ResumeTransformFeedback() {
 728   NOTREACHED() << "Unimplemented ResumeTransformFeedback.";
 729 }
 730 void MojoGLES2Impl::SampleCoverage(GLclampf value, GLboolean invert) {
 731   MojoGLES2MakeCurrent(context_);
 732   glSampleCoverage(value, invert);
 733 }
 734 void MojoGLES2Impl::SamplerParameterf(GLuint sampler,
 735                                       GLenum pname,
 736                                       GLfloat param) {
 737   NOTREACHED() << "Unimplemented SamplerParameterf.";
 738 }
 739 void MojoGLES2Impl::SamplerParameterfv(GLuint sampler,
 740                                        GLenum pname,
 741                                        const GLfloat* params) {
 742   NOTREACHED() << "Unimplemented SamplerParameterfv.";
 743 }
 744 void MojoGLES2Impl::SamplerParameteri(GLuint sampler,
 745                                       GLenum pname,
 746                                       GLint param) {
 747   NOTREACHED() << "Unimplemented SamplerParameteri.";
 748 }
 749 void MojoGLES2Impl::SamplerParameteriv(GLuint sampler,
 750                                        GLenum pname,
 751                                        const GLint* params) {
 752   NOTREACHED() << "Unimplemented SamplerParameteriv.";
 753 }
 754 void MojoGLES2Impl::Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 755   MojoGLES2MakeCurrent(context_);
 756   glScissor(x, y, width, height);
 757 }
 758 void MojoGLES2Impl::ShaderBinary(GLsizei n,
 759                                  const GLuint* shaders,
 760                                  GLenum binaryformat,
 761                                  const void* binary,
 762                                  GLsizei length) {
 763   MojoGLES2MakeCurrent(context_);
 764   glShaderBinary(n, shaders, binaryformat, binary, length);
 765 }
 766 void MojoGLES2Impl::ShaderSource(GLuint shader,
 767                                  GLsizei count,
 768                                  const GLchar* const* str,
 769                                  const GLint* length) {
 770   MojoGLES2MakeCurrent(context_);
 771   glShaderSource(shader, count, str, length);
 772 }
 773 void MojoGLES2Impl::ShallowFinishCHROMIUM() {
 774   NOTREACHED() << "Unimplemented ShallowFinishCHROMIUM.";
 775 }
 776 void MojoGLES2Impl::ShallowFlushCHROMIUM() {
 777   MojoGLES2MakeCurrent(context_);
 778   glShallowFlushCHROMIUM();
 779 }
 780 void MojoGLES2Impl::OrderingBarrierCHROMIUM() {
 781   NOTREACHED() << "Unimplemented OrderingBarrierCHROMIUM.";
 782 }
 783 void MojoGLES2Impl::StencilFunc(GLenum func, GLint ref, GLuint mask) {
 784   MojoGLES2MakeCurrent(context_);
 785   glStencilFunc(func, ref, mask);
 786 }
 787 void MojoGLES2Impl::StencilFuncSeparate(GLenum face,
 788                                         GLenum func,
 789                                         GLint ref,
 790                                         GLuint mask) {
 791   MojoGLES2MakeCurrent(context_);
 792   glStencilFuncSeparate(face, func, ref, mask);
 793 }
 794 void MojoGLES2Impl::StencilMask(GLuint mask) {
 795   MojoGLES2MakeCurrent(context_);
 796   glStencilMask(mask);
 797 }
 798 void MojoGLES2Impl::StencilMaskSeparate(GLenum face, GLuint mask) {
 799   MojoGLES2MakeCurrent(context_);
 800   glStencilMaskSeparate(face, mask);
 801 }
 802 void MojoGLES2Impl::StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 803   MojoGLES2MakeCurrent(context_);
 804   glStencilOp(fail, zfail, zpass);
 805 }
 806 void MojoGLES2Impl::StencilOpSeparate(GLenum face,
 807                                       GLenum fail,
 808                                       GLenum zfail,
 809                                       GLenum zpass) {
 810   MojoGLES2MakeCurrent(context_);
 811   glStencilOpSeparate(face, fail, zfail, zpass);
 812 }
 813 void MojoGLES2Impl::TexImage2D(GLenum target,
 814                                GLint level,
 815                                GLint internalformat,
 816                                GLsizei width,
 817                                GLsizei height,
 818                                GLint border,
 819                                GLenum format,
 820                                GLenum type,
 821                                const void* pixels) {
 822   MojoGLES2MakeCurrent(context_);
 823   glTexImage2D(target, level, internalformat, width, height, border, format,
 824                type, pixels);
 825 }
 826 void MojoGLES2Impl::TexImage3D(GLenum target,
 827                                GLint level,
 828                                GLint internalformat,
 829                                GLsizei width,
 830                                GLsizei height,
 831                                GLsizei depth,
 832                                GLint border,
 833                                GLenum format,
 834                                GLenum type,
 835                                const void* pixels) {
 836   NOTREACHED() << "Unimplemented TexImage3D.";
 837 }
 838 void MojoGLES2Impl::TexParameterf(GLenum target, GLenum pname, GLfloat param) {
 839   MojoGLES2MakeCurrent(context_);
 840   glTexParameterf(target, pname, param);
 841 }
 842 void MojoGLES2Impl::TexParameterfv(GLenum target,
 843                                    GLenum pname,
 844                                    const GLfloat* params) {
 845   MojoGLES2MakeCurrent(context_);
 846   glTexParameterfv(target, pname, params);
 847 }
 848 void MojoGLES2Impl::TexParameteri(GLenum target, GLenum pname, GLint param) {
 849   MojoGLES2MakeCurrent(context_);
 850   glTexParameteri(target, pname, param);
 851 }
 852 void MojoGLES2Impl::TexParameteriv(GLenum target,
 853                                    GLenum pname,
 854                                    const GLint* params) {
 855   MojoGLES2MakeCurrent(context_);
 856   glTexParameteriv(target, pname, params);
 857 }
 858 void MojoGLES2Impl::TexStorage3D(GLenum target,
 859                                  GLsizei levels,
 860                                  GLenum internalFormat,
 861                                  GLsizei width,
 862                                  GLsizei height,
 863                                  GLsizei depth) {
 864   NOTREACHED() << "Unimplemented TexStorage3D.";
 865 }
 866 void MojoGLES2Impl::TexSubImage2D(GLenum target,
 867                                   GLint level,
 868                                   GLint xoffset,
 869                                   GLint yoffset,
 870                                   GLsizei width,
 871                                   GLsizei height,
 872                                   GLenum format,
 873                                   GLenum type,
 874                                   const void* pixels) {
 875   MojoGLES2MakeCurrent(context_);
 876   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
 877                   pixels);
 878 }
 879 void MojoGLES2Impl::TexSubImage3D(GLenum target,
 880                                   GLint level,
 881                                   GLint xoffset,
 882                                   GLint yoffset,
 883                                   GLint zoffset,
 884                                   GLsizei width,
 885                                   GLsizei height,
 886                                   GLsizei depth,
 887                                   GLenum format,
 888                                   GLenum type,
 889                                   const void* pixels) {
 890   NOTREACHED() << "Unimplemented TexSubImage3D.";
 891 }
 892 void MojoGLES2Impl::TransformFeedbackVaryings(GLuint program,
 893                                               GLsizei count,
 894                                               const char* const* varyings,
 895                                               GLenum buffermode) {
 896   NOTREACHED() << "Unimplemented TransformFeedbackVaryings.";
 897 }
 898 void MojoGLES2Impl::Uniform1f(GLint location, GLfloat x) {
 899   MojoGLES2MakeCurrent(context_);
 900   glUniform1f(location, x);
 901 }
 902 void MojoGLES2Impl::Uniform1fv(GLint location,
 903                                GLsizei count,
 904                                const GLfloat* v) {
 905   MojoGLES2MakeCurrent(context_);
 906   glUniform1fv(location, count, v);
 907 }
 908 void MojoGLES2Impl::Uniform1i(GLint location, GLint x) {
 909   MojoGLES2MakeCurrent(context_);
 910   glUniform1i(location, x);
 911 }
 912 void MojoGLES2Impl::Uniform1iv(GLint location, GLsizei count, const GLint* v) {
 913   MojoGLES2MakeCurrent(context_);
 914   glUniform1iv(location, count, v);
 915 }
 916 void MojoGLES2Impl::Uniform1ui(GLint location, GLuint x) {
 917   NOTREACHED() << "Unimplemented Uniform1ui.";
 918 }
 919 void MojoGLES2Impl::Uniform1uiv(GLint location,
 920                                 GLsizei count,
 921                                 const GLuint* v) {
 922   NOTREACHED() << "Unimplemented Uniform1uiv.";
 923 }
 924 void MojoGLES2Impl::Uniform2f(GLint location, GLfloat x, GLfloat y) {
 925   MojoGLES2MakeCurrent(context_);
 926   glUniform2f(location, x, y);
 927 }
 928 void MojoGLES2Impl::Uniform2fv(GLint location,
 929                                GLsizei count,
 930                                const GLfloat* v) {
 931   MojoGLES2MakeCurrent(context_);
 932   glUniform2fv(location, count, v);
 933 }
 934 void MojoGLES2Impl::Uniform2i(GLint location, GLint x, GLint y) {
 935   MojoGLES2MakeCurrent(context_);
 936   glUniform2i(location, x, y);
 937 }
 938 void MojoGLES2Impl::Uniform2iv(GLint location, GLsizei count, const GLint* v) {
 939   MojoGLES2MakeCurrent(context_);
 940   glUniform2iv(location, count, v);
 941 }
 942 void MojoGLES2Impl::Uniform2ui(GLint location, GLuint x, GLuint y) {
 943   NOTREACHED() << "Unimplemented Uniform2ui.";
 944 }
 945 void MojoGLES2Impl::Uniform2uiv(GLint location,
 946                                 GLsizei count,
 947                                 const GLuint* v) {
 948   NOTREACHED() << "Unimplemented Uniform2uiv.";
 949 }
 950 void MojoGLES2Impl::Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 951   MojoGLES2MakeCurrent(context_);
 952   glUniform3f(location, x, y, z);
 953 }
 954 void MojoGLES2Impl::Uniform3fv(GLint location,
 955                                GLsizei count,
 956                                const GLfloat* v) {
 957   MojoGLES2MakeCurrent(context_);
 958   glUniform3fv(location, count, v);
 959 }
 960 void MojoGLES2Impl::Uniform3i(GLint location, GLint x, GLint y, GLint z) {
 961   MojoGLES2MakeCurrent(context_);
 962   glUniform3i(location, x, y, z);
 963 }
 964 void MojoGLES2Impl::Uniform3iv(GLint location, GLsizei count, const GLint* v) {
 965   MojoGLES2MakeCurrent(context_);
 966   glUniform3iv(location, count, v);
 967 }
 968 void MojoGLES2Impl::Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
 969   NOTREACHED() << "Unimplemented Uniform3ui.";
 970 }
 971 void MojoGLES2Impl::Uniform3uiv(GLint location,
 972                                 GLsizei count,
 973                                 const GLuint* v) {
 974   NOTREACHED() << "Unimplemented Uniform3uiv.";
 975 }
 976 void MojoGLES2Impl::Uniform4f(GLint location,
 977                               GLfloat x,
 978                               GLfloat y,
 979                               GLfloat z,
 980                               GLfloat w) {
 981   MojoGLES2MakeCurrent(context_);
 982   glUniform4f(location, x, y, z, w);
 983 }
 984 void MojoGLES2Impl::Uniform4fv(GLint location,
 985                                GLsizei count,
 986                                const GLfloat* v) {
 987   MojoGLES2MakeCurrent(context_);
 988   glUniform4fv(location, count, v);
 989 }
 990 void MojoGLES2Impl::Uniform4i(GLint location,
 991                               GLint x,
 992                               GLint y,
 993                               GLint z,
 994                               GLint w) {
 995   MojoGLES2MakeCurrent(context_);
 996   glUniform4i(location, x, y, z, w);
 997 }
 998 void MojoGLES2Impl::Uniform4iv(GLint location, GLsizei count, const GLint* v) {
 999   MojoGLES2MakeCurrent(context_);
1000   glUniform4iv(location, count, v);
1001 }
1002 void MojoGLES2Impl::Uniform4ui(GLint location,
1003                                GLuint x,
1004                                GLuint y,
1005                                GLuint z,
1006                                GLuint w) {
1007   NOTREACHED() << "Unimplemented Uniform4ui.";
1008 }
1009 void MojoGLES2Impl::Uniform4uiv(GLint location,
1010                                 GLsizei count,
1011                                 const GLuint* v) {
1012   NOTREACHED() << "Unimplemented Uniform4uiv.";
1013 }
1014 void MojoGLES2Impl::UniformBlockBinding(GLuint program,
1015                                         GLuint index,
1016                                         GLuint binding) {
1017   NOTREACHED() << "Unimplemented UniformBlockBinding.";
1018 }
1019 void MojoGLES2Impl::UniformMatrix2fv(GLint location,
1020                                      GLsizei count,
1021                                      GLboolean transpose,
1022                                      const GLfloat* value) {
1023   MojoGLES2MakeCurrent(context_);
1024   glUniformMatrix2fv(location, count, transpose, value);
1025 }
1026 void MojoGLES2Impl::UniformMatrix2x3fv(GLint location,
1027                                        GLsizei count,
1028                                        GLboolean transpose,
1029                                        const GLfloat* value) {
1030   NOTREACHED() << "Unimplemented UniformMatrix2x3fv.";
1031 }
1032 void MojoGLES2Impl::UniformMatrix2x4fv(GLint location,
1033                                        GLsizei count,
1034                                        GLboolean transpose,
1035                                        const GLfloat* value) {
1036   NOTREACHED() << "Unimplemented UniformMatrix2x4fv.";
1037 }
1038 void MojoGLES2Impl::UniformMatrix3fv(GLint location,
1039                                      GLsizei count,
1040                                      GLboolean transpose,
1041                                      const GLfloat* value) {
1042   MojoGLES2MakeCurrent(context_);
1043   glUniformMatrix3fv(location, count, transpose, value);
1044 }
1045 void MojoGLES2Impl::UniformMatrix3x2fv(GLint location,
1046                                        GLsizei count,
1047                                        GLboolean transpose,
1048                                        const GLfloat* value) {
1049   NOTREACHED() << "Unimplemented UniformMatrix3x2fv.";
1050 }
1051 void MojoGLES2Impl::UniformMatrix3x4fv(GLint location,
1052                                        GLsizei count,
1053                                        GLboolean transpose,
1054                                        const GLfloat* value) {
1055   NOTREACHED() << "Unimplemented UniformMatrix3x4fv.";
1056 }
1057 void MojoGLES2Impl::UniformMatrix4fv(GLint location,
1058                                      GLsizei count,
1059                                      GLboolean transpose,
1060                                      const GLfloat* value) {
1061   MojoGLES2MakeCurrent(context_);
1062   glUniformMatrix4fv(location, count, transpose, value);
1063 }
1064 void MojoGLES2Impl::UniformMatrix4x2fv(GLint location,
1065                                        GLsizei count,
1066                                        GLboolean transpose,
1067                                        const GLfloat* value) {
1068   NOTREACHED() << "Unimplemented UniformMatrix4x2fv.";
1069 }
1070 void MojoGLES2Impl::UniformMatrix4x3fv(GLint location,
1071                                        GLsizei count,
1072                                        GLboolean transpose,
1073                                        const GLfloat* value) {
1074   NOTREACHED() << "Unimplemented UniformMatrix4x3fv.";
1075 }
1076 void MojoGLES2Impl::UseProgram(GLuint program) {
1077   MojoGLES2MakeCurrent(context_);
1078   glUseProgram(program);
1079 }
1080 void MojoGLES2Impl::ValidateProgram(GLuint program) {
1081   MojoGLES2MakeCurrent(context_);
1082   glValidateProgram(program);
1083 }
1084 void MojoGLES2Impl::VertexAttrib1f(GLuint indx, GLfloat x) {
1085   MojoGLES2MakeCurrent(context_);
1086   glVertexAttrib1f(indx, x);
1087 }
1088 void MojoGLES2Impl::VertexAttrib1fv(GLuint indx, const GLfloat* values) {
1089   MojoGLES2MakeCurrent(context_);
1090   glVertexAttrib1fv(indx, values);
1091 }
1092 void MojoGLES2Impl::VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
1093   MojoGLES2MakeCurrent(context_);
1094   glVertexAttrib2f(indx, x, y);
1095 }
1096 void MojoGLES2Impl::VertexAttrib2fv(GLuint indx, const GLfloat* values) {
1097   MojoGLES2MakeCurrent(context_);
1098   glVertexAttrib2fv(indx, values);
1099 }
1100 void MojoGLES2Impl::VertexAttrib3f(GLuint indx,
1101                                    GLfloat x,
1102                                    GLfloat y,
1103                                    GLfloat z) {
1104   MojoGLES2MakeCurrent(context_);
1105   glVertexAttrib3f(indx, x, y, z);
1106 }
1107 void MojoGLES2Impl::VertexAttrib3fv(GLuint indx, const GLfloat* values) {
1108   MojoGLES2MakeCurrent(context_);
1109   glVertexAttrib3fv(indx, values);
1110 }
1111 void MojoGLES2Impl::VertexAttrib4f(GLuint indx,
1112                                    GLfloat x,
1113                                    GLfloat y,
1114                                    GLfloat z,
1115                                    GLfloat w) {
1116   MojoGLES2MakeCurrent(context_);
1117   glVertexAttrib4f(indx, x, y, z, w);
1118 }
1119 void MojoGLES2Impl::VertexAttrib4fv(GLuint indx, const GLfloat* values) {
1120   MojoGLES2MakeCurrent(context_);
1121   glVertexAttrib4fv(indx, values);
1122 }
1123 void MojoGLES2Impl::VertexAttribI4i(GLuint indx,
1124                                     GLint x,
1125                                     GLint y,
1126                                     GLint z,
1127                                     GLint w) {
1128   NOTREACHED() << "Unimplemented VertexAttribI4i.";
1129 }
1130 void MojoGLES2Impl::VertexAttribI4iv(GLuint indx, const GLint* values) {
1131   NOTREACHED() << "Unimplemented VertexAttribI4iv.";
1132 }
1133 void MojoGLES2Impl::VertexAttribI4ui(GLuint indx,
1134                                      GLuint x,
1135                                      GLuint y,
1136                                      GLuint z,
1137                                      GLuint w) {
1138   NOTREACHED() << "Unimplemented VertexAttribI4ui.";
1139 }
1140 void MojoGLES2Impl::VertexAttribI4uiv(GLuint indx, const GLuint* values) {
1141   NOTREACHED() << "Unimplemented VertexAttribI4uiv.";
1142 }
1143 void MojoGLES2Impl::VertexAttribIPointer(GLuint indx,
1144                                          GLint size,
1145                                          GLenum type,
1146                                          GLsizei stride,
1147                                          const void* ptr) {
1148   NOTREACHED() << "Unimplemented VertexAttribIPointer.";
1149 }
1150 void MojoGLES2Impl::VertexAttribPointer(GLuint indx,
1151                                         GLint size,
1152                                         GLenum type,
1153                                         GLboolean normalized,
1154                                         GLsizei stride,
1155                                         const void* ptr) {
1156   MojoGLES2MakeCurrent(context_);
1157   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
1158 }
1159 void MojoGLES2Impl::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1160   MojoGLES2MakeCurrent(context_);
1161   glViewport(x, y, width, height);
1162 }
1163 void MojoGLES2Impl::WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
1164   NOTREACHED() << "Unimplemented WaitSync.";
1165 }
1166 void MojoGLES2Impl::BlitFramebufferCHROMIUM(GLint srcX0,
1167                                             GLint srcY0,
1168                                             GLint srcX1,
1169                                             GLint srcY1,
1170                                             GLint dstX0,
1171                                             GLint dstY0,
1172                                             GLint dstX1,
1173                                             GLint dstY1,
1174                                             GLbitfield mask,
1175                                             GLenum filter) {
1176   NOTREACHED() << "Unimplemented BlitFramebufferCHROMIUM.";
1177 }
1178 void MojoGLES2Impl::RenderbufferStorageMultisampleCHROMIUM(
1179     GLenum target,
1180     GLsizei samples,
1181     GLenum internalformat,
1182     GLsizei width,
1183     GLsizei height) {
1184   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleCHROMIUM.";
1185 }
1186 void MojoGLES2Impl::RenderbufferStorageMultisampleEXT(GLenum target,
1187                                                       GLsizei samples,
1188                                                       GLenum internalformat,
1189                                                       GLsizei width,
1190                                                       GLsizei height) {
1191   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleEXT.";
1192 }
1193 void MojoGLES2Impl::FramebufferTexture2DMultisampleEXT(GLenum target,
1194                                                        GLenum attachment,
1195                                                        GLenum textarget,
1196                                                        GLuint texture,
1197                                                        GLint level,
1198                                                        GLsizei samples) {
1199   NOTREACHED() << "Unimplemented FramebufferTexture2DMultisampleEXT.";
1200 }
1201 void MojoGLES2Impl::TexStorage2DEXT(GLenum target,
1202                                     GLsizei levels,
1203                                     GLenum internalFormat,
1204                                     GLsizei width,
1205                                     GLsizei height) {
1206   NOTREACHED() << "Unimplemented TexStorage2DEXT.";
1207 }
1208 void MojoGLES2Impl::GenQueriesEXT(GLsizei n, GLuint* queries) {
1209   MojoGLES2MakeCurrent(context_);
1210   glGenQueriesEXT(n, queries);
1211 }
1212 void MojoGLES2Impl::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
1213   MojoGLES2MakeCurrent(context_);
1214   glDeleteQueriesEXT(n, queries);
1215 }
1216 GLboolean MojoGLES2Impl::IsQueryEXT(GLuint id) {
1217   MojoGLES2MakeCurrent(context_);
1218   return glIsQueryEXT(id);
1219 }
1220 void MojoGLES2Impl::BeginQueryEXT(GLenum target, GLuint id) {
1221   MojoGLES2MakeCurrent(context_);
1222   glBeginQueryEXT(target, id);
1223 }
1224 void MojoGLES2Impl::BeginTransformFeedback(GLenum primitivemode) {
1225   NOTREACHED() << "Unimplemented BeginTransformFeedback.";
1226 }
1227 void MojoGLES2Impl::EndQueryEXT(GLenum target) {
1228   MojoGLES2MakeCurrent(context_);
1229   glEndQueryEXT(target);
1230 }
1231 void MojoGLES2Impl::EndTransformFeedback() {
1232   NOTREACHED() << "Unimplemented EndTransformFeedback.";
1233 }
1234 void MojoGLES2Impl::GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
1235   MojoGLES2MakeCurrent(context_);
1236   glGetQueryivEXT(target, pname, params);
1237 }
1238 void MojoGLES2Impl::GetQueryObjectuivEXT(GLuint id,
1239                                          GLenum pname,
1240                                          GLuint* params) {
1241   MojoGLES2MakeCurrent(context_);
1242   glGetQueryObjectuivEXT(id, pname, params);
1243 }
1244 void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1245   NOTREACHED() << "Unimplemented InsertEventMarkerEXT.";
1246 }
1247 void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1248   NOTREACHED() << "Unimplemented PushGroupMarkerEXT.";
1249 }
1250 void MojoGLES2Impl::PopGroupMarkerEXT() {
1251   NOTREACHED() << "Unimplemented PopGroupMarkerEXT.";
1252 }
1253 void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1254   NOTREACHED() << "Unimplemented GenVertexArraysOES.";
1255 }
1256 void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1257   NOTREACHED() << "Unimplemented DeleteVertexArraysOES.";
1258 }
1259 GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
1260   NOTREACHED() << "Unimplemented IsVertexArrayOES.";
1261   return 0;
1262 }
1263 void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
1264   NOTREACHED() << "Unimplemented BindVertexArrayOES.";
1265 }
1266 void MojoGLES2Impl::SwapBuffers() {
1267   NOTREACHED() << "Unimplemented SwapBuffers.";
1268 }
1269 GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1270                                                   GLsizei count,
1271                                                   GLenum type,
1272                                                   GLuint offset) {
1273   NOTREACHED() << "Unimplemented GetMaxValueInBufferCHROMIUM.";
1274   return 0;
1275 }
1276 GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
1277   NOTREACHED() << "Unimplemented EnableFeatureCHROMIUM.";
1278   return 0;
1279 }
1280 void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
1281   NOTREACHED() << "Unimplemented MapBufferCHROMIUM.";
1282   return 0;
1283 }
1284 GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
1285   NOTREACHED() << "Unimplemented UnmapBufferCHROMIUM.";
1286   return 0;
1287 }
1288 void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
1289                                               GLintptr offset,
1290                                               GLsizeiptr size,
1291                                               GLenum access) {
1292   NOTREACHED() << "Unimplemented MapBufferSubDataCHROMIUM.";
1293   return 0;
1294 }
1295 void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
1296   NOTREACHED() << "Unimplemented UnmapBufferSubDataCHROMIUM.";
1297 }
1298 void* MojoGLES2Impl::MapBufferRange(GLenum target,
1299                                     GLintptr offset,
1300                                     GLsizeiptr size,
1301                                     GLbitfield access) {
1302   NOTREACHED() << "Unimplemented MapBufferRange.";
1303   return 0;
1304 }
1305 GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
1306   NOTREACHED() << "Unimplemented UnmapBuffer.";
1307   return 0;
1308 }
1309 void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
1310                                               GLint level,
1311                                               GLint xoffset,
1312                                               GLint yoffset,
1313                                               GLsizei width,
1314                                               GLsizei height,
1315                                               GLenum format,
1316                                               GLenum type,
1317                                               GLenum access) {
1318   MojoGLES2MakeCurrent(context_);
1319   return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1320                                     height, format, type, access);
1321 }
1322 void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1323   MojoGLES2MakeCurrent(context_);
1324   glUnmapTexSubImage2DCHROMIUM(mem);
1325 }
1326 void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
1327                                    GLuint height,
1328                                    GLfloat scale_factor) {
1329   NOTREACHED() << "Unimplemented ResizeCHROMIUM.";
1330 }
1331 const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
1332   NOTREACHED() << "Unimplemented GetRequestableExtensionsCHROMIUM.";
1333   return 0;
1334 }
1335 void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
1336   NOTREACHED() << "Unimplemented RequestExtensionCHROMIUM.";
1337 }
1338 void MojoGLES2Impl::RateLimitOffscreenContextCHROMIUM() {
1339   NOTREACHED() << "Unimplemented RateLimitOffscreenContextCHROMIUM.";
1340 }
1341 void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
1342                                            GLsizei bufsize,
1343                                            GLsizei* size,
1344                                            void* info) {
1345   NOTREACHED() << "Unimplemented GetProgramInfoCHROMIUM.";
1346 }
1347 void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
1348                                              GLsizei bufsize,
1349                                              GLsizei* size,
1350                                              void* info) {
1351   NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
1352 }
1353 void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1354                                                          GLsizei bufsize,
1355                                                          GLsizei* size,
1356                                                          void* info) {
1357   NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
1358 }
1359 void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
1360                                            GLsizei bufsize,
1361                                            GLsizei* size,
1362                                            void* info) {
1363   NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
1364 }
1365 GLuint MojoGLES2Impl::CreateStreamTextureCHROMIUM(GLuint texture) {
1366   NOTREACHED() << "Unimplemented CreateStreamTextureCHROMIUM.";
1367   return 0;
1368 }
1369 GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
1370                                           GLsizei width,
1371                                           GLsizei height,
1372                                           GLenum internalformat) {
1373   NOTREACHED() << "Unimplemented CreateImageCHROMIUM.";
1374   return 0;
1375 }
1376 void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
1377   NOTREACHED() << "Unimplemented DestroyImageCHROMIUM.";
1378 }
1379 GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1380                                                          GLsizei height,
1381                                                          GLenum internalformat,
1382                                                          GLenum usage) {
1383   NOTREACHED() << "Unimplemented CreateGpuMemoryBufferImageCHROMIUM.";
1384   return 0;
1385 }
1386 void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
1387                                                    GLsizei bufsize,
1388                                                    GLsizei* length,
1389                                                    char* source) {
1390   NOTREACHED() << "Unimplemented GetTranslatedShaderSourceANGLE.";
1391 }
1392 void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
1393                                           GLint y,
1394                                           GLint width,
1395                                           GLint height) {
1396   NOTREACHED() << "Unimplemented PostSubBufferCHROMIUM.";
1397 }
1398 void MojoGLES2Impl::TexImageIOSurface2DCHROMIUM(GLenum target,
1399                                                 GLsizei width,
1400                                                 GLsizei height,
1401                                                 GLuint ioSurfaceId,
1402                                                 GLuint plane) {
1403   NOTREACHED() << "Unimplemented TexImageIOSurface2DCHROMIUM.";
1404 }
1405 void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum target,
1406                                         GLenum source_id,
1407                                         GLenum dest_id,
1408                                         GLint internalformat,
1409                                         GLenum dest_type) {
1410   NOTREACHED() << "Unimplemented CopyTextureCHROMIUM.";
1411 }
1412 void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum target,
1413                                            GLenum source_id,
1414                                            GLenum dest_id,
1415                                            GLint xoffset,
1416                                            GLint yoffset) {
1417   NOTREACHED() << "Unimplemented CopySubTextureCHROMIUM.";
1418 }
1419 void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
1420                                              GLint first,
1421                                              GLsizei count,
1422                                              GLsizei primcount) {
1423   NOTREACHED() << "Unimplemented DrawArraysInstancedANGLE.";
1424 }
1425 void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
1426                                                GLsizei count,
1427                                                GLenum type,
1428                                                const void* indices,
1429                                                GLsizei primcount) {
1430   NOTREACHED() << "Unimplemented DrawElementsInstancedANGLE.";
1431 }
1432 void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1433   NOTREACHED() << "Unimplemented VertexAttribDivisorANGLE.";
1434 }
1435 void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
1436   MojoGLES2MakeCurrent(context_);
1437   glGenMailboxCHROMIUM(mailbox);
1438 }
1439 void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
1440                                            const GLbyte* mailbox) {
1441   MojoGLES2MakeCurrent(context_);
1442   glProduceTextureCHROMIUM(target, mailbox);
1443 }
1444 void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
1445                                                  GLenum target,
1446                                                  const GLbyte* mailbox) {
1447   MojoGLES2MakeCurrent(context_);
1448   glProduceTextureDirectCHROMIUM(texture, target, mailbox);
1449 }
1450 void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
1451                                            const GLbyte* mailbox) {
1452   MojoGLES2MakeCurrent(context_);
1453   glConsumeTextureCHROMIUM(target, mailbox);
1454 }
1455 GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
1456                                                       const GLbyte* mailbox) {
1457   MojoGLES2MakeCurrent(context_);
1458   return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
1459 }
1460 void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
1461                                                 GLint location,
1462                                                 const char* name) {
1463   NOTREACHED() << "Unimplemented BindUniformLocationCHROMIUM.";
1464 }
1465 void MojoGLES2Impl::GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1466   NOTREACHED() << "Unimplemented GenValuebuffersCHROMIUM.";
1467 }
1468 void MojoGLES2Impl::DeleteValuebuffersCHROMIUM(GLsizei n,
1469                                                const GLuint* valuebuffers) {
1470   NOTREACHED() << "Unimplemented DeleteValuebuffersCHROMIUM.";
1471 }
1472 GLboolean MojoGLES2Impl::IsValuebufferCHROMIUM(GLuint valuebuffer) {
1473   NOTREACHED() << "Unimplemented IsValuebufferCHROMIUM.";
1474   return 0;
1475 }
1476 void MojoGLES2Impl::BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1477   NOTREACHED() << "Unimplemented BindValuebufferCHROMIUM.";
1478 }
1479 void MojoGLES2Impl::SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1480   NOTREACHED() << "Unimplemented SubscribeValueCHROMIUM.";
1481 }
1482 void MojoGLES2Impl::PopulateSubscribedValuesCHROMIUM(GLenum target) {
1483   NOTREACHED() << "Unimplemented PopulateSubscribedValuesCHROMIUM.";
1484 }
1485 void MojoGLES2Impl::UniformValuebufferCHROMIUM(GLint location,
1486                                                GLenum target,
1487                                                GLenum subscription) {
1488   NOTREACHED() << "Unimplemented UniformValuebufferCHROMIUM.";
1489 }
1490 void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1491   NOTREACHED() << "Unimplemented BindTexImage2DCHROMIUM.";
1492 }
1493 void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1494   NOTREACHED() << "Unimplemented ReleaseTexImage2DCHROMIUM.";
1495 }
1496 void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
1497                                        const char* trace_name) {
1498   NOTREACHED() << "Unimplemented TraceBeginCHROMIUM.";
1499 }
1500 void MojoGLES2Impl::TraceEndCHROMIUM() {
1501   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
1502 }
1503 void MojoGLES2Impl::AsyncTexSubImage2DCHROMIUM(GLenum target,
1504                                                GLint level,
1505                                                GLint xoffset,
1506                                                GLint yoffset,
1507                                                GLsizei width,
1508                                                GLsizei height,
1509                                                GLenum format,
1510                                                GLenum type,
1511                                                const void* data) {
1512   NOTREACHED() << "Unimplemented AsyncTexSubImage2DCHROMIUM.";
1513 }
1514 void MojoGLES2Impl::AsyncTexImage2DCHROMIUM(GLenum target,
1515                                             GLint level,
1516                                             GLenum internalformat,
1517                                             GLsizei width,
1518                                             GLsizei height,
1519                                             GLint border,
1520                                             GLenum format,
1521                                             GLenum type,
1522                                             const void* pixels) {
1523   NOTREACHED() << "Unimplemented AsyncTexImage2DCHROMIUM.";
1524 }
1525 void MojoGLES2Impl::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1526   NOTREACHED() << "Unimplemented WaitAsyncTexImage2DCHROMIUM.";
1527 }
1528 void MojoGLES2Impl::WaitAllAsyncTexImage2DCHROMIUM() {
1529   NOTREACHED() << "Unimplemented WaitAllAsyncTexImage2DCHROMIUM.";
1530 }
1531 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
1532                                           GLsizei count,
1533                                           const GLenum* attachments) {
1534   NOTREACHED() << "Unimplemented DiscardFramebufferEXT.";
1535 }
1536 void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
1537   NOTREACHED() << "Unimplemented LoseContextCHROMIUM.";
1538 }
1539 GLuint MojoGLES2Impl::InsertSyncPointCHROMIUM() {
1540   MojoGLES2MakeCurrent(context_);
1541   return glInsertSyncPointCHROMIUM();
1542 }
1543 void MojoGLES2Impl::WaitSyncPointCHROMIUM(GLuint sync_point) {
1544   MojoGLES2MakeCurrent(context_);
1545   glWaitSyncPointCHROMIUM(sync_point);
1546 }
1547 void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1548   NOTREACHED() << "Unimplemented DrawBuffersEXT.";
1549 }
1550 void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
1551   NOTREACHED() << "Unimplemented DiscardBackbufferCHROMIUM.";
1552 }
1553 void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1554                                                  GLenum plane_transform,
1555                                                  GLuint overlay_texture_id,
1556                                                  GLint bounds_x,
1557                                                  GLint bounds_y,
1558                                                  GLint bounds_width,
1559                                                  GLint bounds_height,
1560                                                  GLfloat uv_x,
1561                                                  GLfloat uv_y,
1562                                                  GLfloat uv_width,
1563                                                  GLfloat uv_height) {
1564   NOTREACHED() << "Unimplemented ScheduleOverlayPlaneCHROMIUM.";
1565 }
1566 void MojoGLES2Impl::SwapInterval(GLint interval) {
1567   NOTREACHED() << "Unimplemented SwapInterval.";
1568 }
1569 void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1570   NOTREACHED() << "Unimplemented MatrixLoadfCHROMIUM.";
1571 }
1572 void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1573   NOTREACHED() << "Unimplemented MatrixLoadIdentityCHROMIUM.";
1574 }
1575 void MojoGLES2Impl::BlendBarrierKHR() {
1576   NOTREACHED() << "Unimplemented BlendBarrierKHR.";
1577 }
1578
1579 }  // namespace mojo