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