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   MojoGLES2MakeCurrent(context_);
 829   glOrderingBarrierCHROMIUM();
 830 }
 831 void MojoGLES2Impl::StencilFunc(GLenum func, GLint ref, GLuint mask) {
 832   MojoGLES2MakeCurrent(context_);
 833   glStencilFunc(func, ref, mask);
 834 }
 835 void MojoGLES2Impl::StencilFuncSeparate(GLenum face,
 836                                         GLenum func,
 837                                         GLint ref,
 838                                         GLuint mask) {
 839   MojoGLES2MakeCurrent(context_);
 840   glStencilFuncSeparate(face, func, ref, mask);
 841 }
 842 void MojoGLES2Impl::StencilMask(GLuint mask) {
 843   MojoGLES2MakeCurrent(context_);
 844   glStencilMask(mask);
 845 }
 846 void MojoGLES2Impl::StencilMaskSeparate(GLenum face, GLuint mask) {
 847   MojoGLES2MakeCurrent(context_);
 848   glStencilMaskSeparate(face, mask);
 849 }
 850 void MojoGLES2Impl::StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 851   MojoGLES2MakeCurrent(context_);
 852   glStencilOp(fail, zfail, zpass);
 853 }
 854 void MojoGLES2Impl::StencilOpSeparate(GLenum face,
 855                                       GLenum fail,
 856                                       GLenum zfail,
 857                                       GLenum zpass) {
 858   MojoGLES2MakeCurrent(context_);
 859   glStencilOpSeparate(face, fail, zfail, zpass);
 860 }
 861 void MojoGLES2Impl::TexImage2D(GLenum target,
 862                                GLint level,
 863                                GLint internalformat,
 864                                GLsizei width,
 865                                GLsizei height,
 866                                GLint border,
 867                                GLenum format,
 868                                GLenum type,
 869                                const void* pixels) {
 870   MojoGLES2MakeCurrent(context_);
 871   glTexImage2D(target, level, internalformat, width, height, border, format,
 872                type, pixels);
 873 }
 874 void MojoGLES2Impl::TexImage3D(GLenum target,
 875                                GLint level,
 876                                GLint internalformat,
 877                                GLsizei width,
 878                                GLsizei height,
 879                                GLsizei depth,
 880                                GLint border,
 881                                GLenum format,
 882                                GLenum type,
 883                                const void* pixels) {
 884   NOTREACHED() << "Unimplemented TexImage3D.";
 885 }
 886 void MojoGLES2Impl::TexParameterf(GLenum target, GLenum pname, GLfloat param) {
 887   MojoGLES2MakeCurrent(context_);
 888   glTexParameterf(target, pname, param);
 889 }
 890 void MojoGLES2Impl::TexParameterfv(GLenum target,
 891                                    GLenum pname,
 892                                    const GLfloat* params) {
 893   MojoGLES2MakeCurrent(context_);
 894   glTexParameterfv(target, pname, params);
 895 }
 896 void MojoGLES2Impl::TexParameteri(GLenum target, GLenum pname, GLint param) {
 897   MojoGLES2MakeCurrent(context_);
 898   glTexParameteri(target, pname, param);
 899 }
 900 void MojoGLES2Impl::TexParameteriv(GLenum target,
 901                                    GLenum pname,
 902                                    const GLint* params) {
 903   MojoGLES2MakeCurrent(context_);
 904   glTexParameteriv(target, pname, params);
 905 }
 906 void MojoGLES2Impl::TexStorage3D(GLenum target,
 907                                  GLsizei levels,
 908                                  GLenum internalFormat,
 909                                  GLsizei width,
 910                                  GLsizei height,
 911                                  GLsizei depth) {
 912   NOTREACHED() << "Unimplemented TexStorage3D.";
 913 }
 914 void MojoGLES2Impl::TexSubImage2D(GLenum target,
 915                                   GLint level,
 916                                   GLint xoffset,
 917                                   GLint yoffset,
 918                                   GLsizei width,
 919                                   GLsizei height,
 920                                   GLenum format,
 921                                   GLenum type,
 922                                   const void* pixels) {
 923   MojoGLES2MakeCurrent(context_);
 924   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
 925                   pixels);
 926 }
 927 void MojoGLES2Impl::TexSubImage3D(GLenum target,
 928                                   GLint level,
 929                                   GLint xoffset,
 930                                   GLint yoffset,
 931                                   GLint zoffset,
 932                                   GLsizei width,
 933                                   GLsizei height,
 934                                   GLsizei depth,
 935                                   GLenum format,
 936                                   GLenum type,
 937                                   const void* pixels) {
 938   NOTREACHED() << "Unimplemented TexSubImage3D.";
 939 }
 940 void MojoGLES2Impl::TransformFeedbackVaryings(GLuint program,
 941                                               GLsizei count,
 942                                               const char* const* varyings,
 943                                               GLenum buffermode) {
 944   NOTREACHED() << "Unimplemented TransformFeedbackVaryings.";
 945 }
 946 void MojoGLES2Impl::Uniform1f(GLint location, GLfloat x) {
 947   MojoGLES2MakeCurrent(context_);
 948   glUniform1f(location, x);
 949 }
 950 void MojoGLES2Impl::Uniform1fv(GLint location,
 951                                GLsizei count,
 952                                const GLfloat* v) {
 953   MojoGLES2MakeCurrent(context_);
 954   glUniform1fv(location, count, v);
 955 }
 956 void MojoGLES2Impl::Uniform1i(GLint location, GLint x) {
 957   MojoGLES2MakeCurrent(context_);
 958   glUniform1i(location, x);
 959 }
 960 void MojoGLES2Impl::Uniform1iv(GLint location, GLsizei count, const GLint* v) {
 961   MojoGLES2MakeCurrent(context_);
 962   glUniform1iv(location, count, v);
 963 }
 964 void MojoGLES2Impl::Uniform1ui(GLint location, GLuint x) {
 965   NOTREACHED() << "Unimplemented Uniform1ui.";
 966 }
 967 void MojoGLES2Impl::Uniform1uiv(GLint location,
 968                                 GLsizei count,
 969                                 const GLuint* v) {
 970   NOTREACHED() << "Unimplemented Uniform1uiv.";
 971 }
 972 void MojoGLES2Impl::Uniform2f(GLint location, GLfloat x, GLfloat y) {
 973   MojoGLES2MakeCurrent(context_);
 974   glUniform2f(location, x, y);
 975 }
 976 void MojoGLES2Impl::Uniform2fv(GLint location,
 977                                GLsizei count,
 978                                const GLfloat* v) {
 979   MojoGLES2MakeCurrent(context_);
 980   glUniform2fv(location, count, v);
 981 }
 982 void MojoGLES2Impl::Uniform2i(GLint location, GLint x, GLint y) {
 983   MojoGLES2MakeCurrent(context_);
 984   glUniform2i(location, x, y);
 985 }
 986 void MojoGLES2Impl::Uniform2iv(GLint location, GLsizei count, const GLint* v) {
 987   MojoGLES2MakeCurrent(context_);
 988   glUniform2iv(location, count, v);
 989 }
 990 void MojoGLES2Impl::Uniform2ui(GLint location, GLuint x, GLuint y) {
 991   NOTREACHED() << "Unimplemented Uniform2ui.";
 992 }
 993 void MojoGLES2Impl::Uniform2uiv(GLint location,
 994                                 GLsizei count,
 995                                 const GLuint* v) {
 996   NOTREACHED() << "Unimplemented Uniform2uiv.";
 997 }
 998 void MojoGLES2Impl::Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 999   MojoGLES2MakeCurrent(context_);
1000   glUniform3f(location, x, y, z);
1001 }
1002 void MojoGLES2Impl::Uniform3fv(GLint location,
1003                                GLsizei count,
1004                                const GLfloat* v) {
1005   MojoGLES2MakeCurrent(context_);
1006   glUniform3fv(location, count, v);
1007 }
1008 void MojoGLES2Impl::Uniform3i(GLint location, GLint x, GLint y, GLint z) {
1009   MojoGLES2MakeCurrent(context_);
1010   glUniform3i(location, x, y, z);
1011 }
1012 void MojoGLES2Impl::Uniform3iv(GLint location, GLsizei count, const GLint* v) {
1013   MojoGLES2MakeCurrent(context_);
1014   glUniform3iv(location, count, v);
1015 }
1016 void MojoGLES2Impl::Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
1017   NOTREACHED() << "Unimplemented Uniform3ui.";
1018 }
1019 void MojoGLES2Impl::Uniform3uiv(GLint location,
1020                                 GLsizei count,
1021                                 const GLuint* v) {
1022   NOTREACHED() << "Unimplemented Uniform3uiv.";
1023 }
1024 void MojoGLES2Impl::Uniform4f(GLint location,
1025                               GLfloat x,
1026                               GLfloat y,
1027                               GLfloat z,
1028                               GLfloat w) {
1029   MojoGLES2MakeCurrent(context_);
1030   glUniform4f(location, x, y, z, w);
1031 }
1032 void MojoGLES2Impl::Uniform4fv(GLint location,
1033                                GLsizei count,
1034                                const GLfloat* v) {
1035   MojoGLES2MakeCurrent(context_);
1036   glUniform4fv(location, count, v);
1037 }
1038 void MojoGLES2Impl::Uniform4i(GLint location,
1039                               GLint x,
1040                               GLint y,
1041                               GLint z,
1042                               GLint w) {
1043   MojoGLES2MakeCurrent(context_);
1044   glUniform4i(location, x, y, z, w);
1045 }
1046 void MojoGLES2Impl::Uniform4iv(GLint location, GLsizei count, const GLint* v) {
1047   MojoGLES2MakeCurrent(context_);
1048   glUniform4iv(location, count, v);
1049 }
1050 void MojoGLES2Impl::Uniform4ui(GLint location,
1051                                GLuint x,
1052                                GLuint y,
1053                                GLuint z,
1054                                GLuint w) {
1055   NOTREACHED() << "Unimplemented Uniform4ui.";
1056 }
1057 void MojoGLES2Impl::Uniform4uiv(GLint location,
1058                                 GLsizei count,
1059                                 const GLuint* v) {
1060   NOTREACHED() << "Unimplemented Uniform4uiv.";
1061 }
1062 void MojoGLES2Impl::UniformBlockBinding(GLuint program,
1063                                         GLuint index,
1064                                         GLuint binding) {
1065   NOTREACHED() << "Unimplemented UniformBlockBinding.";
1066 }
1067 void MojoGLES2Impl::UniformMatrix2fv(GLint location,
1068                                      GLsizei count,
1069                                      GLboolean transpose,
1070                                      const GLfloat* value) {
1071   MojoGLES2MakeCurrent(context_);
1072   glUniformMatrix2fv(location, count, transpose, value);
1073 }
1074 void MojoGLES2Impl::UniformMatrix2x3fv(GLint location,
1075                                        GLsizei count,
1076                                        GLboolean transpose,
1077                                        const GLfloat* value) {
1078   NOTREACHED() << "Unimplemented UniformMatrix2x3fv.";
1079 }
1080 void MojoGLES2Impl::UniformMatrix2x4fv(GLint location,
1081                                        GLsizei count,
1082                                        GLboolean transpose,
1083                                        const GLfloat* value) {
1084   NOTREACHED() << "Unimplemented UniformMatrix2x4fv.";
1085 }
1086 void MojoGLES2Impl::UniformMatrix3fv(GLint location,
1087                                      GLsizei count,
1088                                      GLboolean transpose,
1089                                      const GLfloat* value) {
1090   MojoGLES2MakeCurrent(context_);
1091   glUniformMatrix3fv(location, count, transpose, value);
1092 }
1093 void MojoGLES2Impl::UniformMatrix3x2fv(GLint location,
1094                                        GLsizei count,
1095                                        GLboolean transpose,
1096                                        const GLfloat* value) {
1097   NOTREACHED() << "Unimplemented UniformMatrix3x2fv.";
1098 }
1099 void MojoGLES2Impl::UniformMatrix3x4fv(GLint location,
1100                                        GLsizei count,
1101                                        GLboolean transpose,
1102                                        const GLfloat* value) {
1103   NOTREACHED() << "Unimplemented UniformMatrix3x4fv.";
1104 }
1105 void MojoGLES2Impl::UniformMatrix4fv(GLint location,
1106                                      GLsizei count,
1107                                      GLboolean transpose,
1108                                      const GLfloat* value) {
1109   MojoGLES2MakeCurrent(context_);
1110   glUniformMatrix4fv(location, count, transpose, value);
1111 }
1112 void MojoGLES2Impl::UniformMatrix4x2fv(GLint location,
1113                                        GLsizei count,
1114                                        GLboolean transpose,
1115                                        const GLfloat* value) {
1116   NOTREACHED() << "Unimplemented UniformMatrix4x2fv.";
1117 }
1118 void MojoGLES2Impl::UniformMatrix4x3fv(GLint location,
1119                                        GLsizei count,
1120                                        GLboolean transpose,
1121                                        const GLfloat* value) {
1122   NOTREACHED() << "Unimplemented UniformMatrix4x3fv.";
1123 }
1124 void MojoGLES2Impl::UseProgram(GLuint program) {
1125   MojoGLES2MakeCurrent(context_);
1126   glUseProgram(program);
1127 }
1128 void MojoGLES2Impl::ValidateProgram(GLuint program) {
1129   MojoGLES2MakeCurrent(context_);
1130   glValidateProgram(program);
1131 }
1132 void MojoGLES2Impl::VertexAttrib1f(GLuint indx, GLfloat x) {
1133   MojoGLES2MakeCurrent(context_);
1134   glVertexAttrib1f(indx, x);
1135 }
1136 void MojoGLES2Impl::VertexAttrib1fv(GLuint indx, const GLfloat* values) {
1137   MojoGLES2MakeCurrent(context_);
1138   glVertexAttrib1fv(indx, values);
1139 }
1140 void MojoGLES2Impl::VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
1141   MojoGLES2MakeCurrent(context_);
1142   glVertexAttrib2f(indx, x, y);
1143 }
1144 void MojoGLES2Impl::VertexAttrib2fv(GLuint indx, const GLfloat* values) {
1145   MojoGLES2MakeCurrent(context_);
1146   glVertexAttrib2fv(indx, values);
1147 }
1148 void MojoGLES2Impl::VertexAttrib3f(GLuint indx,
1149                                    GLfloat x,
1150                                    GLfloat y,
1151                                    GLfloat z) {
1152   MojoGLES2MakeCurrent(context_);
1153   glVertexAttrib3f(indx, x, y, z);
1154 }
1155 void MojoGLES2Impl::VertexAttrib3fv(GLuint indx, const GLfloat* values) {
1156   MojoGLES2MakeCurrent(context_);
1157   glVertexAttrib3fv(indx, values);
1158 }
1159 void MojoGLES2Impl::VertexAttrib4f(GLuint indx,
1160                                    GLfloat x,
1161                                    GLfloat y,
1162                                    GLfloat z,
1163                                    GLfloat w) {
1164   MojoGLES2MakeCurrent(context_);
1165   glVertexAttrib4f(indx, x, y, z, w);
1166 }
1167 void MojoGLES2Impl::VertexAttrib4fv(GLuint indx, const GLfloat* values) {
1168   MojoGLES2MakeCurrent(context_);
1169   glVertexAttrib4fv(indx, values);
1170 }
1171 void MojoGLES2Impl::VertexAttribI4i(GLuint indx,
1172                                     GLint x,
1173                                     GLint y,
1174                                     GLint z,
1175                                     GLint w) {
1176   NOTREACHED() << "Unimplemented VertexAttribI4i.";
1177 }
1178 void MojoGLES2Impl::VertexAttribI4iv(GLuint indx, const GLint* values) {
1179   NOTREACHED() << "Unimplemented VertexAttribI4iv.";
1180 }
1181 void MojoGLES2Impl::VertexAttribI4ui(GLuint indx,
1182                                      GLuint x,
1183                                      GLuint y,
1184                                      GLuint z,
1185                                      GLuint w) {
1186   NOTREACHED() << "Unimplemented VertexAttribI4ui.";
1187 }
1188 void MojoGLES2Impl::VertexAttribI4uiv(GLuint indx, const GLuint* values) {
1189   NOTREACHED() << "Unimplemented VertexAttribI4uiv.";
1190 }
1191 void MojoGLES2Impl::VertexAttribIPointer(GLuint indx,
1192                                          GLint size,
1193                                          GLenum type,
1194                                          GLsizei stride,
1195                                          const void* ptr) {
1196   NOTREACHED() << "Unimplemented VertexAttribIPointer.";
1197 }
1198 void MojoGLES2Impl::VertexAttribPointer(GLuint indx,
1199                                         GLint size,
1200                                         GLenum type,
1201                                         GLboolean normalized,
1202                                         GLsizei stride,
1203                                         const void* ptr) {
1204   MojoGLES2MakeCurrent(context_);
1205   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
1206 }
1207 void MojoGLES2Impl::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1208   MojoGLES2MakeCurrent(context_);
1209   glViewport(x, y, width, height);
1210 }
1211 void MojoGLES2Impl::WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
1212   NOTREACHED() << "Unimplemented WaitSync.";
1213 }
1214 void MojoGLES2Impl::BlitFramebufferCHROMIUM(GLint srcX0,
1215                                             GLint srcY0,
1216                                             GLint srcX1,
1217                                             GLint srcY1,
1218                                             GLint dstX0,
1219                                             GLint dstY0,
1220                                             GLint dstX1,
1221                                             GLint dstY1,
1222                                             GLbitfield mask,
1223                                             GLenum filter) {
1224   NOTREACHED() << "Unimplemented BlitFramebufferCHROMIUM.";
1225 }
1226 void MojoGLES2Impl::RenderbufferStorageMultisampleCHROMIUM(
1227     GLenum target,
1228     GLsizei samples,
1229     GLenum internalformat,
1230     GLsizei width,
1231     GLsizei height) {
1232   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleCHROMIUM.";
1233 }
1234 void MojoGLES2Impl::RenderbufferStorageMultisampleEXT(GLenum target,
1235                                                       GLsizei samples,
1236                                                       GLenum internalformat,
1237                                                       GLsizei width,
1238                                                       GLsizei height) {
1239   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleEXT.";
1240 }
1241 void MojoGLES2Impl::FramebufferTexture2DMultisampleEXT(GLenum target,
1242                                                        GLenum attachment,
1243                                                        GLenum textarget,
1244                                                        GLuint texture,
1245                                                        GLint level,
1246                                                        GLsizei samples) {
1247   NOTREACHED() << "Unimplemented FramebufferTexture2DMultisampleEXT.";
1248 }
1249 void MojoGLES2Impl::TexStorage2DEXT(GLenum target,
1250                                     GLsizei levels,
1251                                     GLenum internalFormat,
1252                                     GLsizei width,
1253                                     GLsizei height) {
1254   NOTREACHED() << "Unimplemented TexStorage2DEXT.";
1255 }
1256 void MojoGLES2Impl::GenQueriesEXT(GLsizei n, GLuint* queries) {
1257   MojoGLES2MakeCurrent(context_);
1258   glGenQueriesEXT(n, queries);
1259 }
1260 void MojoGLES2Impl::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
1261   MojoGLES2MakeCurrent(context_);
1262   glDeleteQueriesEXT(n, queries);
1263 }
1264 void MojoGLES2Impl::QueryCounterEXT(GLuint id, GLenum target) {
1265   NOTREACHED() << "Unimplemented QueryCounterEXT.";
1266 }
1267 GLboolean MojoGLES2Impl::IsQueryEXT(GLuint id) {
1268   MojoGLES2MakeCurrent(context_);
1269   return glIsQueryEXT(id);
1270 }
1271 void MojoGLES2Impl::BeginQueryEXT(GLenum target, GLuint id) {
1272   MojoGLES2MakeCurrent(context_);
1273   glBeginQueryEXT(target, id);
1274 }
1275 void MojoGLES2Impl::BeginTransformFeedback(GLenum primitivemode) {
1276   NOTREACHED() << "Unimplemented BeginTransformFeedback.";
1277 }
1278 void MojoGLES2Impl::EndQueryEXT(GLenum target) {
1279   MojoGLES2MakeCurrent(context_);
1280   glEndQueryEXT(target);
1281 }
1282 void MojoGLES2Impl::EndTransformFeedback() {
1283   NOTREACHED() << "Unimplemented EndTransformFeedback.";
1284 }
1285 void MojoGLES2Impl::GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
1286   MojoGLES2MakeCurrent(context_);
1287   glGetQueryivEXT(target, pname, params);
1288 }
1289 void MojoGLES2Impl::GetQueryObjectivEXT(GLuint id,
1290                                         GLenum pname,
1291                                         GLint* params) {
1292   NOTREACHED() << "Unimplemented GetQueryObjectivEXT.";
1293 }
1294 void MojoGLES2Impl::GetQueryObjectuivEXT(GLuint id,
1295                                          GLenum pname,
1296                                          GLuint* params) {
1297   MojoGLES2MakeCurrent(context_);
1298   glGetQueryObjectuivEXT(id, pname, params);
1299 }
1300 void MojoGLES2Impl::GetQueryObjecti64vEXT(GLuint id,
1301                                           GLenum pname,
1302                                           GLint64* params) {
1303   NOTREACHED() << "Unimplemented GetQueryObjecti64vEXT.";
1304 }
1305 void MojoGLES2Impl::GetQueryObjectui64vEXT(GLuint id,
1306                                            GLenum pname,
1307                                            GLuint64* params) {
1308   NOTREACHED() << "Unimplemented GetQueryObjectui64vEXT.";
1309 }
1310 void MojoGLES2Impl::SetDisjointValueSyncCHROMIUM() {
1311   NOTREACHED() << "Unimplemented SetDisjointValueSyncCHROMIUM.";
1312 }
1313 void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1314   NOTREACHED() << "Unimplemented InsertEventMarkerEXT.";
1315 }
1316 void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1317   NOTREACHED() << "Unimplemented PushGroupMarkerEXT.";
1318 }
1319 void MojoGLES2Impl::PopGroupMarkerEXT() {
1320   NOTREACHED() << "Unimplemented PopGroupMarkerEXT.";
1321 }
1322 void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1323   NOTREACHED() << "Unimplemented GenVertexArraysOES.";
1324 }
1325 void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1326   NOTREACHED() << "Unimplemented DeleteVertexArraysOES.";
1327 }
1328 GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
1329   NOTREACHED() << "Unimplemented IsVertexArrayOES.";
1330   return 0;
1331 }
1332 void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
1333   NOTREACHED() << "Unimplemented BindVertexArrayOES.";
1334 }
1335 void MojoGLES2Impl::SwapBuffers() {
1336   NOTREACHED() << "Unimplemented SwapBuffers.";
1337 }
1338 GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1339                                                   GLsizei count,
1340                                                   GLenum type,
1341                                                   GLuint offset) {
1342   NOTREACHED() << "Unimplemented GetMaxValueInBufferCHROMIUM.";
1343   return 0;
1344 }
1345 GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
1346   NOTREACHED() << "Unimplemented EnableFeatureCHROMIUM.";
1347   return 0;
1348 }
1349 void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
1350   MojoGLES2MakeCurrent(context_);
1351   return glMapBufferCHROMIUM(target, access);
1352 }
1353 GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
1354   MojoGLES2MakeCurrent(context_);
1355   return glUnmapBufferCHROMIUM(target);
1356 }
1357 void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
1358                                               GLintptr offset,
1359                                               GLsizeiptr size,
1360                                               GLenum access) {
1361   NOTREACHED() << "Unimplemented MapBufferSubDataCHROMIUM.";
1362   return 0;
1363 }
1364 void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
1365   NOTREACHED() << "Unimplemented UnmapBufferSubDataCHROMIUM.";
1366 }
1367 void* MojoGLES2Impl::MapBufferRange(GLenum target,
1368                                     GLintptr offset,
1369                                     GLsizeiptr size,
1370                                     GLbitfield access) {
1371   NOTREACHED() << "Unimplemented MapBufferRange.";
1372   return 0;
1373 }
1374 GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
1375   NOTREACHED() << "Unimplemented UnmapBuffer.";
1376   return 0;
1377 }
1378 void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
1379                                               GLint level,
1380                                               GLint xoffset,
1381                                               GLint yoffset,
1382                                               GLsizei width,
1383                                               GLsizei height,
1384                                               GLenum format,
1385                                               GLenum type,
1386                                               GLenum access) {
1387   MojoGLES2MakeCurrent(context_);
1388   return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1389                                     height, format, type, access);
1390 }
1391 void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1392   MojoGLES2MakeCurrent(context_);
1393   glUnmapTexSubImage2DCHROMIUM(mem);
1394 }
1395 void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
1396                                    GLuint height,
1397                                    GLfloat scale_factor) {
1398   NOTREACHED() << "Unimplemented ResizeCHROMIUM.";
1399 }
1400 const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
1401   NOTREACHED() << "Unimplemented GetRequestableExtensionsCHROMIUM.";
1402   return 0;
1403 }
1404 void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
1405   NOTREACHED() << "Unimplemented RequestExtensionCHROMIUM.";
1406 }
1407 void MojoGLES2Impl::RateLimitOffscreenContextCHROMIUM() {
1408   NOTREACHED() << "Unimplemented RateLimitOffscreenContextCHROMIUM.";
1409 }
1410 void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
1411                                            GLsizei bufsize,
1412                                            GLsizei* size,
1413                                            void* info) {
1414   NOTREACHED() << "Unimplemented GetProgramInfoCHROMIUM.";
1415 }
1416 void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
1417                                              GLsizei bufsize,
1418                                              GLsizei* size,
1419                                              void* info) {
1420   NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
1421 }
1422 void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1423                                                          GLsizei bufsize,
1424                                                          GLsizei* size,
1425                                                          void* info) {
1426   NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
1427 }
1428 void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
1429                                            GLsizei bufsize,
1430                                            GLsizei* size,
1431                                            void* info) {
1432   NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
1433 }
1434 GLuint MojoGLES2Impl::CreateStreamTextureCHROMIUM(GLuint texture) {
1435   NOTREACHED() << "Unimplemented CreateStreamTextureCHROMIUM.";
1436   return 0;
1437 }
1438 GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
1439                                           GLsizei width,
1440                                           GLsizei height,
1441                                           GLenum internalformat) {
1442   MojoGLES2MakeCurrent(context_);
1443   return glCreateImageCHROMIUM(buffer, width, height, internalformat);
1444 }
1445 void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
1446   MojoGLES2MakeCurrent(context_);
1447   glDestroyImageCHROMIUM(image_id);
1448 }
1449 GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1450                                                          GLsizei height,
1451                                                          GLenum internalformat,
1452                                                          GLenum usage) {
1453   MojoGLES2MakeCurrent(context_);
1454   return glCreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
1455                                               usage);
1456 }
1457 void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
1458                                                    GLsizei bufsize,
1459                                                    GLsizei* length,
1460                                                    char* source) {
1461   NOTREACHED() << "Unimplemented GetTranslatedShaderSourceANGLE.";
1462 }
1463 void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
1464                                           GLint y,
1465                                           GLint width,
1466                                           GLint height) {
1467   NOTREACHED() << "Unimplemented PostSubBufferCHROMIUM.";
1468 }
1469 void MojoGLES2Impl::TexImageIOSurface2DCHROMIUM(GLenum target,
1470                                                 GLsizei width,
1471                                                 GLsizei height,
1472                                                 GLuint ioSurfaceId,
1473                                                 GLuint plane) {
1474   NOTREACHED() << "Unimplemented TexImageIOSurface2DCHROMIUM.";
1475 }
1476 void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum target,
1477                                         GLenum source_id,
1478                                         GLenum dest_id,
1479                                         GLint internalformat,
1480                                         GLenum dest_type,
1481                                         GLboolean unpack_flip_y,
1482                                         GLboolean unpack_premultiply_alpha,
1483                                         GLboolean unpack_unmultiply_alpha) {
1484   MojoGLES2MakeCurrent(context_);
1485   glCopyTextureCHROMIUM(target, source_id, dest_id, internalformat, dest_type,
1486                         unpack_flip_y, unpack_premultiply_alpha,
1487                         unpack_unmultiply_alpha);
1488 }
1489 void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum target,
1490                                            GLenum source_id,
1491                                            GLenum dest_id,
1492                                            GLint xoffset,
1493                                            GLint yoffset,
1494                                            GLint x,
1495                                            GLint y,
1496                                            GLsizei width,
1497                                            GLsizei height,
1498                                            GLboolean unpack_flip_y,
1499                                            GLboolean unpack_premultiply_alpha,
1500                                            GLboolean unpack_unmultiply_alpha) {
1501   MojoGLES2MakeCurrent(context_);
1502   glCopySubTextureCHROMIUM(target, source_id, dest_id, xoffset, yoffset, x, y,
1503                            width, height, unpack_flip_y,
1504                            unpack_premultiply_alpha, unpack_unmultiply_alpha);
1505 }
1506 void MojoGLES2Impl::CompressedCopyTextureCHROMIUM(GLenum target,
1507                                                   GLenum source_id,
1508                                                   GLenum dest_id) {
1509   NOTREACHED() << "Unimplemented CompressedCopyTextureCHROMIUM.";
1510 }
1511 void MojoGLES2Impl::CompressedCopySubTextureCHROMIUM(GLenum target,
1512                                                      GLenum source_id,
1513                                                      GLenum dest_id,
1514                                                      GLint xoffset,
1515                                                      GLint yoffset,
1516                                                      GLint x,
1517                                                      GLint y,
1518                                                      GLsizei width,
1519                                                      GLsizei height) {
1520   NOTREACHED() << "Unimplemented CompressedCopySubTextureCHROMIUM.";
1521 }
1522 void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
1523                                              GLint first,
1524                                              GLsizei count,
1525                                              GLsizei primcount) {
1526   NOTREACHED() << "Unimplemented DrawArraysInstancedANGLE.";
1527 }
1528 void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
1529                                                GLsizei count,
1530                                                GLenum type,
1531                                                const void* indices,
1532                                                GLsizei primcount) {
1533   NOTREACHED() << "Unimplemented DrawElementsInstancedANGLE.";
1534 }
1535 void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1536   NOTREACHED() << "Unimplemented VertexAttribDivisorANGLE.";
1537 }
1538 void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
1539   MojoGLES2MakeCurrent(context_);
1540   glGenMailboxCHROMIUM(mailbox);
1541 }
1542 void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
1543                                            const GLbyte* mailbox) {
1544   MojoGLES2MakeCurrent(context_);
1545   glProduceTextureCHROMIUM(target, mailbox);
1546 }
1547 void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
1548                                                  GLenum target,
1549                                                  const GLbyte* mailbox) {
1550   MojoGLES2MakeCurrent(context_);
1551   glProduceTextureDirectCHROMIUM(texture, target, mailbox);
1552 }
1553 void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
1554                                            const GLbyte* mailbox) {
1555   MojoGLES2MakeCurrent(context_);
1556   glConsumeTextureCHROMIUM(target, mailbox);
1557 }
1558 GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
1559                                                       const GLbyte* mailbox) {
1560   MojoGLES2MakeCurrent(context_);
1561   return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
1562 }
1563 void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
1564                                                 GLint location,
1565                                                 const char* name) {
1566   NOTREACHED() << "Unimplemented BindUniformLocationCHROMIUM.";
1567 }
1568 void MojoGLES2Impl::GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1569   NOTREACHED() << "Unimplemented GenValuebuffersCHROMIUM.";
1570 }
1571 void MojoGLES2Impl::DeleteValuebuffersCHROMIUM(GLsizei n,
1572                                                const GLuint* valuebuffers) {
1573   NOTREACHED() << "Unimplemented DeleteValuebuffersCHROMIUM.";
1574 }
1575 GLboolean MojoGLES2Impl::IsValuebufferCHROMIUM(GLuint valuebuffer) {
1576   NOTREACHED() << "Unimplemented IsValuebufferCHROMIUM.";
1577   return 0;
1578 }
1579 void MojoGLES2Impl::BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1580   NOTREACHED() << "Unimplemented BindValuebufferCHROMIUM.";
1581 }
1582 void MojoGLES2Impl::SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1583   NOTREACHED() << "Unimplemented SubscribeValueCHROMIUM.";
1584 }
1585 void MojoGLES2Impl::PopulateSubscribedValuesCHROMIUM(GLenum target) {
1586   NOTREACHED() << "Unimplemented PopulateSubscribedValuesCHROMIUM.";
1587 }
1588 void MojoGLES2Impl::UniformValuebufferCHROMIUM(GLint location,
1589                                                GLenum target,
1590                                                GLenum subscription) {
1591   NOTREACHED() << "Unimplemented UniformValuebufferCHROMIUM.";
1592 }
1593 void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1594   MojoGLES2MakeCurrent(context_);
1595   glBindTexImage2DCHROMIUM(target, imageId);
1596 }
1597 void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1598   MojoGLES2MakeCurrent(context_);
1599   glReleaseTexImage2DCHROMIUM(target, imageId);
1600 }
1601 void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
1602                                        const char* trace_name) {
1603   NOTREACHED() << "Unimplemented TraceBeginCHROMIUM.";
1604 }
1605 void MojoGLES2Impl::TraceEndCHROMIUM() {
1606   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
1607 }
1608 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
1609                                           GLsizei count,
1610                                           const GLenum* attachments) {
1611   NOTREACHED() << "Unimplemented DiscardFramebufferEXT.";
1612 }
1613 void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
1614   NOTREACHED() << "Unimplemented LoseContextCHROMIUM.";
1615 }
1616 GLuint MojoGLES2Impl::InsertSyncPointCHROMIUM() {
1617   MojoGLES2MakeCurrent(context_);
1618   return glInsertSyncPointCHROMIUM();
1619 }
1620 void MojoGLES2Impl::WaitSyncPointCHROMIUM(GLuint sync_point) {
1621   MojoGLES2MakeCurrent(context_);
1622   glWaitSyncPointCHROMIUM(sync_point);
1623 }
1624 void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1625   NOTREACHED() << "Unimplemented DrawBuffersEXT.";
1626 }
1627 void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
1628   NOTREACHED() << "Unimplemented DiscardBackbufferCHROMIUM.";
1629 }
1630 void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1631                                                  GLenum plane_transform,
1632                                                  GLuint overlay_texture_id,
1633                                                  GLint bounds_x,
1634                                                  GLint bounds_y,
1635                                                  GLint bounds_width,
1636                                                  GLint bounds_height,
1637                                                  GLfloat uv_x,
1638                                                  GLfloat uv_y,
1639                                                  GLfloat uv_width,
1640                                                  GLfloat uv_height) {
1641   NOTREACHED() << "Unimplemented ScheduleOverlayPlaneCHROMIUM.";
1642 }
1643 void MojoGLES2Impl::SwapInterval(GLint interval) {
1644   NOTREACHED() << "Unimplemented SwapInterval.";
1645 }
1646 void MojoGLES2Impl::FlushDriverCachesCHROMIUM() {
1647   NOTREACHED() << "Unimplemented FlushDriverCachesCHROMIUM.";
1648 }
1649 void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1650   NOTREACHED() << "Unimplemented MatrixLoadfCHROMIUM.";
1651 }
1652 void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1653   NOTREACHED() << "Unimplemented MatrixLoadIdentityCHROMIUM.";
1654 }
1655 GLuint MojoGLES2Impl::GenPathsCHROMIUM(GLsizei range) {
1656   NOTREACHED() << "Unimplemented GenPathsCHROMIUM.";
1657   return 0;
1658 }
1659 void MojoGLES2Impl::DeletePathsCHROMIUM(GLuint path, GLsizei range) {
1660   NOTREACHED() << "Unimplemented DeletePathsCHROMIUM.";
1661 }
1662 GLboolean MojoGLES2Impl::IsPathCHROMIUM(GLuint path) {
1663   NOTREACHED() << "Unimplemented IsPathCHROMIUM.";
1664   return 0;
1665 }
1666 void MojoGLES2Impl::PathCommandsCHROMIUM(GLuint path,
1667                                          GLsizei numCommands,
1668                                          const GLubyte* commands,
1669                                          GLsizei numCoords,
1670                                          GLenum coordType,
1671                                          const GLvoid* coords) {
1672   NOTREACHED() << "Unimplemented PathCommandsCHROMIUM.";
1673 }
1674 void MojoGLES2Impl::PathParameterfCHROMIUM(GLuint path,
1675                                            GLenum pname,
1676                                            GLfloat value) {
1677   NOTREACHED() << "Unimplemented PathParameterfCHROMIUM.";
1678 }
1679 void MojoGLES2Impl::PathParameteriCHROMIUM(GLuint path,
1680                                            GLenum pname,
1681                                            GLint value) {
1682   NOTREACHED() << "Unimplemented PathParameteriCHROMIUM.";
1683 }
1684 void MojoGLES2Impl::PathStencilFuncCHROMIUM(GLenum func,
1685                                             GLint ref,
1686                                             GLuint mask) {
1687   NOTREACHED() << "Unimplemented PathStencilFuncCHROMIUM.";
1688 }
1689 void MojoGLES2Impl::StencilFillPathCHROMIUM(GLuint path,
1690                                             GLenum fillMode,
1691                                             GLuint mask) {
1692   NOTREACHED() << "Unimplemented StencilFillPathCHROMIUM.";
1693 }
1694 void MojoGLES2Impl::StencilStrokePathCHROMIUM(GLuint path,
1695                                               GLint reference,
1696                                               GLuint mask) {
1697   NOTREACHED() << "Unimplemented StencilStrokePathCHROMIUM.";
1698 }
1699 void MojoGLES2Impl::CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
1700   NOTREACHED() << "Unimplemented CoverFillPathCHROMIUM.";
1701 }
1702 void MojoGLES2Impl::CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
1703   NOTREACHED() << "Unimplemented CoverStrokePathCHROMIUM.";
1704 }
1705 void MojoGLES2Impl::StencilThenCoverFillPathCHROMIUM(GLuint path,
1706                                                      GLenum fillMode,
1707                                                      GLuint mask,
1708                                                      GLenum coverMode) {
1709   NOTREACHED() << "Unimplemented StencilThenCoverFillPathCHROMIUM.";
1710 }
1711 void MojoGLES2Impl::StencilThenCoverStrokePathCHROMIUM(GLuint path,
1712                                                        GLint reference,
1713                                                        GLuint mask,
1714                                                        GLenum coverMode) {
1715   NOTREACHED() << "Unimplemented StencilThenCoverStrokePathCHROMIUM.";
1716 }
1717 GLenum MojoGLES2Impl::GetGraphicsResetStatusKHR() {
1718   NOTREACHED() << "Unimplemented GetGraphicsResetStatusKHR.";
1719   return 0;
1720 }
1721 void MojoGLES2Impl::BlendBarrierKHR() {
1722   NOTREACHED() << "Unimplemented BlendBarrierKHR.";
1723 }
1724
1725 }  // namespace mojo