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