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