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