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::GetBufferParameteriv(GLenum target,
 481                                          GLenum pname,
 482                                          GLint* params) {
 483   MojoGLES2MakeCurrent(context_);
 484   glGetBufferParameteriv(target, pname, params);
 485 }
 486 GLenum MojoGLES2Impl::GetError() {
 487   MojoGLES2MakeCurrent(context_);
 488   return glGetError();
 489 }
 490 void MojoGLES2Impl::GetFloatv(GLenum pname, GLfloat* params) {
 491   MojoGLES2MakeCurrent(context_);
 492   glGetFloatv(pname, params);
 493 }
 494 GLint MojoGLES2Impl::GetFragDataLocation(GLuint program, const char* name) {
 495   NOTREACHED() << "Unimplemented GetFragDataLocation.";
 496   return 0;
 497 }
 498 void MojoGLES2Impl::GetFramebufferAttachmentParameteriv(GLenum target,
 499                                                         GLenum attachment,
 500                                                         GLenum pname,
 501                                                         GLint* params) {
 502   MojoGLES2MakeCurrent(context_);
 503   glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 504 }
 505 void MojoGLES2Impl::GetInteger64v(GLenum pname, GLint64* params) {
 506   NOTREACHED() << "Unimplemented GetInteger64v.";
 507 }
 508 void MojoGLES2Impl::GetIntegeri_v(GLenum pname, GLuint index, GLint* data) {
 509   NOTREACHED() << "Unimplemented GetIntegeri_v.";
 510 }
 511 void MojoGLES2Impl::GetInteger64i_v(GLenum pname, GLuint index, GLint64* data) {
 512   NOTREACHED() << "Unimplemented GetInteger64i_v.";
 513 }
 514 void MojoGLES2Impl::GetIntegerv(GLenum pname, GLint* params) {
 515   MojoGLES2MakeCurrent(context_);
 516   glGetIntegerv(pname, params);
 517 }
 518 void MojoGLES2Impl::GetInternalformativ(GLenum target,
 519                                         GLenum format,
 520                                         GLenum pname,
 521                                         GLsizei bufSize,
 522                                         GLint* params) {
 523   NOTREACHED() << "Unimplemented GetInternalformativ.";
 524 }
 525 void MojoGLES2Impl::GetProgramiv(GLuint program, GLenum pname, GLint* params) {
 526   MojoGLES2MakeCurrent(context_);
 527   glGetProgramiv(program, pname, params);
 528 }
 529 void MojoGLES2Impl::GetProgramInfoLog(GLuint program,
 530                                       GLsizei bufsize,
 531                                       GLsizei* length,
 532                                       char* infolog) {
 533   MojoGLES2MakeCurrent(context_);
 534   glGetProgramInfoLog(program, bufsize, length, infolog);
 535 }
 536 void MojoGLES2Impl::GetRenderbufferParameteriv(GLenum target,
 537                                                GLenum pname,
 538                                                GLint* params) {
 539   MojoGLES2MakeCurrent(context_);
 540   glGetRenderbufferParameteriv(target, pname, params);
 541 }
 542 void MojoGLES2Impl::GetSamplerParameterfv(GLuint sampler,
 543                                           GLenum pname,
 544                                           GLfloat* params) {
 545   NOTREACHED() << "Unimplemented GetSamplerParameterfv.";
 546 }
 547 void MojoGLES2Impl::GetSamplerParameteriv(GLuint sampler,
 548                                           GLenum pname,
 549                                           GLint* params) {
 550   NOTREACHED() << "Unimplemented GetSamplerParameteriv.";
 551 }
 552 void MojoGLES2Impl::GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 553   MojoGLES2MakeCurrent(context_);
 554   glGetShaderiv(shader, pname, params);
 555 }
 556 void MojoGLES2Impl::GetShaderInfoLog(GLuint shader,
 557                                      GLsizei bufsize,
 558                                      GLsizei* length,
 559                                      char* infolog) {
 560   MojoGLES2MakeCurrent(context_);
 561   glGetShaderInfoLog(shader, bufsize, length, infolog);
 562 }
 563 void MojoGLES2Impl::GetShaderPrecisionFormat(GLenum shadertype,
 564                                              GLenum precisiontype,
 565                                              GLint* range,
 566                                              GLint* precision) {
 567   MojoGLES2MakeCurrent(context_);
 568   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 569 }
 570 void MojoGLES2Impl::GetShaderSource(GLuint shader,
 571                                     GLsizei bufsize,
 572                                     GLsizei* length,
 573                                     char* source) {
 574   MojoGLES2MakeCurrent(context_);
 575   glGetShaderSource(shader, bufsize, length, source);
 576 }
 577 const GLubyte* MojoGLES2Impl::GetString(GLenum name) {
 578   MojoGLES2MakeCurrent(context_);
 579   return glGetString(name);
 580 }
 581 void MojoGLES2Impl::GetSynciv(GLsync sync,
 582                               GLenum pname,
 583                               GLsizei bufsize,
 584                               GLsizei* length,
 585                               GLint* values) {
 586   NOTREACHED() << "Unimplemented GetSynciv.";
 587 }
 588 void MojoGLES2Impl::GetTexParameterfv(GLenum target,
 589                                       GLenum pname,
 590                                       GLfloat* params) {
 591   MojoGLES2MakeCurrent(context_);
 592   glGetTexParameterfv(target, pname, params);
 593 }
 594 void MojoGLES2Impl::GetTexParameteriv(GLenum target,
 595                                       GLenum pname,
 596                                       GLint* params) {
 597   MojoGLES2MakeCurrent(context_);
 598   glGetTexParameteriv(target, pname, params);
 599 }
 600 void MojoGLES2Impl::GetTransformFeedbackVarying(GLuint program,
 601                                                 GLuint index,
 602                                                 GLsizei bufsize,
 603                                                 GLsizei* length,
 604                                                 GLsizei* size,
 605                                                 GLenum* type,
 606                                                 char* name) {
 607   NOTREACHED() << "Unimplemented GetTransformFeedbackVarying.";
 608 }
 609 GLuint MojoGLES2Impl::GetUniformBlockIndex(GLuint program, const char* name) {
 610   NOTREACHED() << "Unimplemented GetUniformBlockIndex.";
 611   return 0;
 612 }
 613 void MojoGLES2Impl::GetUniformfv(GLuint program,
 614                                  GLint location,
 615                                  GLfloat* params) {
 616   MojoGLES2MakeCurrent(context_);
 617   glGetUniformfv(program, location, params);
 618 }
 619 void MojoGLES2Impl::GetUniformiv(GLuint program,
 620                                  GLint location,
 621                                  GLint* params) {
 622   MojoGLES2MakeCurrent(context_);
 623   glGetUniformiv(program, location, params);
 624 }
 625 void MojoGLES2Impl::GetUniformuiv(GLuint program,
 626                                   GLint location,
 627                                   GLuint* params) {
 628   NOTREACHED() << "Unimplemented GetUniformuiv.";
 629 }
 630 void MojoGLES2Impl::GetUniformIndices(GLuint program,
 631                                       GLsizei count,
 632                                       const char* const* names,
 633                                       GLuint* indices) {
 634   NOTREACHED() << "Unimplemented GetUniformIndices.";
 635 }
 636 GLint MojoGLES2Impl::GetUniformLocation(GLuint program, const char* name) {
 637   MojoGLES2MakeCurrent(context_);
 638   return glGetUniformLocation(program, name);
 639 }
 640 void MojoGLES2Impl::GetVertexAttribfv(GLuint index,
 641                                       GLenum pname,
 642                                       GLfloat* params) {
 643   MojoGLES2MakeCurrent(context_);
 644   glGetVertexAttribfv(index, pname, params);
 645 }
 646 void MojoGLES2Impl::GetVertexAttribiv(GLuint index,
 647                                       GLenum pname,
 648                                       GLint* params) {
 649   MojoGLES2MakeCurrent(context_);
 650   glGetVertexAttribiv(index, pname, params);
 651 }
 652 void MojoGLES2Impl::GetVertexAttribIiv(GLuint index,
 653                                        GLenum pname,
 654                                        GLint* params) {
 655   NOTREACHED() << "Unimplemented GetVertexAttribIiv.";
 656 }
 657 void MojoGLES2Impl::GetVertexAttribIuiv(GLuint index,
 658                                         GLenum pname,
 659                                         GLuint* params) {
 660   NOTREACHED() << "Unimplemented GetVertexAttribIuiv.";
 661 }
 662 void MojoGLES2Impl::GetVertexAttribPointerv(GLuint index,
 663                                             GLenum pname,
 664                                             void** pointer) {
 665   MojoGLES2MakeCurrent(context_);
 666   glGetVertexAttribPointerv(index, pname, pointer);
 667 }
 668 void MojoGLES2Impl::Hint(GLenum target, GLenum mode) {
 669   MojoGLES2MakeCurrent(context_);
 670   glHint(target, mode);
 671 }
 672 void MojoGLES2Impl::InvalidateFramebuffer(GLenum target,
 673                                           GLsizei count,
 674                                           const GLenum* attachments) {
 675   NOTREACHED() << "Unimplemented InvalidateFramebuffer.";
 676 }
 677 void MojoGLES2Impl::InvalidateSubFramebuffer(GLenum target,
 678                                              GLsizei count,
 679                                              const GLenum* attachments,
 680                                              GLint x,
 681                                              GLint y,
 682                                              GLsizei width,
 683                                              GLsizei height) {
 684   NOTREACHED() << "Unimplemented InvalidateSubFramebuffer.";
 685 }
 686 GLboolean MojoGLES2Impl::IsBuffer(GLuint buffer) {
 687   MojoGLES2MakeCurrent(context_);
 688   return glIsBuffer(buffer);
 689 }
 690 GLboolean MojoGLES2Impl::IsEnabled(GLenum cap) {
 691   MojoGLES2MakeCurrent(context_);
 692   return glIsEnabled(cap);
 693 }
 694 GLboolean MojoGLES2Impl::IsFramebuffer(GLuint framebuffer) {
 695   MojoGLES2MakeCurrent(context_);
 696   return glIsFramebuffer(framebuffer);
 697 }
 698 GLboolean MojoGLES2Impl::IsProgram(GLuint program) {
 699   MojoGLES2MakeCurrent(context_);
 700   return glIsProgram(program);
 701 }
 702 GLboolean MojoGLES2Impl::IsRenderbuffer(GLuint renderbuffer) {
 703   MojoGLES2MakeCurrent(context_);
 704   return glIsRenderbuffer(renderbuffer);
 705 }
 706 GLboolean MojoGLES2Impl::IsSampler(GLuint sampler) {
 707   NOTREACHED() << "Unimplemented IsSampler.";
 708   return 0;
 709 }
 710 GLboolean MojoGLES2Impl::IsShader(GLuint shader) {
 711   MojoGLES2MakeCurrent(context_);
 712   return glIsShader(shader);
 713 }
 714 GLboolean MojoGLES2Impl::IsSync(GLsync sync) {
 715   NOTREACHED() << "Unimplemented IsSync.";
 716   return 0;
 717 }
 718 GLboolean MojoGLES2Impl::IsTexture(GLuint texture) {
 719   MojoGLES2MakeCurrent(context_);
 720   return glIsTexture(texture);
 721 }
 722 GLboolean MojoGLES2Impl::IsTransformFeedback(GLuint transformfeedback) {
 723   NOTREACHED() << "Unimplemented IsTransformFeedback.";
 724   return 0;
 725 }
 726 void MojoGLES2Impl::LineWidth(GLfloat width) {
 727   MojoGLES2MakeCurrent(context_);
 728   glLineWidth(width);
 729 }
 730 void MojoGLES2Impl::LinkProgram(GLuint program) {
 731   MojoGLES2MakeCurrent(context_);
 732   glLinkProgram(program);
 733 }
 734 void MojoGLES2Impl::PauseTransformFeedback() {
 735   NOTREACHED() << "Unimplemented PauseTransformFeedback.";
 736 }
 737 void MojoGLES2Impl::PixelStorei(GLenum pname, GLint param) {
 738   MojoGLES2MakeCurrent(context_);
 739   glPixelStorei(pname, param);
 740 }
 741 void MojoGLES2Impl::PolygonOffset(GLfloat factor, GLfloat units) {
 742   MojoGLES2MakeCurrent(context_);
 743   glPolygonOffset(factor, units);
 744 }
 745 void MojoGLES2Impl::ReadBuffer(GLenum src) {
 746   NOTREACHED() << "Unimplemented ReadBuffer.";
 747 }
 748 void MojoGLES2Impl::ReadPixels(GLint x,
 749                                GLint y,
 750                                GLsizei width,
 751                                GLsizei height,
 752                                GLenum format,
 753                                GLenum type,
 754                                void* pixels) {
 755   MojoGLES2MakeCurrent(context_);
 756   glReadPixels(x, y, width, height, format, type, pixels);
 757 }
 758 void MojoGLES2Impl::ReleaseShaderCompiler() {
 759   MojoGLES2MakeCurrent(context_);
 760   glReleaseShaderCompiler();
 761 }
 762 void MojoGLES2Impl::RenderbufferStorage(GLenum target,
 763                                         GLenum internalformat,
 764                                         GLsizei width,
 765                                         GLsizei height) {
 766   MojoGLES2MakeCurrent(context_);
 767   glRenderbufferStorage(target, internalformat, width, height);
 768 }
 769 void MojoGLES2Impl::ResumeTransformFeedback() {
 770   NOTREACHED() << "Unimplemented ResumeTransformFeedback.";
 771 }
 772 void MojoGLES2Impl::SampleCoverage(GLclampf value, GLboolean invert) {
 773   MojoGLES2MakeCurrent(context_);
 774   glSampleCoverage(value, invert);
 775 }
 776 void MojoGLES2Impl::SamplerParameterf(GLuint sampler,
 777                                       GLenum pname,
 778                                       GLfloat param) {
 779   NOTREACHED() << "Unimplemented SamplerParameterf.";
 780 }
 781 void MojoGLES2Impl::SamplerParameterfv(GLuint sampler,
 782                                        GLenum pname,
 783                                        const GLfloat* params) {
 784   NOTREACHED() << "Unimplemented SamplerParameterfv.";
 785 }
 786 void MojoGLES2Impl::SamplerParameteri(GLuint sampler,
 787                                       GLenum pname,
 788                                       GLint param) {
 789   NOTREACHED() << "Unimplemented SamplerParameteri.";
 790 }
 791 void MojoGLES2Impl::SamplerParameteriv(GLuint sampler,
 792                                        GLenum pname,
 793                                        const GLint* params) {
 794   NOTREACHED() << "Unimplemented SamplerParameteriv.";
 795 }
 796 void MojoGLES2Impl::Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 797   MojoGLES2MakeCurrent(context_);
 798   glScissor(x, y, width, height);
 799 }
 800 void MojoGLES2Impl::ShaderBinary(GLsizei n,
 801                                  const GLuint* shaders,
 802                                  GLenum binaryformat,
 803                                  const void* binary,
 804                                  GLsizei length) {
 805   MojoGLES2MakeCurrent(context_);
 806   glShaderBinary(n, shaders, binaryformat, binary, length);
 807 }
 808 void MojoGLES2Impl::ShaderSource(GLuint shader,
 809                                  GLsizei count,
 810                                  const GLchar* const* str,
 811                                  const GLint* length) {
 812   MojoGLES2MakeCurrent(context_);
 813   glShaderSource(shader, count, str, length);
 814 }
 815 void MojoGLES2Impl::ShallowFinishCHROMIUM() {
 816   NOTREACHED() << "Unimplemented ShallowFinishCHROMIUM.";
 817 }
 818 void MojoGLES2Impl::ShallowFlushCHROMIUM() {
 819   MojoGLES2MakeCurrent(context_);
 820   glShallowFlushCHROMIUM();
 821 }
 822 void MojoGLES2Impl::OrderingBarrierCHROMIUM() {
 823   NOTREACHED() << "Unimplemented OrderingBarrierCHROMIUM.";
 824 }
 825 void MojoGLES2Impl::StencilFunc(GLenum func, GLint ref, GLuint mask) {
 826   MojoGLES2MakeCurrent(context_);
 827   glStencilFunc(func, ref, mask);
 828 }
 829 void MojoGLES2Impl::StencilFuncSeparate(GLenum face,
 830                                         GLenum func,
 831                                         GLint ref,
 832                                         GLuint mask) {
 833   MojoGLES2MakeCurrent(context_);
 834   glStencilFuncSeparate(face, func, ref, mask);
 835 }
 836 void MojoGLES2Impl::StencilMask(GLuint mask) {
 837   MojoGLES2MakeCurrent(context_);
 838   glStencilMask(mask);
 839 }
 840 void MojoGLES2Impl::StencilMaskSeparate(GLenum face, GLuint mask) {
 841   MojoGLES2MakeCurrent(context_);
 842   glStencilMaskSeparate(face, mask);
 843 }
 844 void MojoGLES2Impl::StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 845   MojoGLES2MakeCurrent(context_);
 846   glStencilOp(fail, zfail, zpass);
 847 }
 848 void MojoGLES2Impl::StencilOpSeparate(GLenum face,
 849                                       GLenum fail,
 850                                       GLenum zfail,
 851                                       GLenum zpass) {
 852   MojoGLES2MakeCurrent(context_);
 853   glStencilOpSeparate(face, fail, zfail, zpass);
 854 }
 855 void MojoGLES2Impl::TexImage2D(GLenum target,
 856                                GLint level,
 857                                GLint internalformat,
 858                                GLsizei width,
 859                                GLsizei height,
 860                                GLint border,
 861                                GLenum format,
 862                                GLenum type,
 863                                const void* pixels) {
 864   MojoGLES2MakeCurrent(context_);
 865   glTexImage2D(target, level, internalformat, width, height, border, format,
 866                type, pixels);
 867 }
 868 void MojoGLES2Impl::TexImage3D(GLenum target,
 869                                GLint level,
 870                                GLint internalformat,
 871                                GLsizei width,
 872                                GLsizei height,
 873                                GLsizei depth,
 874                                GLint border,
 875                                GLenum format,
 876                                GLenum type,
 877                                const void* pixels) {
 878   NOTREACHED() << "Unimplemented TexImage3D.";
 879 }
 880 void MojoGLES2Impl::TexParameterf(GLenum target, GLenum pname, GLfloat param) {
 881   MojoGLES2MakeCurrent(context_);
 882   glTexParameterf(target, pname, param);
 883 }
 884 void MojoGLES2Impl::TexParameterfv(GLenum target,
 885                                    GLenum pname,
 886                                    const GLfloat* params) {
 887   MojoGLES2MakeCurrent(context_);
 888   glTexParameterfv(target, pname, params);
 889 }
 890 void MojoGLES2Impl::TexParameteri(GLenum target, GLenum pname, GLint param) {
 891   MojoGLES2MakeCurrent(context_);
 892   glTexParameteri(target, pname, param);
 893 }
 894 void MojoGLES2Impl::TexParameteriv(GLenum target,
 895                                    GLenum pname,
 896                                    const GLint* params) {
 897   MojoGLES2MakeCurrent(context_);
 898   glTexParameteriv(target, pname, params);
 899 }
 900 void MojoGLES2Impl::TexStorage3D(GLenum target,
 901                                  GLsizei levels,
 902                                  GLenum internalFormat,
 903                                  GLsizei width,
 904                                  GLsizei height,
 905                                  GLsizei depth) {
 906   NOTREACHED() << "Unimplemented TexStorage3D.";
 907 }
 908 void MojoGLES2Impl::TexSubImage2D(GLenum target,
 909                                   GLint level,
 910                                   GLint xoffset,
 911                                   GLint yoffset,
 912                                   GLsizei width,
 913                                   GLsizei height,
 914                                   GLenum format,
 915                                   GLenum type,
 916                                   const void* pixels) {
 917   MojoGLES2MakeCurrent(context_);
 918   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
 919                   pixels);
 920 }
 921 void MojoGLES2Impl::TexSubImage3D(GLenum target,
 922                                   GLint level,
 923                                   GLint xoffset,
 924                                   GLint yoffset,
 925                                   GLint zoffset,
 926                                   GLsizei width,
 927                                   GLsizei height,
 928                                   GLsizei depth,
 929                                   GLenum format,
 930                                   GLenum type,
 931                                   const void* pixels) {
 932   NOTREACHED() << "Unimplemented TexSubImage3D.";
 933 }
 934 void MojoGLES2Impl::TransformFeedbackVaryings(GLuint program,
 935                                               GLsizei count,
 936                                               const char* const* varyings,
 937                                               GLenum buffermode) {
 938   NOTREACHED() << "Unimplemented TransformFeedbackVaryings.";
 939 }
 940 void MojoGLES2Impl::Uniform1f(GLint location, GLfloat x) {
 941   MojoGLES2MakeCurrent(context_);
 942   glUniform1f(location, x);
 943 }
 944 void MojoGLES2Impl::Uniform1fv(GLint location,
 945                                GLsizei count,
 946                                const GLfloat* v) {
 947   MojoGLES2MakeCurrent(context_);
 948   glUniform1fv(location, count, v);
 949 }
 950 void MojoGLES2Impl::Uniform1i(GLint location, GLint x) {
 951   MojoGLES2MakeCurrent(context_);
 952   glUniform1i(location, x);
 953 }
 954 void MojoGLES2Impl::Uniform1iv(GLint location, GLsizei count, const GLint* v) {
 955   MojoGLES2MakeCurrent(context_);
 956   glUniform1iv(location, count, v);
 957 }
 958 void MojoGLES2Impl::Uniform1ui(GLint location, GLuint x) {
 959   NOTREACHED() << "Unimplemented Uniform1ui.";
 960 }
 961 void MojoGLES2Impl::Uniform1uiv(GLint location,
 962                                 GLsizei count,
 963                                 const GLuint* v) {
 964   NOTREACHED() << "Unimplemented Uniform1uiv.";
 965 }
 966 void MojoGLES2Impl::Uniform2f(GLint location, GLfloat x, GLfloat y) {
 967   MojoGLES2MakeCurrent(context_);
 968   glUniform2f(location, x, y);
 969 }
 970 void MojoGLES2Impl::Uniform2fv(GLint location,
 971                                GLsizei count,
 972                                const GLfloat* v) {
 973   MojoGLES2MakeCurrent(context_);
 974   glUniform2fv(location, count, v);
 975 }
 976 void MojoGLES2Impl::Uniform2i(GLint location, GLint x, GLint y) {
 977   MojoGLES2MakeCurrent(context_);
 978   glUniform2i(location, x, y);
 979 }
 980 void MojoGLES2Impl::Uniform2iv(GLint location, GLsizei count, const GLint* v) {
 981   MojoGLES2MakeCurrent(context_);
 982   glUniform2iv(location, count, v);
 983 }
 984 void MojoGLES2Impl::Uniform2ui(GLint location, GLuint x, GLuint y) {
 985   NOTREACHED() << "Unimplemented Uniform2ui.";
 986 }
 987 void MojoGLES2Impl::Uniform2uiv(GLint location,
 988                                 GLsizei count,
 989                                 const GLuint* v) {
 990   NOTREACHED() << "Unimplemented Uniform2uiv.";
 991 }
 992 void MojoGLES2Impl::Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 993   MojoGLES2MakeCurrent(context_);
 994   glUniform3f(location, x, y, z);
 995 }
 996 void MojoGLES2Impl::Uniform3fv(GLint location,
 997                                GLsizei count,
 998                                const GLfloat* v) {
 999   MojoGLES2MakeCurrent(context_);
1000   glUniform3fv(location, count, v);
1001 }
1002 void MojoGLES2Impl::Uniform3i(GLint location, GLint x, GLint y, GLint z) {
1003   MojoGLES2MakeCurrent(context_);
1004   glUniform3i(location, x, y, z);
1005 }
1006 void MojoGLES2Impl::Uniform3iv(GLint location, GLsizei count, const GLint* v) {
1007   MojoGLES2MakeCurrent(context_);
1008   glUniform3iv(location, count, v);
1009 }
1010 void MojoGLES2Impl::Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
1011   NOTREACHED() << "Unimplemented Uniform3ui.";
1012 }
1013 void MojoGLES2Impl::Uniform3uiv(GLint location,
1014                                 GLsizei count,
1015                                 const GLuint* v) {
1016   NOTREACHED() << "Unimplemented Uniform3uiv.";
1017 }
1018 void MojoGLES2Impl::Uniform4f(GLint location,
1019                               GLfloat x,
1020                               GLfloat y,
1021                               GLfloat z,
1022                               GLfloat w) {
1023   MojoGLES2MakeCurrent(context_);
1024   glUniform4f(location, x, y, z, w);
1025 }
1026 void MojoGLES2Impl::Uniform4fv(GLint location,
1027                                GLsizei count,
1028                                const GLfloat* v) {
1029   MojoGLES2MakeCurrent(context_);
1030   glUniform4fv(location, count, v);
1031 }
1032 void MojoGLES2Impl::Uniform4i(GLint location,
1033                               GLint x,
1034                               GLint y,
1035                               GLint z,
1036                               GLint w) {
1037   MojoGLES2MakeCurrent(context_);
1038   glUniform4i(location, x, y, z, w);
1039 }
1040 void MojoGLES2Impl::Uniform4iv(GLint location, GLsizei count, const GLint* v) {
1041   MojoGLES2MakeCurrent(context_);
1042   glUniform4iv(location, count, v);
1043 }
1044 void MojoGLES2Impl::Uniform4ui(GLint location,
1045                                GLuint x,
1046                                GLuint y,
1047                                GLuint z,
1048                                GLuint w) {
1049   NOTREACHED() << "Unimplemented Uniform4ui.";
1050 }
1051 void MojoGLES2Impl::Uniform4uiv(GLint location,
1052                                 GLsizei count,
1053                                 const GLuint* v) {
1054   NOTREACHED() << "Unimplemented Uniform4uiv.";
1055 }
1056 void MojoGLES2Impl::UniformBlockBinding(GLuint program,
1057                                         GLuint index,
1058                                         GLuint binding) {
1059   NOTREACHED() << "Unimplemented UniformBlockBinding.";
1060 }
1061 void MojoGLES2Impl::UniformMatrix2fv(GLint location,
1062                                      GLsizei count,
1063                                      GLboolean transpose,
1064                                      const GLfloat* value) {
1065   MojoGLES2MakeCurrent(context_);
1066   glUniformMatrix2fv(location, count, transpose, value);
1067 }
1068 void MojoGLES2Impl::UniformMatrix2x3fv(GLint location,
1069                                        GLsizei count,
1070                                        GLboolean transpose,
1071                                        const GLfloat* value) {
1072   NOTREACHED() << "Unimplemented UniformMatrix2x3fv.";
1073 }
1074 void MojoGLES2Impl::UniformMatrix2x4fv(GLint location,
1075                                        GLsizei count,
1076                                        GLboolean transpose,
1077                                        const GLfloat* value) {
1078   NOTREACHED() << "Unimplemented UniformMatrix2x4fv.";
1079 }
1080 void MojoGLES2Impl::UniformMatrix3fv(GLint location,
1081                                      GLsizei count,
1082                                      GLboolean transpose,
1083                                      const GLfloat* value) {
1084   MojoGLES2MakeCurrent(context_);
1085   glUniformMatrix3fv(location, count, transpose, value);
1086 }
1087 void MojoGLES2Impl::UniformMatrix3x2fv(GLint location,
1088                                        GLsizei count,
1089                                        GLboolean transpose,
1090                                        const GLfloat* value) {
1091   NOTREACHED() << "Unimplemented UniformMatrix3x2fv.";
1092 }
1093 void MojoGLES2Impl::UniformMatrix3x4fv(GLint location,
1094                                        GLsizei count,
1095                                        GLboolean transpose,
1096                                        const GLfloat* value) {
1097   NOTREACHED() << "Unimplemented UniformMatrix3x4fv.";
1098 }
1099 void MojoGLES2Impl::UniformMatrix4fv(GLint location,
1100                                      GLsizei count,
1101                                      GLboolean transpose,
1102                                      const GLfloat* value) {
1103   MojoGLES2MakeCurrent(context_);
1104   glUniformMatrix4fv(location, count, transpose, value);
1105 }
1106 void MojoGLES2Impl::UniformMatrix4x2fv(GLint location,
1107                                        GLsizei count,
1108                                        GLboolean transpose,
1109                                        const GLfloat* value) {
1110   NOTREACHED() << "Unimplemented UniformMatrix4x2fv.";
1111 }
1112 void MojoGLES2Impl::UniformMatrix4x3fv(GLint location,
1113                                        GLsizei count,
1114                                        GLboolean transpose,
1115                                        const GLfloat* value) {
1116   NOTREACHED() << "Unimplemented UniformMatrix4x3fv.";
1117 }
1118 void MojoGLES2Impl::UseProgram(GLuint program) {
1119   MojoGLES2MakeCurrent(context_);
1120   glUseProgram(program);
1121 }
1122 void MojoGLES2Impl::ValidateProgram(GLuint program) {
1123   MojoGLES2MakeCurrent(context_);
1124   glValidateProgram(program);
1125 }
1126 void MojoGLES2Impl::VertexAttrib1f(GLuint indx, GLfloat x) {
1127   MojoGLES2MakeCurrent(context_);
1128   glVertexAttrib1f(indx, x);
1129 }
1130 void MojoGLES2Impl::VertexAttrib1fv(GLuint indx, const GLfloat* values) {
1131   MojoGLES2MakeCurrent(context_);
1132   glVertexAttrib1fv(indx, values);
1133 }
1134 void MojoGLES2Impl::VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
1135   MojoGLES2MakeCurrent(context_);
1136   glVertexAttrib2f(indx, x, y);
1137 }
1138 void MojoGLES2Impl::VertexAttrib2fv(GLuint indx, const GLfloat* values) {
1139   MojoGLES2MakeCurrent(context_);
1140   glVertexAttrib2fv(indx, values);
1141 }
1142 void MojoGLES2Impl::VertexAttrib3f(GLuint indx,
1143                                    GLfloat x,
1144                                    GLfloat y,
1145                                    GLfloat z) {
1146   MojoGLES2MakeCurrent(context_);
1147   glVertexAttrib3f(indx, x, y, z);
1148 }
1149 void MojoGLES2Impl::VertexAttrib3fv(GLuint indx, const GLfloat* values) {
1150   MojoGLES2MakeCurrent(context_);
1151   glVertexAttrib3fv(indx, values);
1152 }
1153 void MojoGLES2Impl::VertexAttrib4f(GLuint indx,
1154                                    GLfloat x,
1155                                    GLfloat y,
1156                                    GLfloat z,
1157                                    GLfloat w) {
1158   MojoGLES2MakeCurrent(context_);
1159   glVertexAttrib4f(indx, x, y, z, w);
1160 }
1161 void MojoGLES2Impl::VertexAttrib4fv(GLuint indx, const GLfloat* values) {
1162   MojoGLES2MakeCurrent(context_);
1163   glVertexAttrib4fv(indx, values);
1164 }
1165 void MojoGLES2Impl::VertexAttribI4i(GLuint indx,
1166                                     GLint x,
1167                                     GLint y,
1168                                     GLint z,
1169                                     GLint w) {
1170   NOTREACHED() << "Unimplemented VertexAttribI4i.";
1171 }
1172 void MojoGLES2Impl::VertexAttribI4iv(GLuint indx, const GLint* values) {
1173   NOTREACHED() << "Unimplemented VertexAttribI4iv.";
1174 }
1175 void MojoGLES2Impl::VertexAttribI4ui(GLuint indx,
1176                                      GLuint x,
1177                                      GLuint y,
1178                                      GLuint z,
1179                                      GLuint w) {
1180   NOTREACHED() << "Unimplemented VertexAttribI4ui.";
1181 }
1182 void MojoGLES2Impl::VertexAttribI4uiv(GLuint indx, const GLuint* values) {
1183   NOTREACHED() << "Unimplemented VertexAttribI4uiv.";
1184 }
1185 void MojoGLES2Impl::VertexAttribIPointer(GLuint indx,
1186                                          GLint size,
1187                                          GLenum type,
1188                                          GLsizei stride,
1189                                          const void* ptr) {
1190   NOTREACHED() << "Unimplemented VertexAttribIPointer.";
1191 }
1192 void MojoGLES2Impl::VertexAttribPointer(GLuint indx,
1193                                         GLint size,
1194                                         GLenum type,
1195                                         GLboolean normalized,
1196                                         GLsizei stride,
1197                                         const void* ptr) {
1198   MojoGLES2MakeCurrent(context_);
1199   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
1200 }
1201 void MojoGLES2Impl::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1202   MojoGLES2MakeCurrent(context_);
1203   glViewport(x, y, width, height);
1204 }
1205 void MojoGLES2Impl::WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
1206   NOTREACHED() << "Unimplemented WaitSync.";
1207 }
1208 void MojoGLES2Impl::BlitFramebufferCHROMIUM(GLint srcX0,
1209                                             GLint srcY0,
1210                                             GLint srcX1,
1211                                             GLint srcY1,
1212                                             GLint dstX0,
1213                                             GLint dstY0,
1214                                             GLint dstX1,
1215                                             GLint dstY1,
1216                                             GLbitfield mask,
1217                                             GLenum filter) {
1218   NOTREACHED() << "Unimplemented BlitFramebufferCHROMIUM.";
1219 }
1220 void MojoGLES2Impl::RenderbufferStorageMultisampleCHROMIUM(
1221     GLenum target,
1222     GLsizei samples,
1223     GLenum internalformat,
1224     GLsizei width,
1225     GLsizei height) {
1226   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleCHROMIUM.";
1227 }
1228 void MojoGLES2Impl::RenderbufferStorageMultisampleEXT(GLenum target,
1229                                                       GLsizei samples,
1230                                                       GLenum internalformat,
1231                                                       GLsizei width,
1232                                                       GLsizei height) {
1233   NOTREACHED() << "Unimplemented RenderbufferStorageMultisampleEXT.";
1234 }
1235 void MojoGLES2Impl::FramebufferTexture2DMultisampleEXT(GLenum target,
1236                                                        GLenum attachment,
1237                                                        GLenum textarget,
1238                                                        GLuint texture,
1239                                                        GLint level,
1240                                                        GLsizei samples) {
1241   NOTREACHED() << "Unimplemented FramebufferTexture2DMultisampleEXT.";
1242 }
1243 void MojoGLES2Impl::TexStorage2DEXT(GLenum target,
1244                                     GLsizei levels,
1245                                     GLenum internalFormat,
1246                                     GLsizei width,
1247                                     GLsizei height) {
1248   NOTREACHED() << "Unimplemented TexStorage2DEXT.";
1249 }
1250 void MojoGLES2Impl::GenQueriesEXT(GLsizei n, GLuint* queries) {
1251   MojoGLES2MakeCurrent(context_);
1252   glGenQueriesEXT(n, queries);
1253 }
1254 void MojoGLES2Impl::DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
1255   MojoGLES2MakeCurrent(context_);
1256   glDeleteQueriesEXT(n, queries);
1257 }
1258 void MojoGLES2Impl::QueryCounterEXT(GLuint id, GLenum target) {
1259   NOTREACHED() << "Unimplemented QueryCounterEXT.";
1260 }
1261 GLboolean MojoGLES2Impl::IsQueryEXT(GLuint id) {
1262   MojoGLES2MakeCurrent(context_);
1263   return glIsQueryEXT(id);
1264 }
1265 void MojoGLES2Impl::BeginQueryEXT(GLenum target, GLuint id) {
1266   MojoGLES2MakeCurrent(context_);
1267   glBeginQueryEXT(target, id);
1268 }
1269 void MojoGLES2Impl::BeginTransformFeedback(GLenum primitivemode) {
1270   NOTREACHED() << "Unimplemented BeginTransformFeedback.";
1271 }
1272 void MojoGLES2Impl::EndQueryEXT(GLenum target) {
1273   MojoGLES2MakeCurrent(context_);
1274   glEndQueryEXT(target);
1275 }
1276 void MojoGLES2Impl::EndTransformFeedback() {
1277   NOTREACHED() << "Unimplemented EndTransformFeedback.";
1278 }
1279 void MojoGLES2Impl::GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
1280   MojoGLES2MakeCurrent(context_);
1281   glGetQueryivEXT(target, pname, params);
1282 }
1283 void MojoGLES2Impl::GetQueryObjectuivEXT(GLuint id,
1284                                          GLenum pname,
1285                                          GLuint* params) {
1286   MojoGLES2MakeCurrent(context_);
1287   glGetQueryObjectuivEXT(id, pname, params);
1288 }
1289 void MojoGLES2Impl::GetQueryObjectui64vEXT(GLuint id,
1290                                            GLenum pname,
1291                                            GLuint64* params) {
1292   NOTREACHED() << "Unimplemented GetQueryObjectui64vEXT.";
1293 }
1294 void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1295   NOTREACHED() << "Unimplemented InsertEventMarkerEXT.";
1296 }
1297 void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1298   NOTREACHED() << "Unimplemented PushGroupMarkerEXT.";
1299 }
1300 void MojoGLES2Impl::PopGroupMarkerEXT() {
1301   NOTREACHED() << "Unimplemented PopGroupMarkerEXT.";
1302 }
1303 void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1304   NOTREACHED() << "Unimplemented GenVertexArraysOES.";
1305 }
1306 void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1307   NOTREACHED() << "Unimplemented DeleteVertexArraysOES.";
1308 }
1309 GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
1310   NOTREACHED() << "Unimplemented IsVertexArrayOES.";
1311   return 0;
1312 }
1313 void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
1314   NOTREACHED() << "Unimplemented BindVertexArrayOES.";
1315 }
1316 void MojoGLES2Impl::SwapBuffers() {
1317   NOTREACHED() << "Unimplemented SwapBuffers.";
1318 }
1319 GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1320                                                   GLsizei count,
1321                                                   GLenum type,
1322                                                   GLuint offset) {
1323   NOTREACHED() << "Unimplemented GetMaxValueInBufferCHROMIUM.";
1324   return 0;
1325 }
1326 GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
1327   NOTREACHED() << "Unimplemented EnableFeatureCHROMIUM.";
1328   return 0;
1329 }
1330 void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
1331   MojoGLES2MakeCurrent(context_);
1332   return glMapBufferCHROMIUM(target, access);
1333 }
1334 GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
1335   MojoGLES2MakeCurrent(context_);
1336   return glUnmapBufferCHROMIUM(target);
1337 }
1338 void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
1339                                               GLintptr offset,
1340                                               GLsizeiptr size,
1341                                               GLenum access) {
1342   NOTREACHED() << "Unimplemented MapBufferSubDataCHROMIUM.";
1343   return 0;
1344 }
1345 void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
1346   NOTREACHED() << "Unimplemented UnmapBufferSubDataCHROMIUM.";
1347 }
1348 void* MojoGLES2Impl::MapBufferRange(GLenum target,
1349                                     GLintptr offset,
1350                                     GLsizeiptr size,
1351                                     GLbitfield access) {
1352   NOTREACHED() << "Unimplemented MapBufferRange.";
1353   return 0;
1354 }
1355 GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
1356   NOTREACHED() << "Unimplemented UnmapBuffer.";
1357   return 0;
1358 }
1359 void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
1360                                               GLint level,
1361                                               GLint xoffset,
1362                                               GLint yoffset,
1363                                               GLsizei width,
1364                                               GLsizei height,
1365                                               GLenum format,
1366                                               GLenum type,
1367                                               GLenum access) {
1368   MojoGLES2MakeCurrent(context_);
1369   return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1370                                     height, format, type, access);
1371 }
1372 void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1373   MojoGLES2MakeCurrent(context_);
1374   glUnmapTexSubImage2DCHROMIUM(mem);
1375 }
1376 void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
1377                                    GLuint height,
1378                                    GLfloat scale_factor) {
1379   NOTREACHED() << "Unimplemented ResizeCHROMIUM.";
1380 }
1381 const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
1382   NOTREACHED() << "Unimplemented GetRequestableExtensionsCHROMIUM.";
1383   return 0;
1384 }
1385 void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
1386   NOTREACHED() << "Unimplemented RequestExtensionCHROMIUM.";
1387 }
1388 void MojoGLES2Impl::RateLimitOffscreenContextCHROMIUM() {
1389   NOTREACHED() << "Unimplemented RateLimitOffscreenContextCHROMIUM.";
1390 }
1391 void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
1392                                            GLsizei bufsize,
1393                                            GLsizei* size,
1394                                            void* info) {
1395   NOTREACHED() << "Unimplemented GetProgramInfoCHROMIUM.";
1396 }
1397 void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
1398                                              GLsizei bufsize,
1399                                              GLsizei* size,
1400                                              void* info) {
1401   NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
1402 }
1403 void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1404                                                          GLsizei bufsize,
1405                                                          GLsizei* size,
1406                                                          void* info) {
1407   NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
1408 }
1409 void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
1410                                            GLsizei bufsize,
1411                                            GLsizei* size,
1412                                            void* info) {
1413   NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
1414 }
1415 GLuint MojoGLES2Impl::CreateStreamTextureCHROMIUM(GLuint texture) {
1416   NOTREACHED() << "Unimplemented CreateStreamTextureCHROMIUM.";
1417   return 0;
1418 }
1419 GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
1420                                           GLsizei width,
1421                                           GLsizei height,
1422                                           GLenum internalformat) {
1423   MojoGLES2MakeCurrent(context_);
1424   return glCreateImageCHROMIUM(buffer, width, height, internalformat);
1425 }
1426 void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
1427   MojoGLES2MakeCurrent(context_);
1428   glDestroyImageCHROMIUM(image_id);
1429 }
1430 GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1431                                                          GLsizei height,
1432                                                          GLenum internalformat,
1433                                                          GLenum usage) {
1434   MojoGLES2MakeCurrent(context_);
1435   return glCreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
1436                                               usage);
1437 }
1438 void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
1439                                                    GLsizei bufsize,
1440                                                    GLsizei* length,
1441                                                    char* source) {
1442   NOTREACHED() << "Unimplemented GetTranslatedShaderSourceANGLE.";
1443 }
1444 void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
1445                                           GLint y,
1446                                           GLint width,
1447                                           GLint height) {
1448   NOTREACHED() << "Unimplemented PostSubBufferCHROMIUM.";
1449 }
1450 void MojoGLES2Impl::TexImageIOSurface2DCHROMIUM(GLenum target,
1451                                                 GLsizei width,
1452                                                 GLsizei height,
1453                                                 GLuint ioSurfaceId,
1454                                                 GLuint plane) {
1455   NOTREACHED() << "Unimplemented TexImageIOSurface2DCHROMIUM.";
1456 }
1457 void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum target,
1458                                         GLenum source_id,
1459                                         GLenum dest_id,
1460                                         GLint internalformat,
1461                                         GLenum dest_type,
1462                                         GLboolean unpack_flip_y,
1463                                         GLboolean unpack_premultiply_alpha,
1464                                         GLboolean unpack_unmultiply_alpha) {
1465   MojoGLES2MakeCurrent(context_);
1466   glCopyTextureCHROMIUM(target, source_id, dest_id, internalformat, dest_type,
1467                         unpack_flip_y, unpack_premultiply_alpha,
1468                         unpack_unmultiply_alpha);
1469 }
1470 void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum target,
1471                                            GLenum source_id,
1472                                            GLenum dest_id,
1473                                            GLint xoffset,
1474                                            GLint yoffset,
1475                                            GLint x,
1476                                            GLint y,
1477                                            GLsizei width,
1478                                            GLsizei height,
1479                                            GLboolean unpack_flip_y,
1480                                            GLboolean unpack_premultiply_alpha,
1481                                            GLboolean unpack_unmultiply_alpha) {
1482   MojoGLES2MakeCurrent(context_);
1483   glCopySubTextureCHROMIUM(target, source_id, dest_id, xoffset, yoffset, x, y,
1484                            width, height, unpack_flip_y,
1485                            unpack_premultiply_alpha, unpack_unmultiply_alpha);
1486 }
1487 void MojoGLES2Impl::CompressedCopyTextureCHROMIUM(GLenum target,
1488                                                   GLenum source_id,
1489                                                   GLenum dest_id) {
1490   NOTREACHED() << "Unimplemented CompressedCopyTextureCHROMIUM.";
1491 }
1492 void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
1493                                              GLint first,
1494                                              GLsizei count,
1495                                              GLsizei primcount) {
1496   NOTREACHED() << "Unimplemented DrawArraysInstancedANGLE.";
1497 }
1498 void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
1499                                                GLsizei count,
1500                                                GLenum type,
1501                                                const void* indices,
1502                                                GLsizei primcount) {
1503   NOTREACHED() << "Unimplemented DrawElementsInstancedANGLE.";
1504 }
1505 void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1506   NOTREACHED() << "Unimplemented VertexAttribDivisorANGLE.";
1507 }
1508 void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
1509   MojoGLES2MakeCurrent(context_);
1510   glGenMailboxCHROMIUM(mailbox);
1511 }
1512 void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
1513                                            const GLbyte* mailbox) {
1514   MojoGLES2MakeCurrent(context_);
1515   glProduceTextureCHROMIUM(target, mailbox);
1516 }
1517 void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
1518                                                  GLenum target,
1519                                                  const GLbyte* mailbox) {
1520   MojoGLES2MakeCurrent(context_);
1521   glProduceTextureDirectCHROMIUM(texture, target, mailbox);
1522 }
1523 void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
1524                                            const GLbyte* mailbox) {
1525   MojoGLES2MakeCurrent(context_);
1526   glConsumeTextureCHROMIUM(target, mailbox);
1527 }
1528 GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
1529                                                       const GLbyte* mailbox) {
1530   MojoGLES2MakeCurrent(context_);
1531   return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
1532 }
1533 void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
1534                                                 GLint location,
1535                                                 const char* name) {
1536   NOTREACHED() << "Unimplemented BindUniformLocationCHROMIUM.";
1537 }
1538 void MojoGLES2Impl::GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1539   NOTREACHED() << "Unimplemented GenValuebuffersCHROMIUM.";
1540 }
1541 void MojoGLES2Impl::DeleteValuebuffersCHROMIUM(GLsizei n,
1542                                                const GLuint* valuebuffers) {
1543   NOTREACHED() << "Unimplemented DeleteValuebuffersCHROMIUM.";
1544 }
1545 GLboolean MojoGLES2Impl::IsValuebufferCHROMIUM(GLuint valuebuffer) {
1546   NOTREACHED() << "Unimplemented IsValuebufferCHROMIUM.";
1547   return 0;
1548 }
1549 void MojoGLES2Impl::BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1550   NOTREACHED() << "Unimplemented BindValuebufferCHROMIUM.";
1551 }
1552 void MojoGLES2Impl::SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1553   NOTREACHED() << "Unimplemented SubscribeValueCHROMIUM.";
1554 }
1555 void MojoGLES2Impl::PopulateSubscribedValuesCHROMIUM(GLenum target) {
1556   NOTREACHED() << "Unimplemented PopulateSubscribedValuesCHROMIUM.";
1557 }
1558 void MojoGLES2Impl::UniformValuebufferCHROMIUM(GLint location,
1559                                                GLenum target,
1560                                                GLenum subscription) {
1561   NOTREACHED() << "Unimplemented UniformValuebufferCHROMIUM.";
1562 }
1563 void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1564   MojoGLES2MakeCurrent(context_);
1565   glBindTexImage2DCHROMIUM(target, imageId);
1566 }
1567 void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1568   MojoGLES2MakeCurrent(context_);
1569   glReleaseTexImage2DCHROMIUM(target, imageId);
1570 }
1571 void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
1572                                        const char* trace_name) {
1573   NOTREACHED() << "Unimplemented TraceBeginCHROMIUM.";
1574 }
1575 void MojoGLES2Impl::TraceEndCHROMIUM() {
1576   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
1577 }
1578 void MojoGLES2Impl::AsyncTexSubImage2DCHROMIUM(GLenum target,
1579                                                GLint level,
1580                                                GLint xoffset,
1581                                                GLint yoffset,
1582                                                GLsizei width,
1583                                                GLsizei height,
1584                                                GLenum format,
1585                                                GLenum type,
1586                                                const void* data) {
1587   NOTREACHED() << "Unimplemented AsyncTexSubImage2DCHROMIUM.";
1588 }
1589 void MojoGLES2Impl::AsyncTexImage2DCHROMIUM(GLenum target,
1590                                             GLint level,
1591                                             GLenum internalformat,
1592                                             GLsizei width,
1593                                             GLsizei height,
1594                                             GLint border,
1595                                             GLenum format,
1596                                             GLenum type,
1597                                             const void* pixels) {
1598   NOTREACHED() << "Unimplemented AsyncTexImage2DCHROMIUM.";
1599 }
1600 void MojoGLES2Impl::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1601   NOTREACHED() << "Unimplemented WaitAsyncTexImage2DCHROMIUM.";
1602 }
1603 void MojoGLES2Impl::WaitAllAsyncTexImage2DCHROMIUM() {
1604   NOTREACHED() << "Unimplemented WaitAllAsyncTexImage2DCHROMIUM.";
1605 }
1606 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
1607                                           GLsizei count,
1608                                           const GLenum* attachments) {
1609   NOTREACHED() << "Unimplemented DiscardFramebufferEXT.";
1610 }
1611 void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
1612   NOTREACHED() << "Unimplemented LoseContextCHROMIUM.";
1613 }
1614 GLuint MojoGLES2Impl::InsertSyncPointCHROMIUM() {
1615   MojoGLES2MakeCurrent(context_);
1616   return glInsertSyncPointCHROMIUM();
1617 }
1618 void MojoGLES2Impl::WaitSyncPointCHROMIUM(GLuint sync_point) {
1619   MojoGLES2MakeCurrent(context_);
1620   glWaitSyncPointCHROMIUM(sync_point);
1621 }
1622 void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1623   NOTREACHED() << "Unimplemented DrawBuffersEXT.";
1624 }
1625 void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
1626   NOTREACHED() << "Unimplemented DiscardBackbufferCHROMIUM.";
1627 }
1628 void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1629                                                  GLenum plane_transform,
1630                                                  GLuint overlay_texture_id,
1631                                                  GLint bounds_x,
1632                                                  GLint bounds_y,
1633                                                  GLint bounds_width,
1634                                                  GLint bounds_height,
1635                                                  GLfloat uv_x,
1636                                                  GLfloat uv_y,
1637                                                  GLfloat uv_width,
1638                                                  GLfloat uv_height) {
1639   NOTREACHED() << "Unimplemented ScheduleOverlayPlaneCHROMIUM.";
1640 }
1641 void MojoGLES2Impl::SwapInterval(GLint interval) {
1642   NOTREACHED() << "Unimplemented SwapInterval.";
1643 }
1644 void MojoGLES2Impl::FlushDriverCachesCHROMIUM() {
1645   NOTREACHED() << "Unimplemented FlushDriverCachesCHROMIUM.";
1646 }
1647 void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1648   NOTREACHED() << "Unimplemented MatrixLoadfCHROMIUM.";
1649 }
1650 void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1651   NOTREACHED() << "Unimplemented MatrixLoadIdentityCHROMIUM.";
1652 }
1653 GLuint MojoGLES2Impl::GenPathsCHROMIUM(GLsizei range) {
1654   NOTREACHED() << "Unimplemented GenPathsCHROMIUM.";
1655   return 0;
1656 }
1657 void MojoGLES2Impl::DeletePathsCHROMIUM(GLuint path, GLsizei range) {
1658   NOTREACHED() << "Unimplemented DeletePathsCHROMIUM.";
1659 }
1660 GLboolean MojoGLES2Impl::IsPathCHROMIUM(GLuint path) {
1661   NOTREACHED() << "Unimplemented IsPathCHROMIUM.";
1662   return 0;
1663 }
1664 void MojoGLES2Impl::PathCommandsCHROMIUM(GLuint path,
1665                                          GLsizei numCommands,
1666                                          const GLubyte* commands,
1667                                          GLsizei numCoords,
1668                                          GLenum coordType,
1669                                          const GLvoid* coords) {
1670   NOTREACHED() << "Unimplemented PathCommandsCHROMIUM.";
1671 }
1672 void MojoGLES2Impl::PathParameterfCHROMIUM(GLuint path,
1673                                            GLenum pname,
1674                                            GLfloat value) {
1675   NOTREACHED() << "Unimplemented PathParameterfCHROMIUM.";
1676 }
1677 void MojoGLES2Impl::PathParameteriCHROMIUM(GLuint path,
1678                                            GLenum pname,
1679                                            GLint value) {
1680   NOTREACHED() << "Unimplemented PathParameteriCHROMIUM.";
1681 }
1682 void MojoGLES2Impl::PathStencilFuncCHROMIUM(GLenum func,
1683                                             GLint ref,
1684                                             GLuint mask) {
1685   NOTREACHED() << "Unimplemented PathStencilFuncCHROMIUM.";
1686 }
1687 void MojoGLES2Impl::StencilFillPathCHROMIUM(GLuint path,
1688                                             GLenum fillMode,
1689                                             GLuint mask) {
1690   NOTREACHED() << "Unimplemented StencilFillPathCHROMIUM.";
1691 }
1692 void MojoGLES2Impl::StencilStrokePathCHROMIUM(GLuint path,
1693                                               GLint reference,
1694                                               GLuint mask) {
1695   NOTREACHED() << "Unimplemented StencilStrokePathCHROMIUM.";
1696 }
1697 void MojoGLES2Impl::CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
1698   NOTREACHED() << "Unimplemented CoverFillPathCHROMIUM.";
1699 }
1700 void MojoGLES2Impl::CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
1701   NOTREACHED() << "Unimplemented CoverStrokePathCHROMIUM.";
1702 }
1703 void MojoGLES2Impl::StencilThenCoverFillPathCHROMIUM(GLuint path,
1704                                                      GLenum fillMode,
1705                                                      GLuint mask,
1706                                                      GLenum coverMode) {
1707   NOTREACHED() << "Unimplemented StencilThenCoverFillPathCHROMIUM.";
1708 }
1709 void MojoGLES2Impl::StencilThenCoverStrokePathCHROMIUM(GLuint path,
1710                                                        GLint reference,
1711                                                        GLuint mask,
1712                                                        GLenum coverMode) {
1713   NOTREACHED() << "Unimplemented StencilThenCoverStrokePathCHROMIUM.";
1714 }
1715 GLenum MojoGLES2Impl::GetGraphicsResetStatusKHR() {
1716   NOTREACHED() << "Unimplemented GetGraphicsResetStatusKHR.";
1717   return 0;
1718 }
1719 void MojoGLES2Impl::BlendBarrierKHR() {
1720   NOTREACHED() << "Unimplemented BlendBarrierKHR.";
1721 }
1722
1723 }  // namespace mojo