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::GetIntegerv(GLenum pname, GLint* params) {
 482   MojoGLES2MakeCurrent(context_);
 483   glGetIntegerv(pname, params);
 484 }
 485 void MojoGLES2Impl::GetInternalformativ(GLenum target,
 486                                         GLenum format,
 487                                         GLenum pname,
 488                                         GLsizei bufSize,
 489                                         GLint* params) {
 490   NOTREACHED() << "Unimplemented GetInternalformativ.";
 491 }
 492 void MojoGLES2Impl::GetProgramiv(GLuint program, GLenum pname, GLint* params) {
 493   MojoGLES2MakeCurrent(context_);
 494   glGetProgramiv(program, pname, params);
 495 }
 496 void MojoGLES2Impl::GetProgramInfoLog(GLuint program,
 497                                       GLsizei bufsize,
 498                                       GLsizei* length,
 499                                       char* infolog) {
 500   MojoGLES2MakeCurrent(context_);
 501   glGetProgramInfoLog(program, bufsize, length, infolog);
 502 }
 503 void MojoGLES2Impl::GetRenderbufferParameteriv(GLenum target,
 504                                                GLenum pname,
 505                                                GLint* params) {
 506   MojoGLES2MakeCurrent(context_);
 507   glGetRenderbufferParameteriv(target, pname, params);
 508 }
 509 void MojoGLES2Impl::GetSamplerParameterfv(GLuint sampler,
 510                                           GLenum pname,
 511                                           GLfloat* params) {
 512   NOTREACHED() << "Unimplemented GetSamplerParameterfv.";
 513 }
 514 void MojoGLES2Impl::GetSamplerParameteriv(GLuint sampler,
 515                                           GLenum pname,
 516                                           GLint* params) {
 517   NOTREACHED() << "Unimplemented GetSamplerParameteriv.";
 518 }
 519 void MojoGLES2Impl::GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 520   MojoGLES2MakeCurrent(context_);
 521   glGetShaderiv(shader, pname, params);
 522 }
 523 void MojoGLES2Impl::GetShaderInfoLog(GLuint shader,
 524                                      GLsizei bufsize,
 525                                      GLsizei* length,
 526                                      char* infolog) {
 527   MojoGLES2MakeCurrent(context_);
 528   glGetShaderInfoLog(shader, bufsize, length, infolog);
 529 }
 530 void MojoGLES2Impl::GetShaderPrecisionFormat(GLenum shadertype,
 531                                              GLenum precisiontype,
 532                                              GLint* range,
 533                                              GLint* precision) {
 534   MojoGLES2MakeCurrent(context_);
 535   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 536 }
 537 void MojoGLES2Impl::GetShaderSource(GLuint shader,
 538                                     GLsizei bufsize,
 539                                     GLsizei* length,
 540                                     char* source) {
 541   MojoGLES2MakeCurrent(context_);
 542   glGetShaderSource(shader, bufsize, length, source);
 543 }
 544 const GLubyte* MojoGLES2Impl::GetString(GLenum name) {
 545   MojoGLES2MakeCurrent(context_);
 546   return glGetString(name);
 547 }
 548 void MojoGLES2Impl::GetSynciv(GLsync sync,
 549                               GLenum pname,
 550                               GLsizei bufsize,
 551                               GLsizei* length,
 552                               GLint* values) {
 553   NOTREACHED() << "Unimplemented GetSynciv.";
 554 }
 555 void MojoGLES2Impl::GetTexParameterfv(GLenum target,
 556                                       GLenum pname,
 557                                       GLfloat* params) {
 558   MojoGLES2MakeCurrent(context_);
 559   glGetTexParameterfv(target, pname, params);
 560 }
 561 void MojoGLES2Impl::GetTexParameteriv(GLenum target,
 562                                       GLenum pname,
 563                                       GLint* params) {
 564   MojoGLES2MakeCurrent(context_);
 565   glGetTexParameteriv(target, pname, params);
 566 }
 567 void MojoGLES2Impl::GetTransformFeedbackVarying(GLuint program,
 568                                                 GLuint index,
 569                                                 GLsizei bufsize,
 570                                                 GLsizei* length,
 571                                                 GLsizei* size,
 572                                                 GLenum* type,
 573                                                 char* name) {
 574   NOTREACHED() << "Unimplemented GetTransformFeedbackVarying.";
 575 }
 576 GLuint MojoGLES2Impl::GetUniformBlockIndex(GLuint program, const char* name) {
 577   NOTREACHED() << "Unimplemented GetUniformBlockIndex.";
 578   return 0;
 579 }
 580 void MojoGLES2Impl::GetUniformfv(GLuint program,
 581                                  GLint location,
 582                                  GLfloat* params) {
 583   MojoGLES2MakeCurrent(context_);
 584   glGetUniformfv(program, location, params);
 585 }
 586 void MojoGLES2Impl::GetUniformiv(GLuint program,
 587                                  GLint location,
 588                                  GLint* params) {
 589   MojoGLES2MakeCurrent(context_);
 590   glGetUniformiv(program, location, params);
 591 }
 592 void MojoGLES2Impl::GetUniformIndices(GLuint program,
 593                                       GLsizei count,
 594                                       const char* const* names,
 595                                       GLuint* indices) {
 596   NOTREACHED() << "Unimplemented GetUniformIndices.";
 597 }
 598 GLint MojoGLES2Impl::GetUniformLocation(GLuint program, const char* name) {
 599   MojoGLES2MakeCurrent(context_);
 600   return glGetUniformLocation(program, name);
 601 }
 602 void MojoGLES2Impl::GetVertexAttribfv(GLuint index,
 603                                       GLenum pname,
 604                                       GLfloat* params) {
 605   MojoGLES2MakeCurrent(context_);
 606   glGetVertexAttribfv(index, pname, params);
 607 }
 608 void MojoGLES2Impl::GetVertexAttribiv(GLuint index,
 609                                       GLenum pname,
 610                                       GLint* params) {
 611   MojoGLES2MakeCurrent(context_);
 612   glGetVertexAttribiv(index, pname, params);
 613 }
 614 void MojoGLES2Impl::GetVertexAttribPointerv(GLuint index,
 615                                             GLenum pname,
 616                                             void** pointer) {
 617   MojoGLES2MakeCurrent(context_);
 618   glGetVertexAttribPointerv(index, pname, pointer);
 619 }
 620 void MojoGLES2Impl::Hint(GLenum target, GLenum mode) {
 621   MojoGLES2MakeCurrent(context_);
 622   glHint(target, mode);
 623 }
 624 void MojoGLES2Impl::InvalidateFramebuffer(GLenum target,
 625                                           GLsizei count,
 626                                           const GLenum* attachments) {
 627   NOTREACHED() << "Unimplemented InvalidateFramebuffer.";
 628 }
 629 void MojoGLES2Impl::InvalidateSubFramebuffer(GLenum target,
 630                                              GLsizei count,
 631                                              const GLenum* attachments,
 632                                              GLint x,
 633                                              GLint y,
 634                                              GLsizei width,
 635                                              GLsizei height) {
 636   NOTREACHED() << "Unimplemented InvalidateSubFramebuffer.";
 637 }
 638 GLboolean MojoGLES2Impl::IsBuffer(GLuint buffer) {
 639   MojoGLES2MakeCurrent(context_);
 640   return glIsBuffer(buffer);
 641 }
 642 GLboolean MojoGLES2Impl::IsEnabled(GLenum cap) {
 643   MojoGLES2MakeCurrent(context_);
 644   return glIsEnabled(cap);
 645 }
 646 GLboolean MojoGLES2Impl::IsFramebuffer(GLuint framebuffer) {
 647   MojoGLES2MakeCurrent(context_);
 648   return glIsFramebuffer(framebuffer);
 649 }
 650 GLboolean MojoGLES2Impl::IsProgram(GLuint program) {
 651   MojoGLES2MakeCurrent(context_);
 652   return glIsProgram(program);
 653 }
 654 GLboolean MojoGLES2Impl::IsRenderbuffer(GLuint renderbuffer) {
 655   MojoGLES2MakeCurrent(context_);
 656   return glIsRenderbuffer(renderbuffer);
 657 }
 658 GLboolean MojoGLES2Impl::IsSampler(GLuint sampler) {
 659   NOTREACHED() << "Unimplemented IsSampler.";
 660   return 0;
 661 }
 662 GLboolean MojoGLES2Impl::IsShader(GLuint shader) {
 663   MojoGLES2MakeCurrent(context_);
 664   return glIsShader(shader);
 665 }
 666 GLboolean MojoGLES2Impl::IsSync(GLsync sync) {
 667   NOTREACHED() << "Unimplemented IsSync.";
 668   return 0;
 669 }
 670 GLboolean MojoGLES2Impl::IsTexture(GLuint texture) {
 671   MojoGLES2MakeCurrent(context_);
 672   return glIsTexture(texture);
 673 }
 674 GLboolean MojoGLES2Impl::IsTransformFeedback(GLuint transformfeedback) {
 675   NOTREACHED() << "Unimplemented IsTransformFeedback.";
 676   return 0;
 677 }
 678 void MojoGLES2Impl::LineWidth(GLfloat width) {
 679   MojoGLES2MakeCurrent(context_);
 680   glLineWidth(width);
 681 }
 682 void MojoGLES2Impl::LinkProgram(GLuint program) {
 683   MojoGLES2MakeCurrent(context_);
 684   glLinkProgram(program);
 685 }
 686 void MojoGLES2Impl::PauseTransformFeedback() {
 687   NOTREACHED() << "Unimplemented PauseTransformFeedback.";
 688 }
 689 void MojoGLES2Impl::PixelStorei(GLenum pname, GLint param) {
 690   MojoGLES2MakeCurrent(context_);
 691   glPixelStorei(pname, param);
 692 }
 693 void MojoGLES2Impl::PolygonOffset(GLfloat factor, GLfloat units) {
 694   MojoGLES2MakeCurrent(context_);
 695   glPolygonOffset(factor, units);
 696 }
 697 void MojoGLES2Impl::ReadBuffer(GLenum src) {
 698   NOTREACHED() << "Unimplemented ReadBuffer.";
 699 }
 700 void MojoGLES2Impl::ReadPixels(GLint x,
 701                                GLint y,
 702                                GLsizei width,
 703                                GLsizei height,
 704                                GLenum format,
 705                                GLenum type,
 706                                void* pixels) {
 707   MojoGLES2MakeCurrent(context_);
 708   glReadPixels(x, y, width, height, format, type, pixels);
 709 }
 710 void MojoGLES2Impl::ReleaseShaderCompiler() {
 711   MojoGLES2MakeCurrent(context_);
 712   glReleaseShaderCompiler();
 713 }
 714 void MojoGLES2Impl::RenderbufferStorage(GLenum target,
 715                                         GLenum internalformat,
 716                                         GLsizei width,
 717                                         GLsizei height) {
 718   MojoGLES2MakeCurrent(context_);
 719   glRenderbufferStorage(target, internalformat, width, height);
 720 }
 721 void MojoGLES2Impl::ResumeTransformFeedback() {
 722   NOTREACHED() << "Unimplemented ResumeTransformFeedback.";
 723 }
 724 void MojoGLES2Impl::SampleCoverage(GLclampf value, GLboolean invert) {
 725   MojoGLES2MakeCurrent(context_);
 726   glSampleCoverage(value, invert);
 727 }
 728 void MojoGLES2Impl::SamplerParameterf(GLuint sampler,
 729                                       GLenum pname,
 730                                       GLfloat param) {
 731   NOTREACHED() << "Unimplemented SamplerParameterf.";
 732 }
 733 void MojoGLES2Impl::SamplerParameterfv(GLuint sampler,
 734                                        GLenum pname,
 735                                        const GLfloat* params) {
 736   NOTREACHED() << "Unimplemented SamplerParameterfv.";
 737 }
 738 void MojoGLES2Impl::SamplerParameteri(GLuint sampler,
 739                                       GLenum pname,
 740                                       GLint param) {
 741   NOTREACHED() << "Unimplemented SamplerParameteri.";
 742 }
 743 void MojoGLES2Impl::SamplerParameteriv(GLuint sampler,
 744                                        GLenum pname,
 745                                        const GLint* params) {
 746   NOTREACHED() << "Unimplemented SamplerParameteriv.";
 747 }
 748 void MojoGLES2Impl::Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 749   MojoGLES2MakeCurrent(context_);
 750   glScissor(x, y, width, height);
 751 }
 752 void MojoGLES2Impl::ShaderBinary(GLsizei n,
 753                                  const GLuint* shaders,
 754                                  GLenum binaryformat,
 755                                  const void* binary,
 756                                  GLsizei length) {
 757   MojoGLES2MakeCurrent(context_);
 758   glShaderBinary(n, shaders, binaryformat, binary, length);
 759 }
 760 void MojoGLES2Impl::ShaderSource(GLuint shader,
 761                                  GLsizei count,
 762                                  const GLchar* const* str,
 763                                  const GLint* length) {
 764   MojoGLES2MakeCurrent(context_);
 765   glShaderSource(shader, count, str, length);
 766 }
 767 void MojoGLES2Impl::ShallowFinishCHROMIUM() {
 768   NOTREACHED() << "Unimplemented ShallowFinishCHROMIUM.";
 769 }
 770 void MojoGLES2Impl::ShallowFlushCHROMIUM() {
 771   MojoGLES2MakeCurrent(context_);
 772   glShallowFlushCHROMIUM();
 773 }
 774 void MojoGLES2Impl::OrderingBarrierCHROMIUM() {
 775   NOTREACHED() << "Unimplemented OrderingBarrierCHROMIUM.";
 776 }
 777 void MojoGLES2Impl::StencilFunc(GLenum func, GLint ref, GLuint mask) {
 778   MojoGLES2MakeCurrent(context_);
 779   glStencilFunc(func, ref, mask);
 780 }
 781 void MojoGLES2Impl::StencilFuncSeparate(GLenum face,
 782                                         GLenum func,
 783                                         GLint ref,
 784                                         GLuint mask) {
 785   MojoGLES2MakeCurrent(context_);
 786   glStencilFuncSeparate(face, func, ref, mask);
 787 }
 788 void MojoGLES2Impl::StencilMask(GLuint mask) {
 789   MojoGLES2MakeCurrent(context_);
 790   glStencilMask(mask);
 791 }
 792 void MojoGLES2Impl::StencilMaskSeparate(GLenum face, GLuint mask) {
 793   MojoGLES2MakeCurrent(context_);
 794   glStencilMaskSeparate(face, mask);
 795 }
 796 void MojoGLES2Impl::StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 797   MojoGLES2MakeCurrent(context_);
 798   glStencilOp(fail, zfail, zpass);
 799 }
 800 void MojoGLES2Impl::StencilOpSeparate(GLenum face,
 801                                       GLenum fail,
 802                                       GLenum zfail,
 803                                       GLenum zpass) {
 804   MojoGLES2MakeCurrent(context_);
 805   glStencilOpSeparate(face, fail, zfail, zpass);
 806 }
 807 void MojoGLES2Impl::TexImage2D(GLenum target,
 808                                GLint level,
 809                                GLint internalformat,
 810                                GLsizei width,
 811                                GLsizei height,
 812                                GLint border,
 813                                GLenum format,
 814                                GLenum type,
 815                                const void* pixels) {
 816   MojoGLES2MakeCurrent(context_);
 817   glTexImage2D(target, level, internalformat, width, height, border, format,
 818                type, pixels);
 819 }
 820 void MojoGLES2Impl::TexImage3D(GLenum target,
 821                                GLint level,
 822                                GLint internalformat,
 823                                GLsizei width,
 824                                GLsizei height,
 825                                GLsizei depth,
 826                                GLint border,
 827                                GLenum format,
 828                                GLenum type,
 829                                const void* pixels) {
 830   NOTREACHED() << "Unimplemented TexImage3D.";
 831 }
 832 void MojoGLES2Impl::TexParameterf(GLenum target, GLenum pname, GLfloat param) {
 833   MojoGLES2MakeCurrent(context_);
 834   glTexParameterf(target, pname, param);
 835 }
 836 void MojoGLES2Impl::TexParameterfv(GLenum target,
 837                                    GLenum pname,
 838                                    const GLfloat* params) {
 839   MojoGLES2MakeCurrent(context_);
 840   glTexParameterfv(target, pname, params);
 841 }
 842 void MojoGLES2Impl::TexParameteri(GLenum target, GLenum pname, GLint param) {
 843   MojoGLES2MakeCurrent(context_);
 844   glTexParameteri(target, pname, param);
 845 }
 846 void MojoGLES2Impl::TexParameteriv(GLenum target,
 847                                    GLenum pname,
 848                                    const GLint* params) {
 849   MojoGLES2MakeCurrent(context_);
 850   glTexParameteriv(target, pname, params);
 851 }
 852 void MojoGLES2Impl::TexStorage3D(GLenum target,
 853                                  GLsizei levels,
 854                                  GLenum internalFormat,
 855                                  GLsizei width,
 856                                  GLsizei height,
 857                                  GLsizei depth) {
 858   NOTREACHED() << "Unimplemented TexStorage3D.";
 859 }
 860 void MojoGLES2Impl::TexSubImage2D(GLenum target,
 861                                   GLint level,
 862                                   GLint xoffset,
 863                                   GLint yoffset,
 864                                   GLsizei width,
 865                                   GLsizei height,
 866                                   GLenum format,
 867                                   GLenum type,
 868                                   const void* pixels) {
 869   MojoGLES2MakeCurrent(context_);
 870   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
 871                   pixels);
 872 }
 873 void MojoGLES2Impl::TexSubImage3D(GLenum target,
 874                                   GLint level,
 875                                   GLint xoffset,
 876                                   GLint yoffset,
 877                                   GLint zoffset,
 878                                   GLsizei width,
 879                                   GLsizei height,
 880                                   GLsizei depth,
 881                                   GLenum format,
 882                                   GLenum type,
 883                                   const void* pixels) {
 884   NOTREACHED() << "Unimplemented TexSubImage3D.";
 885 }
 886 void MojoGLES2Impl::TransformFeedbackVaryings(GLuint program,
 887                                               GLsizei count,
 888                                               const char* const* varyings,
 889                                               GLenum buffermode) {
 890   NOTREACHED() << "Unimplemented TransformFeedbackVaryings.";
 891 }
 892 void MojoGLES2Impl::Uniform1f(GLint location, GLfloat x) {
 893   MojoGLES2MakeCurrent(context_);
 894   glUniform1f(location, x);
 895 }
 896 void MojoGLES2Impl::Uniform1fv(GLint location,
 897                                GLsizei count,
 898                                const GLfloat* v) {
 899   MojoGLES2MakeCurrent(context_);
 900   glUniform1fv(location, count, v);
 901 }
 902 void MojoGLES2Impl::Uniform1i(GLint location, GLint x) {
 903   MojoGLES2MakeCurrent(context_);
 904   glUniform1i(location, x);
 905 }
 906 void MojoGLES2Impl::Uniform1iv(GLint location, GLsizei count, const GLint* v) {
 907   MojoGLES2MakeCurrent(context_);
 908   glUniform1iv(location, count, v);
 909 }
 910 void MojoGLES2Impl::Uniform1ui(GLint location, GLuint x) {
 911   NOTREACHED() << "Unimplemented Uniform1ui.";
 912 }
 913 void MojoGLES2Impl::Uniform1uiv(GLint location,
 914                                 GLsizei count,
 915                                 const GLuint* v) {
 916   NOTREACHED() << "Unimplemented Uniform1uiv.";
 917 }
 918 void MojoGLES2Impl::Uniform2f(GLint location, GLfloat x, GLfloat y) {
 919   MojoGLES2MakeCurrent(context_);
 920   glUniform2f(location, x, y);
 921 }
 922 void MojoGLES2Impl::Uniform2fv(GLint location,
 923                                GLsizei count,
 924                                const GLfloat* v) {
 925   MojoGLES2MakeCurrent(context_);
 926   glUniform2fv(location, count, v);
 927 }
 928 void MojoGLES2Impl::Uniform2i(GLint location, GLint x, GLint y) {
 929   MojoGLES2MakeCurrent(context_);
 930   glUniform2i(location, x, y);
 931 }
 932 void MojoGLES2Impl::Uniform2iv(GLint location, GLsizei count, const GLint* v) {
 933   MojoGLES2MakeCurrent(context_);
 934   glUniform2iv(location, count, v);
 935 }
 936 void MojoGLES2Impl::Uniform2ui(GLint location, GLuint x, GLuint y) {
 937   NOTREACHED() << "Unimplemented Uniform2ui.";
 938 }
 939 void MojoGLES2Impl::Uniform2uiv(GLint location,
 940                                 GLsizei count,
 941                                 const GLuint* v) {
 942   NOTREACHED() << "Unimplemented Uniform2uiv.";
 943 }
 944 void MojoGLES2Impl::Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 945   MojoGLES2MakeCurrent(context_);
 946   glUniform3f(location, x, y, z);
 947 }
 948 void MojoGLES2Impl::Uniform3fv(GLint location,
 949                                GLsizei count,
 950                                const GLfloat* v) {
 951   MojoGLES2MakeCurrent(context_);
 952   glUniform3fv(location, count, v);
 953 }
 954 void MojoGLES2Impl::Uniform3i(GLint location, GLint x, GLint y, GLint z) {
 955   MojoGLES2MakeCurrent(context_);
 956   glUniform3i(location, x, y, z);
 957 }
 958 void MojoGLES2Impl::Uniform3iv(GLint location, GLsizei count, const GLint* v) {
 959   MojoGLES2MakeCurrent(context_);
 960   glUniform3iv(location, count, v);
 961 }
 962 void MojoGLES2Impl::Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
 963   NOTREACHED() << "Unimplemented Uniform3ui.";
 964 }
 965 void MojoGLES2Impl::Uniform3uiv(GLint location,
 966                                 GLsizei count,
 967                                 const GLuint* v) {
 968   NOTREACHED() << "Unimplemented Uniform3uiv.";
 969 }
 970 void MojoGLES2Impl::Uniform4f(GLint location,
 971                               GLfloat x,
 972                               GLfloat y,
 973                               GLfloat z,
 974                               GLfloat w) {
 975   MojoGLES2MakeCurrent(context_);
 976   glUniform4f(location, x, y, z, w);
 977 }
 978 void MojoGLES2Impl::Uniform4fv(GLint location,
 979                                GLsizei count,
 980                                const GLfloat* v) {
 981   MojoGLES2MakeCurrent(context_);
 982   glUniform4fv(location, count, v);
 983 }
 984 void MojoGLES2Impl::Uniform4i(GLint location,
 985                               GLint x,
 986                               GLint y,
 987                               GLint z,
 988                               GLint w) {
 989   MojoGLES2MakeCurrent(context_);
 990   glUniform4i(location, x, y, z, w);
 991 }
 992 void MojoGLES2Impl::Uniform4iv(GLint location, GLsizei count, const GLint* v) {
 993   MojoGLES2MakeCurrent(context_);
 994   glUniform4iv(location, count, v);
 995 }
 996 void MojoGLES2Impl::Uniform4ui(GLint location,
 997                                GLuint x,
 998                                GLuint y,
 999                                GLuint z,
1000                                GLuint w) {
1001   NOTREACHED() << "Unimplemented Uniform4ui.";
1002 }
1003 void MojoGLES2Impl::Uniform4uiv(GLint location,
1004                                 GLsizei count,
1005                                 const GLuint* v) {
1006   NOTREACHED() << "Unimplemented Uniform4uiv.";
1007 }
1008 void MojoGLES2Impl::UniformBlockBinding(GLuint program,
1009                                         GLuint index,
1010                                         GLuint binding) {
1011   NOTREACHED() << "Unimplemented UniformBlockBinding.";
1012 }
1013 void MojoGLES2Impl::UniformMatrix2fv(GLint location,
1014                                      GLsizei count,
1015                                      GLboolean transpose,
1016                                      const GLfloat* value) {
1017   MojoGLES2MakeCurrent(context_);
1018   glUniformMatrix2fv(location, count, transpose, value);
1019 }
1020 void MojoGLES2Impl::UniformMatrix2x3fv(GLint location,
1021                                        GLsizei count,
1022                                        GLboolean transpose,
1023                                        const GLfloat* value) {
1024   NOTREACHED() << "Unimplemented UniformMatrix2x3fv.";
1025 }
1026 void MojoGLES2Impl::UniformMatrix2x4fv(GLint location,
1027                                        GLsizei count,
1028                                        GLboolean transpose,
1029                                        const GLfloat* value) {
1030   NOTREACHED() << "Unimplemented UniformMatrix2x4fv.";
1031 }
1032 void MojoGLES2Impl::UniformMatrix3fv(GLint location,
1033                                      GLsizei count,
1034                                      GLboolean transpose,
1035                                      const GLfloat* value) {
1036   MojoGLES2MakeCurrent(context_);
1037   glUniformMatrix3fv(location, count, transpose, value);
1038 }
1039 void MojoGLES2Impl::UniformMatrix3x2fv(GLint location,
1040                                        GLsizei count,
1041                                        GLboolean transpose,
1042                                        const GLfloat* value) {
1043   NOTREACHED() << "Unimplemented UniformMatrix3x2fv.";
1044 }
1045 void MojoGLES2Impl::UniformMatrix3x4fv(GLint location,
1046                                        GLsizei count,
1047                                        GLboolean transpose,
1048                                        const GLfloat* value) {
1049   NOTREACHED() << "Unimplemented UniformMatrix3x4fv.";
1050 }
1051 void MojoGLES2Impl::UniformMatrix4fv(GLint location,
1052                                      GLsizei count,
1053                                      GLboolean transpose,
1054                                      const GLfloat* value) {
1055   MojoGLES2MakeCurrent(context_);
1056   glUniformMatrix4fv(location, count, transpose, value);
1057 }
1058 void MojoGLES2Impl::UniformMatrix4x2fv(GLint location,
1059                                        GLsizei count,
1060                                        GLboolean transpose,
1061                                        const GLfloat* value) {
1062   NOTREACHED() << "Unimplemented UniformMatrix4x2fv.";
1063 }
1064 void MojoGLES2Impl::UniformMatrix4x3fv(GLint location,
1065                                        GLsizei count,
1066                                        GLboolean transpose,
1067                                        const GLfloat* value) {
1068   NOTREACHED() << "Unimplemented UniformMatrix4x3fv.";
1069 }
1070 void MojoGLES2Impl::UseProgram(GLuint program) {
1071   MojoGLES2MakeCurrent(context_);
1072   glUseProgram(program);
1073 }
1074 void MojoGLES2Impl::ValidateProgram(GLuint program) {
1075   MojoGLES2MakeCurrent(context_);
1076   glValidateProgram(program);
1077 }
1078 void MojoGLES2Impl::VertexAttrib1f(GLuint indx, GLfloat x) {
1079   MojoGLES2MakeCurrent(context_);
1080   glVertexAttrib1f(indx, x);
1081 }
1082 void MojoGLES2Impl::VertexAttrib1fv(GLuint indx, const GLfloat* values) {
1083   MojoGLES2MakeCurrent(context_);
1084   glVertexAttrib1fv(indx, values);
1085 }
1086 void MojoGLES2Impl::VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
1087   MojoGLES2MakeCurrent(context_);
1088   glVertexAttrib2f(indx, x, y);
1089 }
1090 void MojoGLES2Impl::VertexAttrib2fv(GLuint indx, const GLfloat* values) {
1091   MojoGLES2MakeCurrent(context_);
1092   glVertexAttrib2fv(indx, values);
1093 }
1094 void MojoGLES2Impl::VertexAttrib3f(GLuint indx,
1095                                    GLfloat x,
1096                                    GLfloat y,
1097                                    GLfloat z) {
1098   MojoGLES2MakeCurrent(context_);
1099   glVertexAttrib3f(indx, x, y, z);
1100 }
1101 void MojoGLES2Impl::VertexAttrib3fv(GLuint indx, const GLfloat* values) {
1102   MojoGLES2MakeCurrent(context_);
1103   glVertexAttrib3fv(indx, values);
1104 }
1105 void MojoGLES2Impl::VertexAttrib4f(GLuint indx,
1106                                    GLfloat x,
1107                                    GLfloat y,
1108                                    GLfloat z,
1109                                    GLfloat w) {
1110   MojoGLES2MakeCurrent(context_);
1111   glVertexAttrib4f(indx, x, y, z, w);
1112 }
1113 void MojoGLES2Impl::VertexAttrib4fv(GLuint indx, const GLfloat* values) {
1114   MojoGLES2MakeCurrent(context_);
1115   glVertexAttrib4fv(indx, values);
1116 }
1117 void MojoGLES2Impl::VertexAttribI4i(GLuint indx,
1118                                     GLint x,
1119                                     GLint y,
1120                                     GLint z,
1121                                     GLint w) {
1122   NOTREACHED() << "Unimplemented VertexAttribI4i.";
1123 }
1124 void MojoGLES2Impl::VertexAttribI4iv(GLuint indx, const GLint* values) {
1125   NOTREACHED() << "Unimplemented VertexAttribI4iv.";
1126 }
1127 void MojoGLES2Impl::VertexAttribI4ui(GLuint indx,
1128                                      GLuint x,
1129                                      GLuint y,
1130                                      GLuint z,
1131                                      GLuint w) {
1132   NOTREACHED() << "Unimplemented VertexAttribI4ui.";
1133 }
1134 void MojoGLES2Impl::VertexAttribI4uiv(GLuint indx, const GLuint* values) {
1135   NOTREACHED() << "Unimplemented VertexAttribI4uiv.";
1136 }
1137 void MojoGLES2Impl::VertexAttribIPointer(GLuint indx,
1138                                          GLint size,
1139                                          GLenum type,
1140                                          GLsizei stride,
1141                                          const void* ptr) {
1142   NOTREACHED() << "Unimplemented VertexAttribIPointer.";
1143 }
1144 void MojoGLES2Impl::VertexAttribPointer(GLuint indx,
1145                                         GLint size,
1146                                         GLenum type,
1147                                         GLboolean normalized,
1148                                         GLsizei stride,
1149                                         const void* ptr) {
1150   MojoGLES2MakeCurrent(context_);
1151   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
1152 }
1153 void MojoGLES2Impl::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1154   MojoGLES2MakeCurrent(context_);
1155   glViewport(x, y, width, height);
1156 }
1157 void MojoGLES2Impl::WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
1158   NOTREACHED() << "Unimplemented WaitSync.";
1159 }
1160 void MojoGLES2Impl::BlitFramebufferCHROMIUM(GLint srcX0,
1161                                             GLint srcY0,
1162                                             GLint srcX1,
1163                                             GLint srcY1,
1164                                             GLint dstX0,
1165                                             GLint dstY0,
1166                                             GLint dstX1,
1167                                             GLint dstY1,
1168                                             GLbitfield mask,
1169                                             GLenum filter) {
1170   NOTREACHED() << "Unimplemented BlitFramebufferCHROMIUM.";
1171 }
1172 void MojoGLES2Impl::RenderbufferStorageMultisampleCHROMIUM(
1173     GLenum target,
1174     GLsizei samples,
1175     GLenum internalformat,
1176     GLsizei width,
1177     GLsizei height) {
1178   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleCHROMIUM.";
1179 }
1180 void MojoGLES2Impl::RenderbufferStorageMultisampleEXT(GLenum target,
1181                                                       GLsizei samples,
1182                                                       GLenum internalformat,
1183                                                       GLsizei width,
1184                                                       GLsizei height) {
1185   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleEXT.";
1186 }
1187 void MojoGLES2Impl::FramebufferTexture2DMultisampleEXT(GLenum target,
1188                                                        GLenum attachment,
1189                                                        GLenum textarget,
1190                                                        GLuint texture,
1191                                                        GLint level,
1192                                                        GLsizei samples) {
1193   NOTREACHED() << "Unimplemented FramebufferTexture2DMultisampleEXT.";
1194 }
1195 void MojoGLES2Impl::TexStorage2DEXT(GLenum target,
1196                                     GLsizei levels,
1197                                     GLenum internalFormat,
1198                                     GLsizei width,
1199                                     GLsizei height) {
1200   NOTREACHED() << "Unimplemented TexStorage2DEXT.";
1201 }
1202 void MojoGLES2Impl::GenQueriesEXT(GLsizei n, GLuint* queries) {
1203   MojoGLES2MakeCurrent(context_);
1204   glGenQueriesEXT(n, queries);
1205 }
1206 void MojoGLES2Impl::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
1207   MojoGLES2MakeCurrent(context_);
1208   glDeleteQueriesEXT(n, queries);
1209 }
1210 GLboolean MojoGLES2Impl::IsQueryEXT(GLuint id) {
1211   MojoGLES2MakeCurrent(context_);
1212   return glIsQueryEXT(id);
1213 }
1214 void MojoGLES2Impl::BeginQueryEXT(GLenum target, GLuint id) {
1215   MojoGLES2MakeCurrent(context_);
1216   glBeginQueryEXT(target, id);
1217 }
1218 void MojoGLES2Impl::BeginTransformFeedback(GLenum primitivemode) {
1219   NOTREACHED() << "Unimplemented BeginTransformFeedback.";
1220 }
1221 void MojoGLES2Impl::EndQueryEXT(GLenum target) {
1222   MojoGLES2MakeCurrent(context_);
1223   glEndQueryEXT(target);
1224 }
1225 void MojoGLES2Impl::EndTransformFeedback() {
1226   NOTREACHED() << "Unimplemented EndTransformFeedback.";
1227 }
1228 void MojoGLES2Impl::GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
1229   MojoGLES2MakeCurrent(context_);
1230   glGetQueryivEXT(target, pname, params);
1231 }
1232 void MojoGLES2Impl::GetQueryObjectuivEXT(GLuint id,
1233                                          GLenum pname,
1234                                          GLuint* params) {
1235   MojoGLES2MakeCurrent(context_);
1236   glGetQueryObjectuivEXT(id, pname, params);
1237 }
1238 void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1239   NOTREACHED() << "Unimplemented InsertEventMarkerEXT.";
1240 }
1241 void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1242   NOTREACHED() << "Unimplemented PushGroupMarkerEXT.";
1243 }
1244 void MojoGLES2Impl::PopGroupMarkerEXT() {
1245   NOTREACHED() << "Unimplemented PopGroupMarkerEXT.";
1246 }
1247 void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1248   NOTREACHED() << "Unimplemented GenVertexArraysOES.";
1249 }
1250 void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1251   NOTREACHED() << "Unimplemented DeleteVertexArraysOES.";
1252 }
1253 GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
1254   NOTREACHED() << "Unimplemented IsVertexArrayOES.";
1255   return 0;
1256 }
1257 void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
1258   NOTREACHED() << "Unimplemented BindVertexArrayOES.";
1259 }
1260 void MojoGLES2Impl::SwapBuffers() {
1261   NOTREACHED() << "Unimplemented SwapBuffers.";
1262 }
1263 GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1264                                                   GLsizei count,
1265                                                   GLenum type,
1266                                                   GLuint offset) {
1267   NOTREACHED() << "Unimplemented GetMaxValueInBufferCHROMIUM.";
1268   return 0;
1269 }
1270 GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
1271   NOTREACHED() << "Unimplemented EnableFeatureCHROMIUM.";
1272   return 0;
1273 }
1274 void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
1275   NOTREACHED() << "Unimplemented MapBufferCHROMIUM.";
1276   return 0;
1277 }
1278 GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
1279   NOTREACHED() << "Unimplemented UnmapBufferCHROMIUM.";
1280   return 0;
1281 }
1282 void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
1283                                               GLintptr offset,
1284                                               GLsizeiptr size,
1285                                               GLenum access) {
1286   NOTREACHED() << "Unimplemented MapBufferSubDataCHROMIUM.";
1287   return 0;
1288 }
1289 void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
1290   NOTREACHED() << "Unimplemented UnmapBufferSubDataCHROMIUM.";
1291 }
1292 void* MojoGLES2Impl::MapBufferRange(GLenum target,
1293                                     GLintptr offset,
1294                                     GLsizeiptr size,
1295                                     GLbitfield access) {
1296   NOTREACHED() << "Unimplemented MapBufferRange.";
1297   return 0;
1298 }
1299 GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
1300   NOTREACHED() << "Unimplemented UnmapBuffer.";
1301   return 0;
1302 }
1303 void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
1304                                               GLint level,
1305                                               GLint xoffset,
1306                                               GLint yoffset,
1307                                               GLsizei width,
1308                                               GLsizei height,
1309                                               GLenum format,
1310                                               GLenum type,
1311                                               GLenum access) {
1312   MojoGLES2MakeCurrent(context_);
1313   return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1314                                     height, format, type, access);
1315 }
1316 void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1317   MojoGLES2MakeCurrent(context_);
1318   glUnmapTexSubImage2DCHROMIUM(mem);
1319 }
1320 void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
1321                                    GLuint height,
1322                                    GLfloat scale_factor) {
1323   NOTREACHED() << "Unimplemented ResizeCHROMIUM.";
1324 }
1325 const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
1326   NOTREACHED() << "Unimplemented GetRequestableExtensionsCHROMIUM.";
1327   return 0;
1328 }
1329 void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
1330   NOTREACHED() << "Unimplemented RequestExtensionCHROMIUM.";
1331 }
1332 void MojoGLES2Impl::RateLimitOffscreenContextCHROMIUM() {
1333   NOTREACHED() << "Unimplemented RateLimitOffscreenContextCHROMIUM.";
1334 }
1335 void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
1336                                            GLsizei bufsize,
1337                                            GLsizei* size,
1338                                            void* info) {
1339   NOTREACHED() << "Unimplemented GetProgramInfoCHROMIUM.";
1340 }
1341 void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
1342                                              GLsizei bufsize,
1343                                              GLsizei* size,
1344                                              void* info) {
1345   NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
1346 }
1347 void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1348                                                          GLsizei bufsize,
1349                                                          GLsizei* size,
1350                                                          void* info) {
1351   NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
1352 }
1353 void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
1354                                            GLsizei bufsize,
1355                                            GLsizei* size,
1356                                            void* info) {
1357   NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
1358 }
1359 GLuint MojoGLES2Impl::CreateStreamTextureCHROMIUM(GLuint texture) {
1360   NOTREACHED() << "Unimplemented CreateStreamTextureCHROMIUM.";
1361   return 0;
1362 }
1363 GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
1364                                           GLsizei width,
1365                                           GLsizei height,
1366                                           GLenum internalformat) {
1367   NOTREACHED() << "Unimplemented CreateImageCHROMIUM.";
1368   return 0;
1369 }
1370 void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
1371   NOTREACHED() << "Unimplemented DestroyImageCHROMIUM.";
1372 }
1373 GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1374                                                          GLsizei height,
1375                                                          GLenum internalformat,
1376                                                          GLenum usage) {
1377   NOTREACHED() << "Unimplemented CreateGpuMemoryBufferImageCHROMIUM.";
1378   return 0;
1379 }
1380 void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
1381                                                    GLsizei bufsize,
1382                                                    GLsizei* length,
1383                                                    char* source) {
1384   NOTREACHED() << "Unimplemented GetTranslatedShaderSourceANGLE.";
1385 }
1386 void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
1387                                           GLint y,
1388                                           GLint width,
1389                                           GLint height) {
1390   NOTREACHED() << "Unimplemented PostSubBufferCHROMIUM.";
1391 }
1392 void MojoGLES2Impl::TexImageIOSurface2DCHROMIUM(GLenum target,
1393                                                 GLsizei width,
1394                                                 GLsizei height,
1395                                                 GLuint ioSurfaceId,
1396                                                 GLuint plane) {
1397   NOTREACHED() << "Unimplemented TexImageIOSurface2DCHROMIUM.";
1398 }
1399 void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum target,
1400                                         GLenum source_id,
1401                                         GLenum dest_id,
1402                                         GLint internalformat,
1403                                         GLenum dest_type) {
1404   NOTREACHED() << "Unimplemented CopyTextureCHROMIUM.";
1405 }
1406 void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum target,
1407                                            GLenum source_id,
1408                                            GLenum dest_id,
1409                                            GLint xoffset,
1410                                            GLint yoffset) {
1411   NOTREACHED() << "Unimplemented CopySubTextureCHROMIUM.";
1412 }
1413 void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
1414                                              GLint first,
1415                                              GLsizei count,
1416                                              GLsizei primcount) {
1417   NOTREACHED() << "Unimplemented DrawArraysInstancedANGLE.";
1418 }
1419 void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
1420                                                GLsizei count,
1421                                                GLenum type,
1422                                                const void* indices,
1423                                                GLsizei primcount) {
1424   NOTREACHED() << "Unimplemented DrawElementsInstancedANGLE.";
1425 }
1426 void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1427   NOTREACHED() << "Unimplemented VertexAttribDivisorANGLE.";
1428 }
1429 void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
1430   MojoGLES2MakeCurrent(context_);
1431   glGenMailboxCHROMIUM(mailbox);
1432 }
1433 void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
1434                                            const GLbyte* mailbox) {
1435   MojoGLES2MakeCurrent(context_);
1436   glProduceTextureCHROMIUM(target, mailbox);
1437 }
1438 void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
1439                                                  GLenum target,
1440                                                  const GLbyte* mailbox) {
1441   MojoGLES2MakeCurrent(context_);
1442   glProduceTextureDirectCHROMIUM(texture, target, mailbox);
1443 }
1444 void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
1445                                            const GLbyte* mailbox) {
1446   MojoGLES2MakeCurrent(context_);
1447   glConsumeTextureCHROMIUM(target, mailbox);
1448 }
1449 GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
1450                                                       const GLbyte* mailbox) {
1451   MojoGLES2MakeCurrent(context_);
1452   return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
1453 }
1454 void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
1455                                                 GLint location,
1456                                                 const char* name) {
1457   NOTREACHED() << "Unimplemented BindUniformLocationCHROMIUM.";
1458 }
1459 void MojoGLES2Impl::GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1460   NOTREACHED() << "Unimplemented GenValuebuffersCHROMIUM.";
1461 }
1462 void MojoGLES2Impl::DeleteValuebuffersCHROMIUM(GLsizei n,
1463                                                const GLuint* valuebuffers) {
1464   NOTREACHED() << "Unimplemented DeleteValuebuffersCHROMIUM.";
1465 }
1466 GLboolean MojoGLES2Impl::IsValuebufferCHROMIUM(GLuint valuebuffer) {
1467   NOTREACHED() << "Unimplemented IsValuebufferCHROMIUM.";
1468   return 0;
1469 }
1470 void MojoGLES2Impl::BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1471   NOTREACHED() << "Unimplemented BindValuebufferCHROMIUM.";
1472 }
1473 void MojoGLES2Impl::SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1474   NOTREACHED() << "Unimplemented SubscribeValueCHROMIUM.";
1475 }
1476 void MojoGLES2Impl::PopulateSubscribedValuesCHROMIUM(GLenum target) {
1477   NOTREACHED() << "Unimplemented PopulateSubscribedValuesCHROMIUM.";
1478 }
1479 void MojoGLES2Impl::UniformValuebufferCHROMIUM(GLint location,
1480                                                GLenum target,
1481                                                GLenum subscription) {
1482   NOTREACHED() << "Unimplemented UniformValuebufferCHROMIUM.";
1483 }
1484 void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1485   NOTREACHED() << "Unimplemented BindTexImage2DCHROMIUM.";
1486 }
1487 void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1488   NOTREACHED() << "Unimplemented ReleaseTexImage2DCHROMIUM.";
1489 }
1490 void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
1491                                        const char* trace_name) {
1492   NOTREACHED() << "Unimplemented TraceBeginCHROMIUM.";
1493 }
1494 void MojoGLES2Impl::TraceEndCHROMIUM() {
1495   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
1496 }
1497 void MojoGLES2Impl::AsyncTexSubImage2DCHROMIUM(GLenum target,
1498                                                GLint level,
1499                                                GLint xoffset,
1500                                                GLint yoffset,
1501                                                GLsizei width,
1502                                                GLsizei height,
1503                                                GLenum format,
1504                                                GLenum type,
1505                                                const void* data) {
1506   NOTREACHED() << "Unimplemented AsyncTexSubImage2DCHROMIUM.";
1507 }
1508 void MojoGLES2Impl::AsyncTexImage2DCHROMIUM(GLenum target,
1509                                             GLint level,
1510                                             GLenum internalformat,
1511                                             GLsizei width,
1512                                             GLsizei height,
1513                                             GLint border,
1514                                             GLenum format,
1515                                             GLenum type,
1516                                             const void* pixels) {
1517   NOTREACHED() << "Unimplemented AsyncTexImage2DCHROMIUM.";
1518 }
1519 void MojoGLES2Impl::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1520   NOTREACHED() << "Unimplemented WaitAsyncTexImage2DCHROMIUM.";
1521 }
1522 void MojoGLES2Impl::WaitAllAsyncTexImage2DCHROMIUM() {
1523   NOTREACHED() << "Unimplemented WaitAllAsyncTexImage2DCHROMIUM.";
1524 }
1525 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
1526                                           GLsizei count,
1527                                           const GLenum* attachments) {
1528   NOTREACHED() << "Unimplemented DiscardFramebufferEXT.";
1529 }
1530 void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
1531   NOTREACHED() << "Unimplemented LoseContextCHROMIUM.";
1532 }
1533 GLuint MojoGLES2Impl::InsertSyncPointCHROMIUM() {
1534   MojoGLES2MakeCurrent(context_);
1535   return glInsertSyncPointCHROMIUM();
1536 }
1537 void MojoGLES2Impl::WaitSyncPointCHROMIUM(GLuint sync_point) {
1538   MojoGLES2MakeCurrent(context_);
1539   glWaitSyncPointCHROMIUM(sync_point);
1540 }
1541 void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1542   NOTREACHED() << "Unimplemented DrawBuffersEXT.";
1543 }
1544 void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
1545   NOTREACHED() << "Unimplemented DiscardBackbufferCHROMIUM.";
1546 }
1547 void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1548                                                  GLenum plane_transform,
1549                                                  GLuint overlay_texture_id,
1550                                                  GLint bounds_x,
1551                                                  GLint bounds_y,
1552                                                  GLint bounds_width,
1553                                                  GLint bounds_height,
1554                                                  GLfloat uv_x,
1555                                                  GLfloat uv_y,
1556                                                  GLfloat uv_width,
1557                                                  GLfloat uv_height) {
1558   NOTREACHED() << "Unimplemented ScheduleOverlayPlaneCHROMIUM.";
1559 }
1560 void MojoGLES2Impl::SwapInterval(GLint interval) {
1561   NOTREACHED() << "Unimplemented SwapInterval.";
1562 }
1563 void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1564   NOTREACHED() << "Unimplemented MatrixLoadfCHROMIUM.";
1565 }
1566 void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1567   NOTREACHED() << "Unimplemented MatrixLoadIdentityCHROMIUM.";
1568 }
1569 void MojoGLES2Impl::BlendBarrierKHR() {
1570   NOTREACHED() << "Unimplemented BlendBarrierKHR.";
1571 }
1572
1573 }  // namespace mojo