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 GLboolean MojoGLES2Impl::IsQueryEXT(GLuint id) {
1259   MojoGLES2MakeCurrent(context_);
1260   return glIsQueryEXT(id);
1261 }
1262 void MojoGLES2Impl::BeginQueryEXT(GLenum target, GLuint id) {
1263   MojoGLES2MakeCurrent(context_);
1264   glBeginQueryEXT(target, id);
1265 }
1266 void MojoGLES2Impl::BeginTransformFeedback(GLenum primitivemode) {
1267   NOTREACHED() << "Unimplemented BeginTransformFeedback.";
1268 }
1269 void MojoGLES2Impl::EndQueryEXT(GLenum target) {
1270   MojoGLES2MakeCurrent(context_);
1271   glEndQueryEXT(target);
1272 }
1273 void MojoGLES2Impl::EndTransformFeedback() {
1274   NOTREACHED() << "Unimplemented EndTransformFeedback.";
1275 }
1276 void MojoGLES2Impl::GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
1277   MojoGLES2MakeCurrent(context_);
1278   glGetQueryivEXT(target, pname, params);
1279 }
1280 void MojoGLES2Impl::GetQueryObjectuivEXT(GLuint id,
1281                                          GLenum pname,
1282                                          GLuint* params) {
1283   MojoGLES2MakeCurrent(context_);
1284   glGetQueryObjectuivEXT(id, pname, params);
1285 }
1286 void MojoGLES2Impl::InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1287   NOTREACHED() << "Unimplemented InsertEventMarkerEXT.";
1288 }
1289 void MojoGLES2Impl::PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1290   NOTREACHED() << "Unimplemented PushGroupMarkerEXT.";
1291 }
1292 void MojoGLES2Impl::PopGroupMarkerEXT() {
1293   NOTREACHED() << "Unimplemented PopGroupMarkerEXT.";
1294 }
1295 void MojoGLES2Impl::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1296   NOTREACHED() << "Unimplemented GenVertexArraysOES.";
1297 }
1298 void MojoGLES2Impl::DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1299   NOTREACHED() << "Unimplemented DeleteVertexArraysOES.";
1300 }
1301 GLboolean MojoGLES2Impl::IsVertexArrayOES(GLuint array) {
1302   NOTREACHED() << "Unimplemented IsVertexArrayOES.";
1303   return 0;
1304 }
1305 void MojoGLES2Impl::BindVertexArrayOES(GLuint array) {
1306   NOTREACHED() << "Unimplemented BindVertexArrayOES.";
1307 }
1308 void MojoGLES2Impl::SwapBuffers() {
1309   NOTREACHED() << "Unimplemented SwapBuffers.";
1310 }
1311 GLuint MojoGLES2Impl::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1312                                                   GLsizei count,
1313                                                   GLenum type,
1314                                                   GLuint offset) {
1315   NOTREACHED() << "Unimplemented GetMaxValueInBufferCHROMIUM.";
1316   return 0;
1317 }
1318 GLboolean MojoGLES2Impl::EnableFeatureCHROMIUM(const char* feature) {
1319   NOTREACHED() << "Unimplemented EnableFeatureCHROMIUM.";
1320   return 0;
1321 }
1322 void* MojoGLES2Impl::MapBufferCHROMIUM(GLuint target, GLenum access) {
1323   MojoGLES2MakeCurrent(context_);
1324   return glMapBufferCHROMIUM(target, access);
1325 }
1326 GLboolean MojoGLES2Impl::UnmapBufferCHROMIUM(GLuint target) {
1327   MojoGLES2MakeCurrent(context_);
1328   return glUnmapBufferCHROMIUM(target);
1329 }
1330 void* MojoGLES2Impl::MapBufferSubDataCHROMIUM(GLuint target,
1331                                               GLintptr offset,
1332                                               GLsizeiptr size,
1333                                               GLenum access) {
1334   NOTREACHED() << "Unimplemented MapBufferSubDataCHROMIUM.";
1335   return 0;
1336 }
1337 void MojoGLES2Impl::UnmapBufferSubDataCHROMIUM(const void* mem) {
1338   NOTREACHED() << "Unimplemented UnmapBufferSubDataCHROMIUM.";
1339 }
1340 void* MojoGLES2Impl::MapBufferRange(GLenum target,
1341                                     GLintptr offset,
1342                                     GLsizeiptr size,
1343                                     GLbitfield access) {
1344   NOTREACHED() << "Unimplemented MapBufferRange.";
1345   return 0;
1346 }
1347 GLboolean MojoGLES2Impl::UnmapBuffer(GLenum target) {
1348   NOTREACHED() << "Unimplemented UnmapBuffer.";
1349   return 0;
1350 }
1351 void* MojoGLES2Impl::MapTexSubImage2DCHROMIUM(GLenum target,
1352                                               GLint level,
1353                                               GLint xoffset,
1354                                               GLint yoffset,
1355                                               GLsizei width,
1356                                               GLsizei height,
1357                                               GLenum format,
1358                                               GLenum type,
1359                                               GLenum access) {
1360   MojoGLES2MakeCurrent(context_);
1361   return glMapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1362                                     height, format, type, access);
1363 }
1364 void MojoGLES2Impl::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1365   MojoGLES2MakeCurrent(context_);
1366   glUnmapTexSubImage2DCHROMIUM(mem);
1367 }
1368 void MojoGLES2Impl::ResizeCHROMIUM(GLuint width,
1369                                    GLuint height,
1370                                    GLfloat scale_factor) {
1371   NOTREACHED() << "Unimplemented ResizeCHROMIUM.";
1372 }
1373 const GLchar* MojoGLES2Impl::GetRequestableExtensionsCHROMIUM() {
1374   NOTREACHED() << "Unimplemented GetRequestableExtensionsCHROMIUM.";
1375   return 0;
1376 }
1377 void MojoGLES2Impl::RequestExtensionCHROMIUM(const char* extension) {
1378   NOTREACHED() << "Unimplemented RequestExtensionCHROMIUM.";
1379 }
1380 void MojoGLES2Impl::RateLimitOffscreenContextCHROMIUM() {
1381   NOTREACHED() << "Unimplemented RateLimitOffscreenContextCHROMIUM.";
1382 }
1383 void MojoGLES2Impl::GetProgramInfoCHROMIUM(GLuint program,
1384                                            GLsizei bufsize,
1385                                            GLsizei* size,
1386                                            void* info) {
1387   NOTREACHED() << "Unimplemented GetProgramInfoCHROMIUM.";
1388 }
1389 void MojoGLES2Impl::GetUniformBlocksCHROMIUM(GLuint program,
1390                                              GLsizei bufsize,
1391                                              GLsizei* size,
1392                                              void* info) {
1393   NOTREACHED() << "Unimplemented GetUniformBlocksCHROMIUM.";
1394 }
1395 void MojoGLES2Impl::GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1396                                                          GLsizei bufsize,
1397                                                          GLsizei* size,
1398                                                          void* info) {
1399   NOTREACHED() << "Unimplemented GetTransformFeedbackVaryingsCHROMIUM.";
1400 }
1401 void MojoGLES2Impl::GetUniformsES3CHROMIUM(GLuint program,
1402                                            GLsizei bufsize,
1403                                            GLsizei* size,
1404                                            void* info) {
1405   NOTREACHED() << "Unimplemented GetUniformsES3CHROMIUM.";
1406 }
1407 GLuint MojoGLES2Impl::CreateStreamTextureCHROMIUM(GLuint texture) {
1408   NOTREACHED() << "Unimplemented CreateStreamTextureCHROMIUM.";
1409   return 0;
1410 }
1411 GLuint MojoGLES2Impl::CreateImageCHROMIUM(ClientBuffer buffer,
1412                                           GLsizei width,
1413                                           GLsizei height,
1414                                           GLenum internalformat) {
1415   MojoGLES2MakeCurrent(context_);
1416   return glCreateImageCHROMIUM(buffer, width, height, internalformat);
1417 }
1418 void MojoGLES2Impl::DestroyImageCHROMIUM(GLuint image_id) {
1419   MojoGLES2MakeCurrent(context_);
1420   glDestroyImageCHROMIUM(image_id);
1421 }
1422 GLuint MojoGLES2Impl::CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1423                                                          GLsizei height,
1424                                                          GLenum internalformat,
1425                                                          GLenum usage) {
1426   MojoGLES2MakeCurrent(context_);
1427   return glCreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
1428                                               usage);
1429 }
1430 void MojoGLES2Impl::GetTranslatedShaderSourceANGLE(GLuint shader,
1431                                                    GLsizei bufsize,
1432                                                    GLsizei* length,
1433                                                    char* source) {
1434   NOTREACHED() << "Unimplemented GetTranslatedShaderSourceANGLE.";
1435 }
1436 void MojoGLES2Impl::PostSubBufferCHROMIUM(GLint x,
1437                                           GLint y,
1438                                           GLint width,
1439                                           GLint height) {
1440   NOTREACHED() << "Unimplemented PostSubBufferCHROMIUM.";
1441 }
1442 void MojoGLES2Impl::TexImageIOSurface2DCHROMIUM(GLenum target,
1443                                                 GLsizei width,
1444                                                 GLsizei height,
1445                                                 GLuint ioSurfaceId,
1446                                                 GLuint plane) {
1447   NOTREACHED() << "Unimplemented TexImageIOSurface2DCHROMIUM.";
1448 }
1449 void MojoGLES2Impl::CopyTextureCHROMIUM(GLenum target,
1450                                         GLenum source_id,
1451                                         GLenum dest_id,
1452                                         GLint internalformat,
1453                                         GLenum dest_type) {
1454   MojoGLES2MakeCurrent(context_);
1455   glCopyTextureCHROMIUM(target, source_id, dest_id, internalformat, dest_type);
1456 }
1457 void MojoGLES2Impl::CopySubTextureCHROMIUM(GLenum target,
1458                                            GLenum source_id,
1459                                            GLenum dest_id,
1460                                            GLint xoffset,
1461                                            GLint yoffset,
1462                                            GLint x,
1463                                            GLint y,
1464                                            GLsizei width,
1465                                            GLsizei height) {
1466   MojoGLES2MakeCurrent(context_);
1467   glCopySubTextureCHROMIUM(target, source_id, dest_id, xoffset, yoffset, x, y,
1468                            width, height);
1469 }
1470 void MojoGLES2Impl::CompressedCopyTextureCHROMIUM(GLenum target,
1471                                                   GLenum source_id,
1472                                                   GLenum dest_id) {
1473   NOTREACHED() << "Unimplemented CompressedCopyTextureCHROMIUM.";
1474 }
1475 void MojoGLES2Impl::DrawArraysInstancedANGLE(GLenum mode,
1476                                              GLint first,
1477                                              GLsizei count,
1478                                              GLsizei primcount) {
1479   NOTREACHED() << "Unimplemented DrawArraysInstancedANGLE.";
1480 }
1481 void MojoGLES2Impl::DrawElementsInstancedANGLE(GLenum mode,
1482                                                GLsizei count,
1483                                                GLenum type,
1484                                                const void* indices,
1485                                                GLsizei primcount) {
1486   NOTREACHED() << "Unimplemented DrawElementsInstancedANGLE.";
1487 }
1488 void MojoGLES2Impl::VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1489   NOTREACHED() << "Unimplemented VertexAttribDivisorANGLE.";
1490 }
1491 void MojoGLES2Impl::GenMailboxCHROMIUM(GLbyte* mailbox) {
1492   MojoGLES2MakeCurrent(context_);
1493   glGenMailboxCHROMIUM(mailbox);
1494 }
1495 void MojoGLES2Impl::ProduceTextureCHROMIUM(GLenum target,
1496                                            const GLbyte* mailbox) {
1497   MojoGLES2MakeCurrent(context_);
1498   glProduceTextureCHROMIUM(target, mailbox);
1499 }
1500 void MojoGLES2Impl::ProduceTextureDirectCHROMIUM(GLuint texture,
1501                                                  GLenum target,
1502                                                  const GLbyte* mailbox) {
1503   MojoGLES2MakeCurrent(context_);
1504   glProduceTextureDirectCHROMIUM(texture, target, mailbox);
1505 }
1506 void MojoGLES2Impl::ConsumeTextureCHROMIUM(GLenum target,
1507                                            const GLbyte* mailbox) {
1508   MojoGLES2MakeCurrent(context_);
1509   glConsumeTextureCHROMIUM(target, mailbox);
1510 }
1511 GLuint MojoGLES2Impl::CreateAndConsumeTextureCHROMIUM(GLenum target,
1512                                                       const GLbyte* mailbox) {
1513   MojoGLES2MakeCurrent(context_);
1514   return glCreateAndConsumeTextureCHROMIUM(target, mailbox);
1515 }
1516 void MojoGLES2Impl::BindUniformLocationCHROMIUM(GLuint program,
1517                                                 GLint location,
1518                                                 const char* name) {
1519   NOTREACHED() << "Unimplemented BindUniformLocationCHROMIUM.";
1520 }
1521 void MojoGLES2Impl::GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1522   NOTREACHED() << "Unimplemented GenValuebuffersCHROMIUM.";
1523 }
1524 void MojoGLES2Impl::DeleteValuebuffersCHROMIUM(GLsizei n,
1525                                                const GLuint* valuebuffers) {
1526   NOTREACHED() << "Unimplemented DeleteValuebuffersCHROMIUM.";
1527 }
1528 GLboolean MojoGLES2Impl::IsValuebufferCHROMIUM(GLuint valuebuffer) {
1529   NOTREACHED() << "Unimplemented IsValuebufferCHROMIUM.";
1530   return 0;
1531 }
1532 void MojoGLES2Impl::BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1533   NOTREACHED() << "Unimplemented BindValuebufferCHROMIUM.";
1534 }
1535 void MojoGLES2Impl::SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1536   NOTREACHED() << "Unimplemented SubscribeValueCHROMIUM.";
1537 }
1538 void MojoGLES2Impl::PopulateSubscribedValuesCHROMIUM(GLenum target) {
1539   NOTREACHED() << "Unimplemented PopulateSubscribedValuesCHROMIUM.";
1540 }
1541 void MojoGLES2Impl::UniformValuebufferCHROMIUM(GLint location,
1542                                                GLenum target,
1543                                                GLenum subscription) {
1544   NOTREACHED() << "Unimplemented UniformValuebufferCHROMIUM.";
1545 }
1546 void MojoGLES2Impl::BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1547   MojoGLES2MakeCurrent(context_);
1548   glBindTexImage2DCHROMIUM(target, imageId);
1549 }
1550 void MojoGLES2Impl::ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1551   MojoGLES2MakeCurrent(context_);
1552   glReleaseTexImage2DCHROMIUM(target, imageId);
1553 }
1554 void MojoGLES2Impl::TraceBeginCHROMIUM(const char* category_name,
1555                                        const char* trace_name) {
1556   NOTREACHED() << "Unimplemented TraceBeginCHROMIUM.";
1557 }
1558 void MojoGLES2Impl::TraceEndCHROMIUM() {
1559   NOTREACHED() << "Unimplemented TraceEndCHROMIUM.";
1560 }
1561 void MojoGLES2Impl::AsyncTexSubImage2DCHROMIUM(GLenum target,
1562                                                GLint level,
1563                                                GLint xoffset,
1564                                                GLint yoffset,
1565                                                GLsizei width,
1566                                                GLsizei height,
1567                                                GLenum format,
1568                                                GLenum type,
1569                                                const void* data) {
1570   NOTREACHED() << "Unimplemented AsyncTexSubImage2DCHROMIUM.";
1571 }
1572 void MojoGLES2Impl::AsyncTexImage2DCHROMIUM(GLenum target,
1573                                             GLint level,
1574                                             GLenum internalformat,
1575                                             GLsizei width,
1576                                             GLsizei height,
1577                                             GLint border,
1578                                             GLenum format,
1579                                             GLenum type,
1580                                             const void* pixels) {
1581   NOTREACHED() << "Unimplemented AsyncTexImage2DCHROMIUM.";
1582 }
1583 void MojoGLES2Impl::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1584   NOTREACHED() << "Unimplemented WaitAsyncTexImage2DCHROMIUM.";
1585 }
1586 void MojoGLES2Impl::WaitAllAsyncTexImage2DCHROMIUM() {
1587   NOTREACHED() << "Unimplemented WaitAllAsyncTexImage2DCHROMIUM.";
1588 }
1589 void MojoGLES2Impl::DiscardFramebufferEXT(GLenum target,
1590                                           GLsizei count,
1591                                           const GLenum* attachments) {
1592   NOTREACHED() << "Unimplemented DiscardFramebufferEXT.";
1593 }
1594 void MojoGLES2Impl::LoseContextCHROMIUM(GLenum current, GLenum other) {
1595   NOTREACHED() << "Unimplemented LoseContextCHROMIUM.";
1596 }
1597 GLuint MojoGLES2Impl::InsertSyncPointCHROMIUM() {
1598   MojoGLES2MakeCurrent(context_);
1599   return glInsertSyncPointCHROMIUM();
1600 }
1601 void MojoGLES2Impl::WaitSyncPointCHROMIUM(GLuint sync_point) {
1602   MojoGLES2MakeCurrent(context_);
1603   glWaitSyncPointCHROMIUM(sync_point);
1604 }
1605 void MojoGLES2Impl::DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1606   NOTREACHED() << "Unimplemented DrawBuffersEXT.";
1607 }
1608 void MojoGLES2Impl::DiscardBackbufferCHROMIUM() {
1609   NOTREACHED() << "Unimplemented DiscardBackbufferCHROMIUM.";
1610 }
1611 void MojoGLES2Impl::ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1612                                                  GLenum plane_transform,
1613                                                  GLuint overlay_texture_id,
1614                                                  GLint bounds_x,
1615                                                  GLint bounds_y,
1616                                                  GLint bounds_width,
1617                                                  GLint bounds_height,
1618                                                  GLfloat uv_x,
1619                                                  GLfloat uv_y,
1620                                                  GLfloat uv_width,
1621                                                  GLfloat uv_height) {
1622   NOTREACHED() << "Unimplemented ScheduleOverlayPlaneCHROMIUM.";
1623 }
1624 void MojoGLES2Impl::SwapInterval(GLint interval) {
1625   NOTREACHED() << "Unimplemented SwapInterval.";
1626 }
1627 void MojoGLES2Impl::MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1628   NOTREACHED() << "Unimplemented MatrixLoadfCHROMIUM.";
1629 }
1630 void MojoGLES2Impl::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1631   NOTREACHED() << "Unimplemented MatrixLoadIdentityCHROMIUM.";
1632 }
1633 GLenum MojoGLES2Impl::GetGraphicsResetStatusKHR() {
1634   NOTREACHED() << "Unimplemented GetGraphicsResetStatusKHR.";
1635   return 0;
1636 }
1637 void MojoGLES2Impl::BlendBarrierKHR() {
1638   NOTREACHED() << "Unimplemented BlendBarrierKHR.";
1639 }
1640
1641 }  // namespace mojo