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