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 StubGLFlushMappedBufferRange(GLenum target, GLintptr offset,
 233                                     GLsizeiptr length) {
 234   glFlushMappedBufferRange(target, offset, length);
 235 }
 236
 237 GLvoid StubGLFramebufferRenderbuffer(GLenum target, GLenum attachment,
 238                                      GLenum renderbuffertarget,
 239                                      GLuint renderbuffer) {
 240   glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
 241                                renderbuffer);
 242 }
 243
 244 GLvoid StubGLFramebufferTexture2D(GLenum target, GLenum attachment,
 245                                   GLenum textarget, GLuint texture,
 246                                   GLint level) {
 247   glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
 248 }
 249
 250 GLvoid StubGLFramebufferTexture2DMultisample(GLenum target, GLenum attachment,
 251                                   GLenum textarget, GLuint texture,
 252                                   GLint level, GLsizei samples) {
 253   glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture,
 254       level, samples);
 255 }
 256
 257 GLvoid StubGLFrontFace(GLenum mode) {
 258   glFrontFace(mode);
 259 }
 260
 261 GLvoid StubGLGenBuffers(GLsizei n, GLuint* buffers) {
 262   glGenBuffersARB(n, buffers);
 263 }
 264
 265 GLvoid StubGLGenFramebuffers(GLsizei n, GLuint* framebuffers) {
 266   glGenFramebuffersEXT(n, framebuffers);
 267 }
 268
 269 GLvoid StubGLGenQueries(GLsizei n, GLuint* ids) {
 270   glGenQueries(n, ids);
 271 }
 272
 273 GLvoid StubGLGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 274   glGenRenderbuffersEXT(n, renderbuffers);
 275 }
 276
 277 GLvoid StubGLGenTextures(GLsizei n, GLuint* textures) {
 278   glGenTextures(n, textures);
 279 }
 280
 281 GLvoid StubGLGenVertexArrays(GLsizei n, GLuint* arrays) {
 282   glGenVertexArraysOES(n, arrays);
 283 }
 284
 285 GLvoid StubGLGenerateMipmap(GLenum target){
 286   glGenerateMipmapEXT(target);
 287 }
 288
 289 GLvoid StubGLGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
 290   glGetBufferParameteriv(target, pname, params);
 291 }
 292
 293 GLvoid StubGLGetFramebufferAttachmentParameteriv(GLenum target,
 294                                                  GLenum attachment,
 295                                                  GLenum pname, GLint* params) {
 296   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
 297 }
 298
 299 GLenum StubGLGetError() {
 300   return glGetError();
 301 }
 302
 303 GLvoid StubGLGetIntegerv(GLenum pname, GLint* params) {
 304   glGetIntegerv(pname, params);
 305 }
 306
 307 GLvoid StubGLGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length,
 308                                char* infolog) {
 309   glGetProgramInfoLog(program, bufsize, length, infolog);
 310 }
 311
 312 GLvoid StubGLGetProgramiv(GLuint program, GLenum pname, GLint* params) {
 313   glGetProgramiv(program, pname, params);
 314 }
 315
 316 GLvoid StubGLGetRenderbufferParameteriv(GLenum target,
 317                                         GLenum pname, GLint* params) {
 318   glGetRenderbufferParameterivEXT(target, pname, params);
 319 }
 320
 321 GLvoid StubGLGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length,
 322                               char* infolog) {
 323   glGetShaderInfoLog(shader, bufsize, length, infolog);
 324 }
 325
 326 GLvoid StubGLGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 327   glGetShaderiv(shader, pname, params);
 328 }
 329
 330 GLvoid StubGLGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
 331                                       GLint *range, GLint *precision) {
 332   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 333 }
 334
 335 const GLubyte* StubGLGetString(GLenum name) {
 336   return glGetString(name);
 337 }
 338
 339 const GLubyte* StubGLGetStringi(GLenum name, GLuint index) {
 340   return glGetStringi(name, index);
 341 }
 342
 343 GLvoid StubGLGetQueryiv(GLenum target, GLenum pname, GLint* params) {
 344   glGetQueryiv(target, pname, params);
 345 }
 346
 347 GLvoid StubGLGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
 348   glGetQueryObjecti64v(id, pname, params);
 349 }
 350
 351 GLvoid StubGLGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
 352   glGetQueryObjectiv(id, pname, params);
 353 }
 354
 355 GLvoid StubGLGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
 356   glGetQueryObjectui64v(id, pname, params);
 357 }
 358
 359 GLvoid StubGLGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
 360   glGetQueryObjectuiv(id, pname, params);
 361 }
 362
 363 GLvoid StubGLGetTexLevelParameteriv(GLenum target, GLint level,
 364                                     GLenum pname, GLint* params) {
 365   glGetTexLevelParameteriv(target, level, pname, params);
 366 }
 367
 368 GLint StubGLGetUniformLocation(GLuint program, const char* name) {
 369   return glGetUniformLocation(program, name);
 370 }
 371
 372 GLvoid StubGLInsertEventMarker(GLsizei length, const char* marker) {
 373   glInsertEventMarkerEXT(length, marker);
 374 }
 375
 376 GLvoid StubGLInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
 377                                    const GLenum* attachments) {
 378   glInvalidateFramebuffer(target, numAttachments, attachments);
 379 }
 380
 381 GLvoid StubGLInvalidateSubFramebuffer(GLenum target,
 382                                       GLsizei numAttachments,
 383                                       const GLenum* attachments,
 384                                       GLint x, GLint y,
 385                                       GLsizei width, GLsizei height) {
 386   glInvalidateSubFramebuffer(target, numAttachments, attachments,
 387                              x, y, width, height);
 388 }
 389
 390 GLvoid StubGLLineWidth(GLfloat width) {
 391   glLineWidth(width);
 392 }
 393
 394 GLvoid StubGLLinkProgram(GLuint program) {
 395   glLinkProgram(program);
 396 }
 397
 398 void* StubGLMapBuffer(GLenum target, GLenum access) {
 399   return glMapBuffer(target, access);
 400 }
 401
 402 void* StubGLMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
 403                            GLbitfield access) {
 404   return glMapBufferRange(target, offset, length, access);
 405 }
 406
 407 GLvoid StubGLPixelStorei(GLenum pname, GLint param) {
 408   glPixelStorei(pname, param);
 409 }
 410
 411 GLvoid StubGLPopGroupMarker() {
 412   glPopGroupMarkerEXT();
 413 }
 414
 415 GLvoid StubGLPushGroupMarker(GLsizei length, const char* marker) {
 416   glPushGroupMarkerEXT(length, marker);
 417 }
 418
 419 GLvoid StubGLQueryCounter(GLuint id, GLenum target) {
 420   glQueryCounter(id, target);
 421 }
 422
 423 GLvoid StubGLReadBuffer(GLenum src) {
 424   glReadBuffer(src);
 425 }
 426
 427 GLvoid StubGLReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
 428                         GLenum format, GLenum type, void* pixels) {
 429   glReadPixels(x, y, width, height, format, type, pixels);
 430 }
 431
 432 GLvoid StubGLRenderbufferStorage(GLenum target, GLenum internalformat,
 433                                  GLsizei width, GLsizei height) {
 434   glRenderbufferStorageEXT(target, internalformat, width, height);
 435 }
 436
 437 GLvoid StubGLRenderbufferStorageMultisample(GLenum target, GLsizei samples,
 438                                             GLenum internalformat,
 439                                             GLsizei width, GLsizei height) {
 440   glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
 441                                       height);
 442 }
 443
 444 GLvoid StubGLScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 445   glScissor(x, y, width, height);
 446 }
 447
 448 GLvoid StubGLShaderSource(GLuint shader, GLsizei count, const char* const* str,
 449                           const GLint* length) {
 450   glShaderSource(shader, count, str, length);
 451 }
 452
 453 GLvoid StubGLStencilFunc(GLenum func, GLint ref, GLuint mask) {
 454   glStencilFunc(func, ref, mask);
 455 }
 456
 457 GLvoid StubGLStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
 458                                  GLuint mask) {
 459   glStencilFuncSeparate(face, func, ref, mask);
 460 }
 461
 462 GLvoid StubGLStencilMask(GLuint mask) {
 463   glStencilMask(mask);
 464 }
 465
 466 GLvoid StubGLStencilMaskSeparate(GLenum face, GLuint mask) {
 467   glStencilMaskSeparate(face, mask);
 468 }
 469
 470 GLvoid StubGLStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 471   glStencilOp(fail, zfail, zpass);
 472 }
 473
 474 GLvoid StubGLStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
 475                                GLenum zpass) {
 476   glStencilOpSeparate(face, fail, zfail, zpass);
 477 }
 478
 479 GLvoid StubGLTexImage2D(GLenum target, GLint level, GLint internalformat,
 480                         GLsizei width, GLsizei height, GLint border,
 481                         GLenum format, GLenum type, const void* pixels) {
 482   glTexImage2D(target, level, internalformat, width, height, border, format,
 483                type, pixels);
 484 }
 485
 486 GLvoid StubGLTexParameteri(GLenum target, GLenum pname, GLint param) {
 487   glTexParameteri(target, pname, param);
 488 }
 489
 490 GLvoid StubGLTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
 491   glTexParameteriv(target, pname, params);
 492 }
 493
 494 GLvoid StubGLTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat,
 495                           GLsizei width, GLsizei height) {
 496   glTexStorage2DEXT(target, levels, internalFormat, width, height);
 497 }
 498
 499 GLvoid StubGLTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 500                            GLint yoffset, GLsizei width, GLsizei height,
 501                            GLenum format, GLenum type, const void* pixels) {
 502   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
 503                   pixels);
 504 }
 505
 506 GLvoid StubGLUniform1f(GLint location, GLfloat v) {
 507   glUniform1f(location, v);
 508 }
 509
 510 GLvoid StubGLUniform1i(GLint location, GLint v) {
 511   glUniform1i(location, v);
 512 }
 513
 514 GLvoid StubGLUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
 515   glUniform1fv(location, count, v);
 516 }
 517
 518 GLvoid StubGLUniform1iv(GLint location, GLsizei count, const GLint* v) {
 519   glUniform1iv(location, count, v);
 520 }
 521
 522 GLvoid StubGLUniform2f(GLint location, GLfloat v0, GLfloat v1) {
 523   glUniform2f(location, v0, v1);
 524 }
 525
 526 GLvoid StubGLUniform2i(GLint location, GLint v0, GLint v1) {
 527   glUniform2i(location, v0, v1);
 528 }
 529
 530 GLvoid StubGLUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
 531   glUniform2fv(location, count, v);
 532 }
 533
 534 GLvoid StubGLUniform2iv(GLint location, GLsizei count, const GLint* v) {
 535   glUniform2iv(location, count, v);
 536 }
 537
 538 GLvoid StubGLUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
 539   glUniform3f(location, v0, v1, v2);
 540 }
 541
 542 GLvoid StubGLUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
 543   glUniform3i(location, v0, v1, v2);
 544 }
 545
 546 GLvoid StubGLUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
 547   glUniform3fv(location, count, v);
 548 }
 549
 550 GLvoid StubGLUniform3iv(GLint location, GLsizei count, const GLint* v) {
 551   glUniform3iv(location, count, v);
 552 }
 553
 554 GLvoid StubGLUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
 555                        GLfloat v3) {
 556   glUniform4f(location, v0, v1, v2, v3);
 557 }
 558
 559 GLvoid StubGLUniform4i(GLint location, GLint v0, GLint v1, GLint v2,
 560                        GLint v3) {
 561   glUniform4i(location, v0, v1, v2, v3);
 562 }
 563
 564 GLvoid StubGLUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
 565   glUniform4fv(location, count, v);
 566 }
 567
 568 GLvoid StubGLUniform4iv(GLint location, GLsizei count, const GLint* v) {
 569   glUniform4iv(location, count, v);
 570 }
 571
 572 GLvoid StubGLUniformMatrix2fv(GLint location, GLsizei count,
 573                               GLboolean transpose, const GLfloat* value) {
 574   glUniformMatrix2fv(location, count, transpose, value);
 575 }
 576
 577 GLvoid StubGLUniformMatrix3fv(GLint location, GLsizei count,
 578                               GLboolean transpose, const GLfloat* value) {
 579   glUniformMatrix3fv(location, count, transpose, value);
 580 }
 581
 582 GLvoid StubGLUniformMatrix4fv(GLint location, GLsizei count,
 583                               GLboolean transpose, const GLfloat* value) {
 584   glUniformMatrix4fv(location, count, transpose, value);
 585 }
 586
 587 GLboolean StubGLUnmapBuffer(GLenum target) {
 588   return glUnmapBuffer(target);
 589 }
 590
 591 GLvoid StubGLUseProgram(GLuint program) {
 592   glUseProgram(program);
 593 }
 594
 595 GLvoid StubGLVertexAttrib1f(GLuint indx, const GLfloat value) {
 596   glVertexAttrib1f(indx, value);
 597 }
 598
 599 GLvoid StubGLVertexAttrib2fv(GLuint indx, const GLfloat* values) {
 600   glVertexAttrib2fv(indx, values);
 601 }
 602
 603 GLvoid StubGLVertexAttrib3fv(GLuint indx, const GLfloat* values) {
 604   glVertexAttrib3fv(indx, values);
 605 }
 606
 607 GLvoid StubGLVertexAttrib4fv(GLuint indx, const GLfloat* values) {
 608   glVertexAttrib4fv(indx, values);
 609 }
 610
 611 GLvoid StubGLVertexAttribPointer(GLuint indx, GLint size, GLenum type,
 612                                  GLboolean normalized, GLsizei stride,
 613                                  const void* ptr) {
 614   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 615 }
 616
 617 GLvoid StubGLViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
 618   glViewport(x, y, width, height);
 619 }
 620
 621 GLint StubGLGetProgramResourceLocation(GLuint program,
 622                                        GLenum programInterface,
 623                                        const char* name) {
 624   return glGetProgramResourceLocation(program, programInterface, name);
 625 }
 626
 627 }  // extern "C"
 628 }  // namespace
 629
 630 namespace gfx {
 631
 632 GrGLInterface* CreateInProcessSkiaGLBinding() {
 633   GrGLStandard standard;
 634   switch (gfx::GetGLImplementation()) {
 635     case gfx::kGLImplementationNone:
 636       NOTREACHED();
 637       return NULL;
 638     case gfx::kGLImplementationDesktopGL:
 639     case gfx::kGLImplementationAppleGL:
 640       standard = kGL_GrGLStandard;
 641       break;
 642     case gfx::kGLImplementationOSMesaGL:
 643       standard = kGL_GrGLStandard;
 644       break;
 645     case gfx::kGLImplementationEGLGLES2:
 646       standard = kGLES_GrGLStandard;
 647       break;
 648     case gfx::kGLImplementationMockGL:
 649       NOTREACHED();
 650       return NULL;
 651     default:
 652       NOTREACHED();
 653       return NULL;
 654   }
 655
 656   GrGLInterface* interface = new GrGLInterface;
 657   interface->fStandard = standard;
 658   interface->fExtensions.init(standard,
 659                               StubGLGetString,
 660                               StubGLGetStringi,
 661                               StubGLGetIntegerv);
 662
 663   GrGLInterface::Functions* functions = &interface->fFunctions;
 664   functions->fActiveTexture = StubGLActiveTexture;
 665   functions->fAttachShader = StubGLAttachShader;
 666   functions->fBeginQuery = StubGLBeginQuery;
 667   functions->fBindAttribLocation = StubGLBindAttribLocation;
 668   functions->fBindBuffer = StubGLBindBuffer;
 669   functions->fBindFragDataLocation = StubGLBindFragDataLocation;
 670   functions->fBindTexture = StubGLBindTexture;
 671   functions->fBindVertexArray = StubGLBindVertexArray;
 672   functions->fBlendColor = StubGLBlendColor;
 673   functions->fBlendFunc = StubGLBlendFunc;
 674   functions->fBufferData = StubGLBufferData;
 675   functions->fBufferSubData = StubGLBufferSubData;
 676   functions->fClear = StubGLClear;
 677   functions->fClearColor = StubGLClearColor;
 678   functions->fClearStencil = StubGLClearStencil;
 679   functions->fColorMask = StubGLColorMask;
 680   functions->fCompileShader = StubGLCompileShader;
 681   functions->fCompressedTexImage2D = StubGLCompressedTexImage2D;
 682   functions->fCopyTexSubImage2D = StubGLCopyTexSubImage2D;
 683   functions->fCreateProgram = StubGLCreateProgram;
 684   functions->fCreateShader = StubGLCreateShader;
 685   functions->fCullFace = StubGLCullFace;
 686   functions->fDeleteBuffers = StubGLDeleteBuffers;
 687   functions->fDeleteProgram = StubGLDeleteProgram;
 688   functions->fDeleteQueries = StubGLDeleteQueries;
 689   functions->fDeleteShader = StubGLDeleteShader;
 690   functions->fDeleteTextures = StubGLDeleteTextures;
 691   functions->fDeleteVertexArrays = StubGLDeleteVertexArrays;
 692   functions->fDepthMask = StubGLDepthMask;
 693   functions->fDisable = StubGLDisable;
 694   functions->fDisableVertexAttribArray = StubGLDisableVertexAttribArray;
 695   functions->fDiscardFramebuffer = StubGLDiscardFramebuffer;
 696   functions->fDrawArrays = StubGLDrawArrays;
 697   functions->fDrawBuffer = StubGLDrawBuffer;
 698   functions->fDrawBuffers = StubGLDrawBuffers;
 699   functions->fDrawElements = StubGLDrawElements;
 700   functions->fEnable = StubGLEnable;
 701   functions->fEnableVertexAttribArray = StubGLEnableVertexAttribArray;
 702   functions->fEndQuery = StubGLEndQuery;
 703   functions->fFinish = StubGLFinish;
 704   functions->fFlush = StubGLFlush;
 705   functions->fFlushMappedBufferRange = StubGLFlushMappedBufferRange;
 706   functions->fFrontFace = StubGLFrontFace;
 707   functions->fGenBuffers = StubGLGenBuffers;
 708   functions->fGenQueries = StubGLGenQueries;
 709   functions->fGenTextures = StubGLGenTextures;
 710   functions->fGenVertexArrays = StubGLGenVertexArrays;
 711   functions->fGenerateMipmap = StubGLGenerateMipmap;
 712   functions->fGetBufferParameteriv = StubGLGetBufferParameteriv;
 713   functions->fGetError = StubGLGetError;
 714   functions->fGetIntegerv = StubGLGetIntegerv;
 715   functions->fGetQueryiv = StubGLGetQueryiv;
 716   functions->fGetQueryObjecti64v = StubGLGetQueryObjecti64v;
 717   functions->fGetQueryObjectiv = StubGLGetQueryObjectiv;
 718   functions->fGetQueryObjectui64v = StubGLGetQueryObjectui64v;
 719   functions->fGetQueryObjectuiv = StubGLGetQueryObjectuiv;
 720   functions->fGetProgramInfoLog = StubGLGetProgramInfoLog;
 721   functions->fGetProgramiv = StubGLGetProgramiv;
 722   functions->fGetShaderInfoLog = StubGLGetShaderInfoLog;
 723   functions->fGetShaderiv = StubGLGetShaderiv;
 724   functions->fGetShaderPrecisionFormat = StubGLGetShaderPrecisionFormat;
 725   functions->fGetString = StubGLGetString;
 726   functions->fGetStringi = StubGLGetStringi;
 727   functions->fGetTexLevelParameteriv = StubGLGetTexLevelParameteriv;
 728   functions->fGetUniformLocation = StubGLGetUniformLocation;
 729   functions->fInsertEventMarker = StubGLInsertEventMarker;
 730   functions->fInvalidateFramebuffer = StubGLInvalidateFramebuffer;
 731   functions->fInvalidateSubFramebuffer = StubGLInvalidateSubFramebuffer;
 732   functions->fLineWidth = StubGLLineWidth;
 733   functions->fLinkProgram = StubGLLinkProgram;
 734   functions->fMapBufferRange = StubGLMapBufferRange;
 735   functions->fPixelStorei = StubGLPixelStorei;
 736   functions->fPopGroupMarker = StubGLPopGroupMarker;
 737   functions->fPushGroupMarker = StubGLPushGroupMarker;
 738   functions->fQueryCounter = StubGLQueryCounter;
 739   functions->fReadBuffer = StubGLReadBuffer;
 740   functions->fReadPixels = StubGLReadPixels;
 741   functions->fScissor = StubGLScissor;
 742   functions->fShaderSource = StubGLShaderSource;
 743   functions->fStencilFunc = StubGLStencilFunc;
 744   functions->fStencilFuncSeparate = StubGLStencilFuncSeparate;
 745   functions->fStencilMask = StubGLStencilMask;
 746   functions->fStencilMaskSeparate = StubGLStencilMaskSeparate;
 747   functions->fStencilOp = StubGLStencilOp;
 748   functions->fStencilOpSeparate = StubGLStencilOpSeparate;
 749   functions->fTexImage2D = StubGLTexImage2D;
 750   functions->fTexParameteri = StubGLTexParameteri;
 751   functions->fTexParameteriv = StubGLTexParameteriv;
 752   functions->fTexSubImage2D = StubGLTexSubImage2D;
 753   functions->fTexStorage2D = StubGLTexStorage2D;
 754   functions->fUniform1f = StubGLUniform1f;
 755   functions->fUniform1i = StubGLUniform1i;
 756   functions->fUniform1fv = StubGLUniform1fv;
 757   functions->fUniform1iv = StubGLUniform1iv;
 758   functions->fUniform2f = StubGLUniform2f;
 759   functions->fUniform2i = StubGLUniform2i;
 760   functions->fUniform2fv = StubGLUniform2fv;
 761   functions->fUniform2iv = StubGLUniform2iv;
 762   functions->fUniform3f = StubGLUniform3f;
 763   functions->fUniform3i = StubGLUniform3i;
 764   functions->fUniform3fv = StubGLUniform3fv;
 765   functions->fUniform3iv = StubGLUniform3iv;
 766   functions->fUniform4f = StubGLUniform4f;
 767   functions->fUniform4i = StubGLUniform4i;
 768   functions->fUniform4fv = StubGLUniform4fv;
 769   functions->fUniform4iv = StubGLUniform4iv;
 770   functions->fUniformMatrix2fv = StubGLUniformMatrix2fv;
 771   functions->fUniformMatrix3fv = StubGLUniformMatrix3fv;
 772   functions->fUniformMatrix4fv = StubGLUniformMatrix4fv;
 773   functions->fUseProgram = StubGLUseProgram;
 774   functions->fVertexAttrib1f = StubGLVertexAttrib1f;
 775   functions->fVertexAttrib2fv = StubGLVertexAttrib2fv;
 776   functions->fVertexAttrib3fv = StubGLVertexAttrib3fv;
 777   functions->fVertexAttrib4fv = StubGLVertexAttrib4fv;
 778   functions->fVertexAttribPointer = StubGLVertexAttribPointer;
 779   functions->fViewport = StubGLViewport;
 780   functions->fBindFramebuffer = StubGLBindFramebuffer;
 781   functions->fBindRenderbuffer = StubGLBindRenderbuffer;
 782   functions->fCheckFramebufferStatus = StubGLCheckFramebufferStatus;
 783   functions->fDeleteFramebuffers = StubGLDeleteFramebuffers;
 784   functions->fDeleteRenderbuffers = StubGLDeleteRenderbuffers;
 785   functions->fFramebufferRenderbuffer = StubGLFramebufferRenderbuffer;
 786   functions->fFramebufferTexture2D = StubGLFramebufferTexture2D;
 787   functions->fFramebufferTexture2DMultisample =
 788     StubGLFramebufferTexture2DMultisample;
 789   functions->fGenFramebuffers = StubGLGenFramebuffers;
 790   functions->fGenRenderbuffers = StubGLGenRenderbuffers;
 791   functions->fGetFramebufferAttachmentParameteriv =
 792     StubGLGetFramebufferAttachmentParameteriv;
 793   functions->fGetRenderbufferParameteriv = StubGLGetRenderbufferParameteriv;
 794   functions->fRenderbufferStorage = StubGLRenderbufferStorage;
 795   functions->fRenderbufferStorageMultisample =
 796     StubGLRenderbufferStorageMultisample;
 797   functions->fRenderbufferStorageMultisampleES2EXT =
 798     StubGLRenderbufferStorageMultisample;
 799   functions->fBlitFramebuffer = StubGLBlitFramebuffer;
 800   functions->fMapBuffer = StubGLMapBuffer;
 801   functions->fUnmapBuffer = StubGLUnmapBuffer;
 802   functions->fBindFragDataLocationIndexed =
 803     StubGLBindFragDataLocationIndexed;
 804   functions->fGetProgramResourceLocation = StubGLGetProgramResourceLocation;
 805
 806   return interface;
 807 }
 808
 809 }  // namespace gfx