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::GetQueryObjectuivEXT(GLuint id,
1289                                          GLenum pname,
1290                                          GLuint* params) {
1291   MojoGLES2MakeCurrent(context_);
1292   glGetQueryObjectuivEXT(id, pname, params);
1293 }
1294 void MojoGLES2Impl::GetQueryObjectui64vEXT(GLuint id,
1295                                            GLenum pname,
1296                                            GLuint64* params) {
1297   NOTREACHED() << "Unimplemented GetQueryObjectui64vEXT.";
1298 }
1299 void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1300   NOTREACHED() << "Unimplemented InsertEventMarkerEXT.";
1301 }
1302 void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1303   NOTREACHED() << "Unimplemented PushGroupMarkerEXT.";
1304 }
1305 void MojoGLES2Impl::PopGroupMarkerEXT() {
1306   NOTREACHED() << "Unimplemented PopGroupMarkerEXT.";
1307 }
1308 void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1309   NOTREACHED() << "Unimplemented GenVertexArraysOES.";
1310 }
1311 void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1312   NOTREACHED() << "Unimplemented DeleteVertexArraysOES.";
1313 }
1314 GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
1315   NOTREACHED() << "Unimplemented IsVertexArrayOES.";
1316   return 0;
1317 }
1318 void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
1319   NOTREACHED() << "Unimplemented BindVertexArrayOES.";
1320 }
1321 void MojoGLES2Impl::SwapBuffers() {
1322   NOTREACHED() << "Unimplemented SwapBuffers.";
1323 }
1324 GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1325                                                   GLsizei count,
1326                                                   GLenum type,
1327                                                   GLuint offset) {
1328   NOTREACHED() << "Unimplemented GetMaxValueInBufferCHROMIUM.";
1329   return 0;
1330 }
1331 GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
1332   NOTREACHED() << "Unimplemented EnableFeatureCHROMIUM.";
1333   return 0;
1334 }
1335 void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
1336   MojoGLES2MakeCurrent(context_);
1337   return glMapBufferCHROMIUM(target, access);
1338 }
1339 GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
1340   MojoGLES2MakeCurrent(context_);
1341   return glUnmapBufferCHROMIUM(target);
1342 }
1343 void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
1344                                               GLintptr offset,
1345                                               GLsizeiptr size,
1346                                               GLenum access) {
1347   NOTREACHED() << "Unimplemented MapBufferSubDataCHROMIUM.";
1348   return 0;
1349 }
1350 void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
1351   NOTREACHED() << "Unimplemented UnmapBufferSubDataCHROMIUM.";
1352 }
1353 void* MojoGLES2Impl::MapBufferRange(GLenum target,
1354                                     GLintptr offset,
1355                                     GLsizeiptr size,
1356                                     GLbitfield access) {
1357   NOTREACHED() << "Unimplemented MapBufferRange.";
1358   return 0;
1359 }
1360 GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
1361   NOTREACHED() << "Unimplemented UnmapBuffer.";
1362   return 0;
1363 }
1364 void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
1365                                               GLint level,
1366                                               GLint xoffset,
1367                                               GLint yoffset,
1368                                               GLsizei width,
1369                                               GLsizei height,
1370                                               GLenum format,
1371                                               GLenum type,
1372                                               GLenum access) {
1373   MojoGLES2MakeCurrent(context_);
1374   return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1375                                     height, format, type, access);
1376 }
1377 void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1378   MojoGLES2MakeCurrent(context_);
1379   glUnmapTexSubImage2DCHROMIUM(mem);
1380 }
1381 void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
1382                                    GLuint height,
1383                                    GLfloat scale_factor) {
1384   NOTREACHED() << "Unimplemented ResizeCHROMIUM.";
1385 }
1386 const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
1387   NOTREACHED() << "Unimplemented GetRequestableExtensionsCHROMIUM.";
1388   return 0;
1389 }
1390 void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
1391   NOTREACHED() << "Unimplemented RequestExtensionCHROMIUM.";
1392 }
1393 void MojoGLES2Impl::RateLimitOffscreenContextCHROMIUM() {
1394   NOTREACHED() << "Unimplemented RateLimitOffscreenContextCHROMIUM.";
1395 }
1396 void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
1397                                            GLsizei bufsize,
1398                                            GLsizei* size,
1399                                            void* info) {
1400   NOTREACHED() << "Unimplemented GetProgramInfoCHROMIUM.";
1401 }
1402 void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
1403                                              GLsizei bufsize,
1404                                              GLsizei* size,
1405                                              void* info) {
1406   NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
1407 }
1408 void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1409                                                          GLsizei bufsize,
1410                                                          GLsizei* size,
1411                                                          void* info) {
1412   NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
1413 }
1414 void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
1415                                            GLsizei bufsize,
1416                                            GLsizei* size,
1417                                            void* info) {
1418   NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
1419 }
1420 GLuint MojoGLES2Impl::CreateStreamTextureCHROMIUM(GLuint texture) {
1421   NOTREACHED() << "Unimplemented CreateStreamTextureCHROMIUM.";
1422   return 0;
1423 }
1424 GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
1425                                           GLsizei width,
1426                                           GLsizei height,
1427                                           GLenum internalformat) {
1428   MojoGLES2MakeCurrent(context_);
1429   return glCreateImageCHROMIUM(buffer, width, height, internalformat);
1430 }
1431 void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
1432   MojoGLES2MakeCurrent(context_);
1433   glDestroyImageCHROMIUM(image_id);
1434 }
1435 GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1436                                                          GLsizei height,
1437                                                          GLenum internalformat,
1438                                                          GLenum usage) {
1439   MojoGLES2MakeCurrent(context_);
1440   return glCreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
1441                                               usage);
1442 }
1443 void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
1444                                                    GLsizei bufsize,
1445                                                    GLsizei* length,
1446                                                    char* source) {
1447   NOTREACHED() << "Unimplemented GetTranslatedShaderSourceANGLE.";
1448 }
1449 void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
1450                                           GLint y,
1451                                           GLint width,
1452                                           GLint height) {
1453   NOTREACHED() << "Unimplemented PostSubBufferCHROMIUM.";
1454 }
1455 void MojoGLES2Impl::TexImageIOSurface2DCHROMIUM(GLenum target,
1456                                                 GLsizei width,
1457                                                 GLsizei height,
1458                                                 GLuint ioSurfaceId,
1459                                                 GLuint plane) {
1460   NOTREACHED() << "Unimplemented TexImageIOSurface2DCHROMIUM.";
1461 }
1462 void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum target,
1463                                         GLenum source_id,
1464                                         GLenum dest_id,
1465                                         GLint internalformat,
1466                                         GLenum dest_type,
1467                                         GLboolean unpack_flip_y,
1468                                         GLboolean unpack_premultiply_alpha,
1469                                         GLboolean unpack_unmultiply_alpha) {
1470   MojoGLES2MakeCurrent(context_);
1471   glCopyTextureCHROMIUM(target, source_id, dest_id, internalformat, dest_type,
1472                         unpack_flip_y, unpack_premultiply_alpha,
1473                         unpack_unmultiply_alpha);
1474 }
1475 void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum target,
1476                                            GLenum source_id,
1477                                            GLenum dest_id,
1478                                            GLint xoffset,
1479                                            GLint yoffset,
1480                                            GLint x,
1481                                            GLint y,
1482                                            GLsizei width,
1483                                            GLsizei height,
1484                                            GLboolean unpack_flip_y,
1485                                            GLboolean unpack_premultiply_alpha,
1486                                            GLboolean unpack_unmultiply_alpha) {
1487   MojoGLES2MakeCurrent(context_);
1488   glCopySubTextureCHROMIUM(target, source_id, dest_id, xoffset, yoffset, x, y,
1489                            width, height, unpack_flip_y,
1490                            unpack_premultiply_alpha, unpack_unmultiply_alpha);
1491 }
1492 void MojoGLES2Impl::CompressedCopyTextureCHROMIUM(GLenum target,
1493                                                   GLenum source_id,
1494                                                   GLenum dest_id) {
1495   NOTREACHED() << "Unimplemented CompressedCopyTextureCHROMIUM.";
1496 }
1497 void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
1498                                              GLint first,
1499                                              GLsizei count,
1500                                              GLsizei primcount) {
1501   NOTREACHED() << "Unimplemented DrawArraysInstancedANGLE.";
1502 }
1503 void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
1504                                                GLsizei count,
1505                                                GLenum type,
1506                                                const void* indices,
1507                                                GLsizei primcount) {
1508   NOTREACHED() << "Unimplemented DrawElementsInstancedANGLE.";
1509 }
1510 void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1511   NOTREACHED() << "Unimplemented VertexAttribDivisorANGLE.";
1512 }
1513 void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
1514   MojoGLES2MakeCurrent(context_);
1515   glGenMailboxCHROMIUM(mailbox);
1516 }
1517 void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
1518                                            const GLbyte* mailbox) {
1519   MojoGLES2MakeCurrent(context_);
1520   glProduceTextureCHROMIUM(target, mailbox);
1521 }
1522 void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
1523                                                  GLenum target,
1524                                                  const GLbyte* mailbox) {
1525   MojoGLES2MakeCurrent(context_);
1526   glProduceTextureDirectCHROMIUM(texture, target, mailbox);
1527 }
1528 void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
1529                                            const GLbyte* mailbox) {
1530   MojoGLES2MakeCurrent(context_);
1531   glConsumeTextureCHROMIUM(target, mailbox);
1532 }
1533 GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
1534                                                       const GLbyte* mailbox) {
1535   MojoGLES2MakeCurrent(context_);
1536   return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
1537 }
1538 void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
1539                                                 GLint location,
1540                                                 const char* name) {
1541   NOTREACHED() << "Unimplemented BindUniformLocationCHROMIUM.";
1542 }
1543 void MojoGLES2Impl::GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1544   NOTREACHED() << "Unimplemented GenValuebuffersCHROMIUM.";
1545 }
1546 void MojoGLES2Impl::DeleteValuebuffersCHROMIUM(GLsizei n,
1547                                                const GLuint* valuebuffers) {
1548   NOTREACHED() << "Unimplemented DeleteValuebuffersCHROMIUM.";
1549 }
1550 GLboolean MojoGLES2Impl::IsValuebufferCHROMIUM(GLuint valuebuffer) {
1551   NOTREACHED() << "Unimplemented IsValuebufferCHROMIUM.";
1552   return 0;
1553 }
1554 void MojoGLES2Impl::BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1555   NOTREACHED() << "Unimplemented BindValuebufferCHROMIUM.";
1556 }
1557 void MojoGLES2Impl::SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1558   NOTREACHED() << "Unimplemented SubscribeValueCHROMIUM.";
1559 }
1560 void MojoGLES2Impl::PopulateSubscribedValuesCHROMIUM(GLenum target) {
1561   NOTREACHED() << "Unimplemented PopulateSubscribedValuesCHROMIUM.";
1562 }
1563 void MojoGLES2Impl::UniformValuebufferCHROMIUM(GLint location,
1564                                                GLenum target,
1565                                                GLenum subscription) {
1566   NOTREACHED() << "Unimplemented UniformValuebufferCHROMIUM.";
1567 }
1568 void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1569   MojoGLES2MakeCurrent(context_);
1570   glBindTexImage2DCHROMIUM(target, imageId);
1571 }
1572 void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1573   MojoGLES2MakeCurrent(context_);
1574   glReleaseTexImage2DCHROMIUM(target, imageId);
1575 }
1576 void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
1577                                        const char* trace_name) {
1578   NOTREACHED() << "Unimplemented TraceBeginCHROMIUM.";
1579 }
1580 void MojoGLES2Impl::TraceEndCHROMIUM() {
1581   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
1582 }
1583 void MojoGLES2Impl::AsyncTexSubImage2DCHROMIUM(GLenum target,
1584                                                GLint level,
1585                                                GLint xoffset,
1586                                                GLint yoffset,
1587                                                GLsizei width,
1588                                                GLsizei height,
1589                                                GLenum format,
1590                                                GLenum type,
1591                                                const void* data) {
1592   NOTREACHED() << "Unimplemented AsyncTexSubImage2DCHROMIUM.";
1593 }
1594 void MojoGLES2Impl::AsyncTexImage2DCHROMIUM(GLenum target,
1595                                             GLint level,
1596                                             GLenum internalformat,
1597                                             GLsizei width,
1598                                             GLsizei height,
1599                                             GLint border,
1600                                             GLenum format,
1601                                             GLenum type,
1602                                             const void* pixels) {
1603   NOTREACHED() << "Unimplemented AsyncTexImage2DCHROMIUM.";
1604 }
1605 void MojoGLES2Impl::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1606   NOTREACHED() << "Unimplemented WaitAsyncTexImage2DCHROMIUM.";
1607 }
1608 void MojoGLES2Impl::WaitAllAsyncTexImage2DCHROMIUM() {
1609   NOTREACHED() << "Unimplemented WaitAllAsyncTexImage2DCHROMIUM.";
1610 }
1611 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
1612                                           GLsizei count,
1613                                           const GLenum* attachments) {
1614   NOTREACHED() << "Unimplemented DiscardFramebufferEXT.";
1615 }
1616 void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
1617   NOTREACHED() << "Unimplemented LoseContextCHROMIUM.";
1618 }
1619 GLuint MojoGLES2Impl::InsertSyncPointCHROMIUM() {
1620   MojoGLES2MakeCurrent(context_);
1621   return glInsertSyncPointCHROMIUM();
1622 }
1623 void MojoGLES2Impl::WaitSyncPointCHROMIUM(GLuint sync_point) {
1624   MojoGLES2MakeCurrent(context_);
1625   glWaitSyncPointCHROMIUM(sync_point);
1626 }
1627 void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1628   NOTREACHED() << "Unimplemented DrawBuffersEXT.";
1629 }
1630 void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
1631   NOTREACHED() << "Unimplemented DiscardBackbufferCHROMIUM.";
1632 }
1633 void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1634                                                  GLenum plane_transform,
1635                                                  GLuint overlay_texture_id,
1636                                                  GLint bounds_x,
1637                                                  GLint bounds_y,
1638                                                  GLint bounds_width,
1639                                                  GLint bounds_height,
1640                                                  GLfloat uv_x,
1641                                                  GLfloat uv_y,
1642                                                  GLfloat uv_width,
1643                                                  GLfloat uv_height) {
1644   NOTREACHED() << "Unimplemented ScheduleOverlayPlaneCHROMIUM.";
1645 }
1646 void MojoGLES2Impl::SwapInterval(GLint interval) {
1647   NOTREACHED() << "Unimplemented SwapInterval.";
1648 }
1649 void MojoGLES2Impl::FlushDriverCachesCHROMIUM() {
1650   NOTREACHED() << "Unimplemented FlushDriverCachesCHROMIUM.";
1651 }
1652 void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1653   NOTREACHED() << "Unimplemented MatrixLoadfCHROMIUM.";
1654 }
1655 void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1656   NOTREACHED() << "Unimplemented MatrixLoadIdentityCHROMIUM.";
1657 }
1658 GLuint MojoGLES2Impl::GenPathsCHROMIUM(GLsizei range) {
1659   NOTREACHED() << "Unimplemented GenPathsCHROMIUM.";
1660   return 0;
1661 }
1662 void MojoGLES2Impl::DeletePathsCHROMIUM(GLuint path, GLsizei range) {
1663   NOTREACHED() << "Unimplemented DeletePathsCHROMIUM.";
1664 }
1665 GLboolean MojoGLES2Impl::IsPathCHROMIUM(GLuint path) {
1666   NOTREACHED() << "Unimplemented IsPathCHROMIUM.";
1667   return 0;
1668 }
1669 void MojoGLES2Impl::PathCommandsCHROMIUM(GLuint path,
1670                                          GLsizei numCommands,
1671                                          const GLubyte* commands,
1672                                          GLsizei numCoords,
1673                                          GLenum coordType,
1674                                          const GLvoid* coords) {
1675   NOTREACHED() << "Unimplemented PathCommandsCHROMIUM.";
1676 }
1677 void MojoGLES2Impl::PathParameterfCHROMIUM(GLuint path,
1678                                            GLenum pname,
1679                                            GLfloat value) {
1680   NOTREACHED() << "Unimplemented PathParameterfCHROMIUM.";
1681 }
1682 void MojoGLES2Impl::PathParameteriCHROMIUM(GLuint path,
1683                                            GLenum pname,
1684                                            GLint value) {
1685   NOTREACHED() << "Unimplemented PathParameteriCHROMIUM.";
1686 }
1687 void MojoGLES2Impl::PathStencilFuncCHROMIUM(GLenum func,
1688                                             GLint ref,
1689                                             GLuint mask) {
1690   NOTREACHED() << "Unimplemented PathStencilFuncCHROMIUM.";
1691 }
1692 void MojoGLES2Impl::StencilFillPathCHROMIUM(GLuint path,
1693                                             GLenum fillMode,
1694                                             GLuint mask) {
1695   NOTREACHED() << "Unimplemented StencilFillPathCHROMIUM.";
1696 }
1697 void MojoGLES2Impl::StencilStrokePathCHROMIUM(GLuint path,
1698                                               GLint reference,
1699                                               GLuint mask) {
1700   NOTREACHED() << "Unimplemented StencilStrokePathCHROMIUM.";
1701 }
1702 void MojoGLES2Impl::CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
1703   NOTREACHED() << "Unimplemented CoverFillPathCHROMIUM.";
1704 }
1705 void MojoGLES2Impl::CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
1706   NOTREACHED() << "Unimplemented CoverStrokePathCHROMIUM.";
1707 }
1708 void MojoGLES2Impl::StencilThenCoverFillPathCHROMIUM(GLuint path,
1709                                                      GLenum fillMode,
1710                                                      GLuint mask,
1711                                                      GLenum coverMode) {
1712   NOTREACHED() << "Unimplemented StencilThenCoverFillPathCHROMIUM.";
1713 }
1714 void MojoGLES2Impl::StencilThenCoverStrokePathCHROMIUM(GLuint path,
1715                                                        GLint reference,
1716                                                        GLuint mask,
1717                                                        GLenum coverMode) {
1718   NOTREACHED() << "Unimplemented StencilThenCoverStrokePathCHROMIUM.";
1719 }
1720 GLenum MojoGLES2Impl::GetGraphicsResetStatusKHR() {
1721   NOTREACHED() << "Unimplemented GetGraphicsResetStatusKHR.";
1722   return 0;
1723 }
1724 void MojoGLES2Impl::BlendBarrierKHR() {
1725   NOTREACHED() << "Unimplemented BlendBarrierKHR.";
1726 }
1727
1728 }  // namespace mojo