ui/gl/gl_bindings_skia_in_process.cc

   1 // Copyright (c) 2012 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
   6 #include "ui/gl/gl_bindings_skia_in_process.h"
   7
   8 #include "base/logging.h"
   9 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
  10 #include "ui/gl/gl_bindings.h"
  11 #include "ui/gl/gl_implementation.h"
  12
  13 namespace {
  14
  15 extern "C" {
  16 // The following stub functions are required because the glXXX routines exported
  17 // via gl_bindings.h use call-type GL_BINDING_CALL, which on Windows is stdcall.
  18 // Skia has been built such that its GrGLInterface GL pointers are __cdecl.
  19
  20 GLvoid StubGLActiveTexture(GLenum texture) {
  21   glActiveTexture(texture);
  22 }
  23
  24 GLvoid StubGLAttachShader(GLuint program, GLuint shader) {
  25   glAttachShader(program, shader);
  26 }
  27
  28 GLvoid StubGLBeginQuery(GLenum target, GLuint id) {
  29   glBeginQuery(target, id);
  30 }
  31
  32 GLvoid StubGLBindAttribLocation(GLuint program, GLuint index,
  33                                 const char* name) {
  34   glBindAttribLocation(program, index, name);
  35 }
  36
  37 GLvoid StubGLBindBuffer(GLenum target, GLuint buffer) {
  38   glBindBuffer(target, buffer);
  39 }
  40
  41 GLvoid StubGLBindFragDataLocation(GLuint program, GLuint colorNumber,
  42                                   const GLchar * name) {
  43   glBindFragDataLocation(program, colorNumber, name);
  44 }
  45
  46 GLvoid StubGLBindFragDataLocationIndexed(GLuint program, GLuint colorNumber,
  47                                          GLuint index, const GLchar * name) {
  48   glBindFragDataLocationIndexed(program, colorNumber, index, name);
  49 }
  50
  51 GLvoid StubGLBindFramebuffer(GLenum target, GLuint framebuffer) {
  52   glBindFramebufferEXT(target, framebuffer);
  53 }
  54
  55 GLvoid StubGLBindRenderbuffer(GLenum target, GLuint renderbuffer) {
  56   glBindRenderbufferEXT(target, renderbuffer);
  57 }
  58
  59 GLvoid StubGLBindTexture(GLenum target, GLuint texture) {
  60   glBindTexture(target, texture);
  61 }
  62
  63 GLvoid StubGLBindVertexArray(GLuint array) {
  64   glBindVertexArrayOES(array);
  65 }
  66
  67 GLvoid StubGLBlendColor(GLclampf red, GLclampf green, GLclampf blue,
  68                         GLclampf alpha) {
  69   glBlendColor(red, green, blue, alpha);
  70 }
  71
  72 GLvoid StubGLBlendFunc(GLenum sfactor, GLenum dfactor) {
  73   glBlendFunc(sfactor, dfactor);
  74 }
  75
  76 GLvoid StubGLBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
  77                              GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
  78                              GLbitfield mask, GLenum filter) {
  79   glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
  80                        mask, filter);
  81 }
  82
  83 GLvoid StubGLBufferData(GLenum target, GLsizeiptr size, const void* data,
  84                         GLenum usage) {
  85   glBufferData(target, size, data, usage);
  86 }
  87
  88 GLvoid StubGLBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
  89                            const void* data) {
  90   glBufferSubData(target, offset, size, data);
  91 }
  92
  93 GLenum StubGLCheckFramebufferStatus(GLenum target) {
  94   return glCheckFramebufferStatusEXT(target);
  95 }
  96
  97 GLvoid StubGLClear(GLbitfield mask) {
  98   glClear(mask);
  99 }
 100
 101 GLvoid StubGLClearColor(GLclampf red, GLclampf green, GLclampf blue,
 102                         GLclampf alpha) {
 103   glClearColor(red, green, blue, alpha);
 104 }
 105
 106 GLvoid StubGLClearStencil(GLint s) {
 107   glClearStencil(s);
 108 }
 109
 110 GLvoid StubGLColorMask(GLboolean red, GLboolean green, GLboolean blue,
 111                        GLboolean alpha) {
 112   glColorMask(red, green, blue, alpha);
 113 }
 114
 115 GLvoid StubGLCompileShader(GLuint shader) {
 116   glCompileShader(shader);
 117 }
 118
 119 GLvoid StubGLCompressedTexImage2D(GLenum target, GLint level,
 120                                   GLenum internalformat, GLsizei width,
 121                                   GLsizei height, GLint border,
 122                                   GLsizei imageSize, const void* data) {
 123   glCompressedTexImage2D(target, level, internalformat, width, height, border,
 124                          imageSize, data);
 125 }
 126
 127 GLvoid StubGLCopyTexSubImage2D(GLenum target, GLint level,
 128                                GLint xoffset, GLint yoffset,
 129                                GLint x, GLint y,
 130                                GLsizei width, GLsizei height) {
 131   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 132 }
 133
 134 GLuint StubGLCreateProgram(void) {
 135   return glCreateProgram();
 136 }
 137
 138 GLuint StubGLCreateShader(GLenum type) {
 139   return glCreateShader(type);
 140 }
 141
 142 GLvoid StubGLCullFace(GLenum mode) {
 143   glCullFace(mode);
 144 }
 145
 146 GLvoid StubGLDeleteBuffers(GLsizei n, const GLuint* buffers) {
 147   glDeleteBuffersARB(n, buffers);
 148 }
 149
 150 GLvoid StubGLDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
 151   glDeleteFramebuffersEXT(n, framebuffers);
 152 }
 153
 154 GLvoid StubGLDeleteQueries(GLsizei n, const GLuint* ids) {
 155   glDeleteQueries(n, ids);
 156 }
 157
 158 GLvoid StubGLDeleteProgram(GLuint program) {
 159   glDeleteProgram(program);
 160 }
 161
 162 GLvoid StubGLDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
 163   glDeleteRenderbuffersEXT(n, renderbuffers);
 164 }
 165
 166 GLvoid StubGLDeleteShader(GLuint shader) {
 167   glDeleteShader(shader);
 168 }
 169
 170 GLvoid StubGLDeleteTextures(GLsizei n, const GLuint* textures) {
 171   glDeleteTextures(n, textures);
 172 }
 173
 174 GLvoid StubGLDeleteVertexArrays(GLsizei n, const GLuint* arrays) {
 175   glDeleteVertexArraysOES(n, arrays);
 176 }
 177
 178 GLvoid StubGLDepthMask(GLboolean flag) {
 179   glDepthMask(flag);
 180 }
 181
 182 GLvoid StubGLDisable(GLenum cap) {
 183   glDisable(cap);
 184 }
 185
 186 GLvoid StubGLDisableVertexAttribArray(GLuint index) {
 187   glDisableVertexAttribArray(index);
 188 }
 189
 190 GLvoid StubGLDiscardFramebuffer(GLenum target, GLsizei numAttachments,
 191                                 const GLenum *attachments) {
 192   glDiscardFramebufferEXT(target, numAttachments, attachments);
 193 }
 194
 195 GLvoid StubGLDrawArrays(GLenum mode, GLint first, GLsizei count) {
 196   glDrawArrays(mode, first, count);
 197 }
 198
 199 GLvoid StubGLDrawBuffer(GLenum mode) {
 200   glDrawBuffer(mode);
 201 }
 202
 203 GLvoid StubGLDrawBuffers(GLsizei n, const GLenum* bufs) {
 204   glDrawBuffersARB(n, bufs);
 205 }
 206
 207 GLvoid StubGLDrawElements(GLenum mode, GLsizei count, GLenum type,
 208                           const void* indices) {
 209   glDrawElements(mode, count, type, indices);
 210 }
 211
 212 GLvoid StubGLEnable(GLenum cap) {
 213   glEnable(cap);
 214 }
 215
 216 GLvoid StubGLEnableVertexAttribArray(GLuint index) {
 217   glEnableVertexAttribArray(index);
 218 }
 219
 220 GLvoid StubGLEndQuery(GLenum target) {
 221   glEndQuery(target);
 222 }
 223
 224 GLvoid StubGLFinish() {
 225   glFinish();
 226 }
 227
 228 GLvoid StubGLFlush() {
 229   glFlush();
 230 }
 231
 232 GLvoid StubGLFramebufferRenderbuffer(GLenum target, GLenum attachment,
 233                                      GLenum renderbuffertarget,
 234                                      GLuint renderbuffer) {
 235   glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
 236                                renderbuffer);
 237 }
 238
 239 GLvoid StubGLFramebufferTexture2D(GLenum target, GLenum attachment,
 240                                   GLenum textarget, GLuint texture,
 241                                   GLint level) {
 242   glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
 243 }
 244
 245 GLvoid StubGLFramebufferTexture2DMultisample(GLenum target, GLenum attachment,
 246                                   GLenum textarget, GLuint texture,
 247                                   GLint level, GLsizei samples) {
 248   glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture,
 249       level, samples);
 250 }
 251
 252 GLvoid StubGLFrontFace(GLenum mode) {
 253   glFrontFace(mode);
 254 }
 255
 256 GLvoid StubGLGenBuffers(GLsizei n, GLuint* buffers) {
 257   glGenBuffersARB(n, buffers);
 258 }
 259
 260 GLvoid StubGLGenFramebuffers(GLsizei n, GLuint* framebuffers) {
 261   glGenFramebuffersEXT(n, framebuffers);
 262 }
 263
 264 GLvoid StubGLGenQueries(GLsizei n, GLuint* ids) {
 265   glGenQueries(n, ids);
 266 }
 267
 268 GLvoid StubGLGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 269   glGenRenderbuffersEXT(n, renderbuffers);
 270 }
 271
 272 GLvoid StubGLGenTextures(GLsizei n, GLuint* textures) {
 273   glGenTextures(n, textures);
 274 }
 275
 276 GLvoid StubGLGenVertexArrays(GLsizei n, GLuint* arrays) {
 277   glGenVertexArraysOES(n, arrays);
 278 }
 279
 280 GLvoid StubGLGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
 281   glGetBufferParameteriv(target, pname, params);
 282 }
 283
 284 GLvoid StubGLGetFramebufferAttachmentParameteriv(GLenum target,
 285                                                  GLenum attachment,
 286                                                  GLenum pname, GLint* params) {
 287   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
 288 }
 289
 290 GLenum StubGLGetError() {
 291   return glGetError();
 292 }
 293
 294 GLvoid StubGLGetIntegerv(GLenum pname, GLint* params) {
 295   glGetIntegerv(pname, params);
 296 }
 297
 298 GLvoid StubGLGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length,
 299                                char* infolog) {
 300   glGetProgramInfoLog(program, bufsize, length, infolog);
 301 }
 302
 303 GLvoid StubGLGetProgramiv(GLuint program, GLenum pname, GLint* params) {
 304   glGetProgramiv(program, pname, params);
 305 }
 306
 307 GLvoid StubGLGetRenderbufferParameteriv(GLenum target,
 308                                         GLenum pname, GLint* params) {
 309   glGetRenderbufferParameterivEXT(target, pname, params);
 310 }
 311
 312 GLvoid StubGLGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length,
 313                               char* infolog) {
 314   glGetShaderInfoLog(shader, bufsize, length, infolog);
 315 }
 316
 317 GLvoid StubGLGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 318   glGetShaderiv(shader, pname, params);
 319 }
 320
 321 GLvoid StubGLGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
 322                                       GLint *range, GLint *precision) {
 323   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 324 }
 325
 326 const GLubyte* StubGLGetString(GLenum name) {
 327   return glGetString(name);
 328 }
 329
 330 GLvoid StubGLGetQueryiv(GLenum target, GLenum pname, GLint* params) {
 331   glGetQueryiv(target, pname, params);
 332 }
 333
 334 GLvoid StubGLGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
 335   glGetQueryObjecti64v(id, pname, params);
 336 }
 337
 338 GLvoid StubGLGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
 339   glGetQueryObjectiv(id, pname, params);
 340 }
 341
 342 GLvoid StubGLGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
 343   glGetQueryObjectui64v(id, pname, params);
 344 }
 345
 346 GLvoid StubGLGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
 347   glGetQueryObjectuiv(id, pname, params);
 348 }
 349
 350 GLvoid StubGLGetTexLevelParameteriv(GLenum target, GLint level,
 351                                     GLenum pname, GLint* params) {
 352   glGetTexLevelParameteriv(target, level, pname, params);
 353 }
 354
 355 GLint StubGLGetUniformLocation(GLuint program, const char* name) {
 356   return glGetUniformLocation(program, name);
 357 }
 358
 359 GLvoid StubGLInsertEventMarker(GLsizei length, const char* marker) {
 360   glInsertEventMarkerEXT(length, marker);
 361 }
 362
 363 GLvoid StubGLLineWidth(GLfloat width) {
 364   glLineWidth(width);
 365 }
 366
 367 GLvoid StubGLLinkProgram(GLuint program) {
 368   glLinkProgram(program);
 369 }
 370
 371 void* StubGLMapBuffer(GLenum target, GLenum access) {
 372   return glMapBuffer(target, access);
 373 }
 374
 375 GLvoid StubGLPixelStorei(GLenum pname, GLint param) {
 376   glPixelStorei(pname, param);
 377 }
 378
 379 GLvoid StubGLPopGroupMarker() {
 380   glPopGroupMarkerEXT();
 381 }
 382
 383 GLvoid StubGLPushGroupMarker(GLsizei length, const char* marker) {
 384   glPushGroupMarkerEXT(length, marker);
 385 }
 386
 387 GLvoid StubGLQueryCounter(GLuint id, GLenum target) {
 388   glQueryCounter(id, target);
 389 }
 390
 391 GLvoid StubGLReadBuffer(GLenum src) {
 392   glReadBuffer(src);
 393 }
 394
 395 GLvoid StubGLReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
 396                         GLenum format, GLenum type, void* pixels) {
 397   glReadPixels(x, y, width, height, format, type, pixels);
 398 }
 399
 400 GLvoid StubGLRenderbufferStorage(GLenum target, GLenum internalformat,
 401                                  GLsizei width, GLsizei height) {
 402   glRenderbufferStorageEXT(target, internalformat, width, height);
 403 }
 404
 405 GLvoid StubGLRenderbufferStorageMultisample(GLenum target, GLsizei samples,
 406                                             GLenum internalformat,
 407                                             GLsizei width, GLsizei height) {
 408   glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
 409                                       height);
 410 }
 411
 412 GLvoid StubGLScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 413   glScissor(x, y, width, height);
 414 }
 415
 416 GLvoid StubGLShaderSource(GLuint shader, GLsizei count, const char* const* str,
 417                           const GLint* length) {
 418   glShaderSource(shader, count, str, length);
 419 }
 420
 421 GLvoid StubGLStencilFunc(GLenum func, GLint ref, GLuint mask) {
 422   glStencilFunc(func, ref, mask);
 423 }
 424
 425 GLvoid StubGLStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
 426                                  GLuint mask) {
 427   glStencilFuncSeparate(face, func, ref, mask);
 428 }
 429
 430 GLvoid StubGLStencilMask(GLuint mask) {
 431   glStencilMask(mask);
 432 }
 433
 434 GLvoid StubGLStencilMaskSeparate(GLenum face, GLuint mask) {
 435   glStencilMaskSeparate(face, mask);
 436 }
 437
 438 GLvoid StubGLStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 439   glStencilOp(fail, zfail, zpass);
 440 }
 441
 442 GLvoid StubGLStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
 443                                GLenum zpass) {
 444   glStencilOpSeparate(face, fail, zfail, zpass);
 445 }
 446
 447 GLvoid StubGLTexImage2D(GLenum target, GLint level, GLint internalformat,
 448                         GLsizei width, GLsizei height, GLint border,
 449                         GLenum format, GLenum type, const void* pixels) {
 450   glTexImage2D(target, level, internalformat, width, height, border, format,
 451                type, pixels);
 452 }
 453
 454 GLvoid StubGLTexParameteri(GLenum target, GLenum pname, GLint param) {
 455   glTexParameteri(target, pname, param);
 456 }
 457
 458 GLvoid StubGLTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
 459   glTexParameteriv(target, pname, params);
 460 }
 461
 462 GLvoid StubGLTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat,
 463                           GLsizei width, GLsizei height) {
 464   glTexStorage2DEXT(target, levels, internalFormat, width, height);
 465 }
 466
 467 GLvoid StubGLTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 468                            GLint yoffset, GLsizei width, GLsizei height,
 469                            GLenum format, GLenum type, const void* pixels) {
 470   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
 471                   pixels);
 472 }
 473
 474 GLvoid StubGLUniform1f(GLint location, GLfloat v) {
 475   glUniform1f(location, v);
 476 }
 477
 478 GLvoid StubGLUniform1i(GLint location, GLint v) {
 479   glUniform1i(location, v);
 480 }
 481
 482 GLvoid StubGLUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
 483   glUniform1fv(location, count, v);
 484 }
 485
 486 GLvoid StubGLUniform1iv(GLint location, GLsizei count, const GLint* v) {
 487   glUniform1iv(location, count, v);
 488 }
 489
 490 GLvoid StubGLUniform2f(GLint location, GLfloat v0, GLfloat v1) {
 491   glUniform2f(location, v0, v1);
 492 }
 493
 494 GLvoid StubGLUniform2i(GLint location, GLint v0, GLint v1) {
 495   glUniform2i(location, v0, v1);
 496 }
 497
 498 GLvoid StubGLUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
 499   glUniform2fv(location, count, v);
 500 }
 501
 502 GLvoid StubGLUniform2iv(GLint location, GLsizei count, const GLint* v) {
 503   glUniform2iv(location, count, v);
 504 }
 505
 506 GLvoid StubGLUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
 507   glUniform3f(location, v0, v1, v2);
 508 }
 509
 510 GLvoid StubGLUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
 511   glUniform3i(location, v0, v1, v2);
 512 }
 513
 514 GLvoid StubGLUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
 515   glUniform3fv(location, count, v);
 516 }
 517
 518 GLvoid StubGLUniform3iv(GLint location, GLsizei count, const GLint* v) {
 519   glUniform3iv(location, count, v);
 520 }
 521
 522 GLvoid StubGLUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
 523                        GLfloat v3) {
 524   glUniform4f(location, v0, v1, v2, v3);
 525 }
 526
 527 GLvoid StubGLUniform4i(GLint location, GLint v0, GLint v1, GLint v2,
 528                        GLint v3) {
 529   glUniform4i(location, v0, v1, v2, v3);
 530 }
 531
 532 GLvoid StubGLUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
 533   glUniform4fv(location, count, v);
 534 }
 535
 536 GLvoid StubGLUniform4iv(GLint location, GLsizei count, const GLint* v) {
 537   glUniform4iv(location, count, v);
 538 }
 539
 540 GLvoid StubGLUniformMatrix2fv(GLint location, GLsizei count,
 541                               GLboolean transpose, const GLfloat* value) {
 542   glUniformMatrix2fv(location, count, transpose, value);
 543 }
 544
 545 GLvoid StubGLUniformMatrix3fv(GLint location, GLsizei count,
 546                               GLboolean transpose, const GLfloat* value) {
 547   glUniformMatrix3fv(location, count, transpose, value);
 548 }
 549
 550 GLvoid StubGLUniformMatrix4fv(GLint location, GLsizei count,
 551                               GLboolean transpose, const GLfloat* value) {
 552   glUniformMatrix4fv(location, count, transpose, value);
 553 }
 554
 555 GLboolean StubGLUnmapBuffer(GLenum target) {
 556   return glUnmapBuffer(target);
 557 }
 558
 559 GLvoid StubGLUseProgram(GLuint program) {
 560   glUseProgram(program);
 561 }
 562
 563 GLvoid StubGLVertexAttrib1f(GLuint indx, const GLfloat value) {
 564   glVertexAttrib1f(indx, value);
 565 }
 566
 567 GLvoid StubGLVertexAttrib2fv(GLuint indx, const GLfloat* values) {
 568   glVertexAttrib2fv(indx, values);
 569 }
 570
 571 GLvoid StubGLVertexAttrib3fv(GLuint indx, const GLfloat* values) {
 572   glVertexAttrib3fv(indx, values);
 573 }
 574
 575 GLvoid StubGLVertexAttrib4fv(GLuint indx, const GLfloat* values) {
 576   glVertexAttrib4fv(indx, values);
 577 }
 578
 579 GLvoid StubGLVertexAttribPointer(GLuint indx, GLint size, GLenum type,
 580                                  GLboolean normalized, GLsizei stride,
 581                                  const void* ptr) {
 582   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 583 }
 584
 585 GLvoid StubGLViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
 586   glViewport(x, y, width, height);
 587 }
 588 }  // extern "C"
 589 }  // namespace
 590
 591 namespace gfx {
 592
 593 GrGLInterface* CreateInProcessSkiaGLBinding() {
 594   GrGLStandard standard;
 595   switch (gfx::GetGLImplementation()) {
 596     case gfx::kGLImplementationNone:
 597       NOTREACHED();
 598       return NULL;
 599     case gfx::kGLImplementationDesktopGL:
 600     case gfx::kGLImplementationAppleGL:
 601       standard = kGL_GrGLStandard;
 602       break;
 603     case gfx::kGLImplementationOSMesaGL:
 604       standard = kGL_GrGLStandard;
 605       break;
 606     case gfx::kGLImplementationEGLGLES2:
 607       standard = kGLES_GrGLStandard;
 608       break;
 609     case gfx::kGLImplementationMockGL:
 610       NOTREACHED();
 611       return NULL;
 612     default:
 613       NOTREACHED();
 614       return NULL;
 615   }
 616
 617   GrGLInterface* interface = new GrGLInterface;
 618   interface->fStandard = standard;
 619   interface->fExtensions.init(standard,
 620                               StubGLGetString,
 621                               NULL,
 622                               StubGLGetIntegerv);
 623
 624   GrGLInterface::Functions* functions = &interface->fFunctions;
 625   functions->fActiveTexture = StubGLActiveTexture;
 626   functions->fAttachShader = StubGLAttachShader;
 627   functions->fBeginQuery = StubGLBeginQuery;
 628   functions->fBindAttribLocation = StubGLBindAttribLocation;
 629   functions->fBindBuffer = StubGLBindBuffer;
 630   functions->fBindFragDataLocation = StubGLBindFragDataLocation;
 631   functions->fBindTexture = StubGLBindTexture;
 632   functions->fBindVertexArray = StubGLBindVertexArray;
 633   functions->fBlendColor = StubGLBlendColor;
 634   functions->fBlendFunc = StubGLBlendFunc;
 635   functions->fBufferData = StubGLBufferData;
 636   functions->fBufferSubData = StubGLBufferSubData;
 637   functions->fClear = StubGLClear;
 638   functions->fClearColor = StubGLClearColor;
 639   functions->fClearStencil = StubGLClearStencil;
 640   functions->fColorMask = StubGLColorMask;
 641   functions->fCompileShader = StubGLCompileShader;
 642   functions->fCompressedTexImage2D = StubGLCompressedTexImage2D;
 643   functions->fCopyTexSubImage2D = StubGLCopyTexSubImage2D;
 644   functions->fCreateProgram = StubGLCreateProgram;
 645   functions->fCreateShader = StubGLCreateShader;
 646   functions->fCullFace = StubGLCullFace;
 647   functions->fDeleteBuffers = StubGLDeleteBuffers;
 648   functions->fDeleteProgram = StubGLDeleteProgram;
 649   functions->fDeleteQueries = StubGLDeleteQueries;
 650   functions->fDeleteShader = StubGLDeleteShader;
 651   functions->fDeleteTextures = StubGLDeleteTextures;
 652   functions->fDeleteVertexArrays = StubGLDeleteVertexArrays;
 653   functions->fDepthMask = StubGLDepthMask;
 654   functions->fDisable = StubGLDisable;
 655   functions->fDisableVertexAttribArray = StubGLDisableVertexAttribArray;
 656   functions->fDiscardFramebuffer = StubGLDiscardFramebuffer;
 657   functions->fDrawArrays = StubGLDrawArrays;
 658   functions->fDrawBuffer = StubGLDrawBuffer;
 659   functions->fDrawBuffers = StubGLDrawBuffers;
 660   functions->fDrawElements = StubGLDrawElements;
 661   functions->fEnable = StubGLEnable;
 662   functions->fEnableVertexAttribArray = StubGLEnableVertexAttribArray;
 663   functions->fEndQuery = StubGLEndQuery;
 664   functions->fFinish = StubGLFinish;
 665   functions->fFlush = StubGLFlush;
 666   functions->fFrontFace = StubGLFrontFace;
 667   functions->fGenBuffers = StubGLGenBuffers;
 668   functions->fGenQueries = StubGLGenQueries;
 669   functions->fGenTextures = StubGLGenTextures;
 670   functions->fGenVertexArrays = StubGLGenVertexArrays;
 671   functions->fGetBufferParameteriv = StubGLGetBufferParameteriv;
 672   functions->fGetError = StubGLGetError;
 673   functions->fGetIntegerv = StubGLGetIntegerv;
 674   functions->fGetQueryiv = StubGLGetQueryiv;
 675   functions->fGetQueryObjecti64v = StubGLGetQueryObjecti64v;
 676   functions->fGetQueryObjectiv = StubGLGetQueryObjectiv;
 677   functions->fGetQueryObjectui64v = StubGLGetQueryObjectui64v;
 678   functions->fGetQueryObjectuiv = StubGLGetQueryObjectuiv;
 679   functions->fGetProgramInfoLog = StubGLGetProgramInfoLog;
 680   functions->fGetProgramiv = StubGLGetProgramiv;
 681   functions->fGetShaderInfoLog = StubGLGetShaderInfoLog;
 682   functions->fGetShaderiv = StubGLGetShaderiv;
 683   functions->fGetShaderPrecisionFormat = StubGLGetShaderPrecisionFormat;
 684   functions->fGetString = StubGLGetString;
 685   functions->fGetTexLevelParameteriv = StubGLGetTexLevelParameteriv;
 686   functions->fGetUniformLocation = StubGLGetUniformLocation;
 687   functions->fInsertEventMarker = StubGLInsertEventMarker;
 688   functions->fLineWidth = StubGLLineWidth;
 689   functions->fLinkProgram = StubGLLinkProgram;
 690   functions->fPixelStorei = StubGLPixelStorei;
 691   functions->fPopGroupMarker = StubGLPopGroupMarker;
 692   functions->fPushGroupMarker = StubGLPushGroupMarker;
 693   functions->fQueryCounter = StubGLQueryCounter;
 694   functions->fReadBuffer = StubGLReadBuffer;
 695   functions->fReadPixels = StubGLReadPixels;
 696   functions->fScissor = StubGLScissor;
 697   functions->fShaderSource = StubGLShaderSource;
 698   functions->fStencilFunc = StubGLStencilFunc;
 699   functions->fStencilFuncSeparate = StubGLStencilFuncSeparate;
 700   functions->fStencilMask = StubGLStencilMask;
 701   functions->fStencilMaskSeparate = StubGLStencilMaskSeparate;
 702   functions->fStencilOp = StubGLStencilOp;
 703   functions->fStencilOpSeparate = StubGLStencilOpSeparate;
 704   functions->fTexImage2D = StubGLTexImage2D;
 705   functions->fTexParameteri = StubGLTexParameteri;
 706   functions->fTexParameteriv = StubGLTexParameteriv;
 707   functions->fTexSubImage2D = StubGLTexSubImage2D;
 708   functions->fTexStorage2D = StubGLTexStorage2D;
 709   functions->fUniform1f = StubGLUniform1f;
 710   functions->fUniform1i = StubGLUniform1i;
 711   functions->fUniform1fv = StubGLUniform1fv;
 712   functions->fUniform1iv = StubGLUniform1iv;
 713   functions->fUniform2f = StubGLUniform2f;
 714   functions->fUniform2i = StubGLUniform2i;
 715   functions->fUniform2fv = StubGLUniform2fv;
 716   functions->fUniform2iv = StubGLUniform2iv;
 717   functions->fUniform3f = StubGLUniform3f;
 718   functions->fUniform3i = StubGLUniform3i;
 719   functions->fUniform3fv = StubGLUniform3fv;
 720   functions->fUniform3iv = StubGLUniform3iv;
 721   functions->fUniform4f = StubGLUniform4f;
 722   functions->fUniform4i = StubGLUniform4i;
 723   functions->fUniform4fv = StubGLUniform4fv;
 724   functions->fUniform4iv = StubGLUniform4iv;
 725   functions->fUniformMatrix2fv = StubGLUniformMatrix2fv;
 726   functions->fUniformMatrix3fv = StubGLUniformMatrix3fv;
 727   functions->fUniformMatrix4fv = StubGLUniformMatrix4fv;
 728   functions->fUseProgram = StubGLUseProgram;
 729   functions->fVertexAttrib1f = StubGLVertexAttrib1f;
 730   functions->fVertexAttrib2fv = StubGLVertexAttrib2fv;
 731   functions->fVertexAttrib3fv = StubGLVertexAttrib3fv;
 732   functions->fVertexAttrib4fv = StubGLVertexAttrib4fv;
 733   functions->fVertexAttribPointer = StubGLVertexAttribPointer;
 734   functions->fViewport = StubGLViewport;
 735   functions->fBindFramebuffer = StubGLBindFramebuffer;
 736   functions->fBindRenderbuffer = StubGLBindRenderbuffer;
 737   functions->fCheckFramebufferStatus = StubGLCheckFramebufferStatus;
 738   functions->fDeleteFramebuffers = StubGLDeleteFramebuffers;
 739   functions->fDeleteRenderbuffers = StubGLDeleteRenderbuffers;
 740   functions->fFramebufferRenderbuffer = StubGLFramebufferRenderbuffer;
 741   functions->fFramebufferTexture2D = StubGLFramebufferTexture2D;
 742   functions->fFramebufferTexture2DMultisample =
 743     StubGLFramebufferTexture2DMultisample;
 744   functions->fGenFramebuffers = StubGLGenFramebuffers;
 745   functions->fGenRenderbuffers = StubGLGenRenderbuffers;
 746   functions->fGetFramebufferAttachmentParameteriv =
 747     StubGLGetFramebufferAttachmentParameteriv;
 748   functions->fGetRenderbufferParameteriv = StubGLGetRenderbufferParameteriv;
 749   functions->fRenderbufferStorage = StubGLRenderbufferStorage;
 750   functions->fRenderbufferStorageMultisample =
 751     StubGLRenderbufferStorageMultisample;
 752   functions->fBlitFramebuffer = StubGLBlitFramebuffer;
 753   functions->fMapBuffer = StubGLMapBuffer;
 754   functions->fUnmapBuffer = StubGLUnmapBuffer;
 755   functions->fBindFragDataLocationIndexed =
 756     StubGLBindFragDataLocationIndexed;
 757
 758   return interface;
 759 }
 760
 761 }  // namespace gfx