@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/include/gpu/ganesh/gl/GrGLFunctions.h

@@ -0,0 +1,306 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLFunctions_DEFINED
+#define GrGLFunctions_DEFINED
+
+#include <cstring>
+#include "include/gpu/ganesh/gl/GrGLTypes.h"
+#include "include/private/base/SkTLogic.h"
+
+
+extern "C" {
+
+///////////////////////////////////////////////////////////////////////////////
+
+using GrGLActiveTextureFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum texture);
+using GrGLAttachShaderFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLuint shader);
+using GrGLBeginQueryFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLuint id);
+using GrGLBindAttribLocationFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLuint index, const char* name);
+using GrGLBindBufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLuint buffer);
+using GrGLBindFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLuint framebuffer);
+using GrGLBindRenderbufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLuint renderbuffer);
+using GrGLBindTextureFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLuint texture);
+using GrGLBindFragDataLocationFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLuint colorNumber, const GrGLchar* name);
+using GrGLBindFragDataLocationIndexedFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLuint colorNumber, GrGLuint index, const GrGLchar* name);
+using GrGLBindSamplerFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint unit, GrGLuint sampler);
+using GrGLBindVertexArrayFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint array);
+using GrGLBlendBarrierFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLBlendColorFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha);
+using GrGLBlendEquationFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode);
+using GrGLBlendFuncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum sfactor, GrGLenum dfactor);
+using GrGLBlitFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint srcX0, GrGLint srcY0, GrGLint srcX1, GrGLint srcY1, GrGLint dstX0, GrGLint dstY0, GrGLint dstX1, GrGLint dstY1, GrGLbitfield mask, GrGLenum filter);
+using GrGLBufferDataFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data, GrGLenum usage);
+using GrGLBufferSubDataFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLintptr offset, GrGLsizeiptr size, const GrGLvoid* data);
+using GrGLCheckFramebufferStatusFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLenum target);
+using GrGLClearFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLbitfield mask);
+using GrGLClearColorFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha);
+using GrGLClearStencilFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint s);
+using GrGLClearTexImageFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint texture, GrGLint level, GrGLenum format, GrGLenum type, const GrGLvoid* data);
+using GrGLClearTexSubImageFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint texture, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint zoffset, GrGLsizei width, GrGLsizei height, GrGLsizei depth, GrGLenum format, GrGLenum type, const GrGLvoid* data);
+using GrGLColorMaskFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLboolean red, GrGLboolean green, GrGLboolean blue, GrGLboolean alpha);
+using GrGLCompileShaderFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint shader);
+using GrGLCompressedTexImage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLenum internalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLsizei imageSize, const GrGLvoid* data);
+using GrGLCompressedTexSubImage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLsizei imageSize, const GrGLvoid* data);
+using GrGLCopyBufferSubDataFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum readTargt, GrGLenum writeTarget, GrGLintptr readOffset, GrGLintptr writeOffset, GrGLsizeiptr size);
+using GrGLCopyTexSubImage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height);
+using GrGLCreateProgramFn = GrGLuint GR_GL_FUNCTION_TYPE();
+using GrGLCreateShaderFn = GrGLuint GR_GL_FUNCTION_TYPE(GrGLenum type);
+using GrGLCullFaceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode);
+using GrGLDeleteBuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* buffers);
+using GrGLDeleteFencesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* fences);
+using GrGLDeleteFramebuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* framebuffers);
+using GrGLDeleteProgramFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program);
+using GrGLDeleteQueriesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* ids);
+using GrGLDeleteRenderbuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* renderbuffers);
+using GrGLDeleteSamplersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei count, const GrGLuint* samplers);
+using GrGLDeleteShaderFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint shader);
+using GrGLDeleteTexturesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* textures);
+using GrGLDeleteVertexArraysFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLuint* arrays);
+using GrGLDepthMaskFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLboolean flag);
+using GrGLDisableFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum cap);
+using GrGLDisableVertexAttribArrayFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint index);
+using GrGLDrawArraysFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLint first, GrGLsizei count);
+using GrGLDrawArraysInstancedFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLint first, GrGLsizei count, GrGLsizei primcount);
+using GrGLDrawArraysIndirectFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, const GrGLvoid* indirect);
+using GrGLDrawBufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode);
+using GrGLDrawBuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, const GrGLenum* bufs);
+using GrGLDrawElementsFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLsizei count, GrGLenum type, const GrGLvoid* indices);
+using GrGLDrawElementsInstancedFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLsizei count, GrGLenum type, const GrGLvoid* indices, GrGLsizei primcount);
+using GrGLDrawElementsIndirectFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLenum type, const GrGLvoid* indirect);
+using GrGLDrawRangeElementsFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLuint start, GrGLuint end, GrGLsizei count, GrGLenum type, const GrGLvoid* indices);
+using GrGLEnableFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum cap);
+using GrGLEnableVertexAttribArrayFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint index);
+using GrGLEndQueryFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target);
+using GrGLFinishFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLFinishFenceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint fence);
+using GrGLFlushFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLFlushMappedBufferRangeFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length);
+using GrGLFramebufferRenderbufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum attachment, GrGLenum renderbuffertarget, GrGLuint renderbuffer);
+using GrGLFramebufferTexture2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level);
+using GrGLFramebufferTexture2DMultisampleFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level, GrGLsizei samples);
+using GrGLFrontFaceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode);
+using GrGLGenBuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* buffers);
+using GrGLGenFencesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* fences);
+using GrGLGenFramebuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* framebuffers);
+using GrGLGenerateMipmapFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target);
+using GrGLGenQueriesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* ids);
+using GrGLGenRenderbuffersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* renderbuffers);
+using GrGLGenSamplersFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei count, GrGLuint* samplers);
+using GrGLGenTexturesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* textures);
+using GrGLGenVertexArraysFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei n, GrGLuint* arrays);
+using GrGLGetBufferParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLint* params);
+using GrGLGetErrorFn = GrGLenum GR_GL_FUNCTION_TYPE();
+using GrGLGetFramebufferAttachmentParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params);
+using GrGLGetFloatvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLfloat* params);
+using GrGLGetIntegervFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLint* params);
+using GrGLGetMultisamplefvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLuint index, GrGLfloat* val);
+using GrGLGetProgramBinaryFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, GrGLenum* binaryFormat, void* binary);
+using GrGLGetProgramInfoLogFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, char* infolog);
+using GrGLGetProgramivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLenum pname, GrGLint* params);
+using GrGLGetQueryivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum GLtarget, GrGLenum pname, GrGLint* params);
+using GrGLGetQueryObjecti64vFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLint64* params);
+using GrGLGetQueryObjectivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLint* params);
+using GrGLGetQueryObjectui64vFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLuint64* params);
+using GrGLGetQueryObjectuivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLuint* params);
+using GrGLGetRenderbufferParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLint* params);
+using GrGLGetShaderInfoLogFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length, char* infolog);
+using GrGLGetShaderivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint shader, GrGLenum pname, GrGLint* params);
+using GrGLGetShaderPrecisionFormatFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum shadertype, GrGLenum precisiontype, GrGLint* range, GrGLint* precision);
+using GrGLGetStringFn = const GrGLubyte* GR_GL_FUNCTION_TYPE(GrGLenum name);
+using GrGLGetStringiFn = const GrGLubyte* GR_GL_FUNCTION_TYPE(GrGLenum name, GrGLuint index);
+using GrGLGetTexLevelParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLenum pname, GrGLint* params);
+using GrGLGetUniformLocationFn = GrGLint GR_GL_FUNCTION_TYPE(GrGLuint program, const char* name);
+using GrGLInsertEventMarkerFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei length, const char* marker);
+using GrGLInvalidateBufferDataFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint buffer);
+using GrGLInvalidateBufferSubDataFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr length);
+using GrGLInvalidateFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizei numAttachments, const GrGLenum* attachments);
+using GrGLInvalidateSubFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizei numAttachments, const GrGLenum* attachments, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height);
+using GrGLInvalidateTexImageFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint texture, GrGLint level);
+using GrGLInvalidateTexSubImageFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint texture, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint zoffset, GrGLsizei width, GrGLsizei height, GrGLsizei depth);
+using GrGLIsTextureFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLuint texture);
+using GrGLLineWidthFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLfloat width);
+using GrGLLinkProgramFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program);
+using GrGLMapBufferFn = GrGLvoid* GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum access);
+using GrGLMapBufferRangeFn = GrGLvoid* GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length, GrGLbitfield access);
+using GrGLMapBufferSubDataFn = GrGLvoid* GR_GL_FUNCTION_TYPE(GrGLuint target, GrGLintptr offset, GrGLsizeiptr size, GrGLenum access);
+using GrGLMapTexSubImage2DFn = GrGLvoid* GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, GrGLenum access);
+using GrGLMemoryBarrierFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLbitfield barriers);
+using GrGLPatchParameteriFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLint value);
+using GrGLPixelStoreiFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum pname, GrGLint param);
+using GrGLPolygonModeFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum face, GrGLenum mode);
+using GrGLPopGroupMarkerFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLProgramBinaryFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLenum binaryFormat, void* binary, GrGLsizei length);
+using GrGLProgramParameteriFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLenum pname, GrGLint value);
+using GrGLPushGroupMarkerFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsizei length, const char* marker);
+using GrGLQueryCounterFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum target);
+using GrGLReadBufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum src);
+using GrGLReadPixelsFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, GrGLvoid* pixels);
+using GrGLRenderbufferStorageFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height);
+using GrGLRenderbufferStorageMultisampleFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizei samples, GrGLenum internalformat, GrGLsizei width, GrGLsizei height);
+using GrGLResolveMultisampleFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLSamplerParameterfFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, GrGLfloat param);
+using GrGLSamplerParameteriFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, GrGLint param);
+using GrGLSamplerParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint sampler, GrGLenum pname, const GrGLint* params);
+using GrGLScissorFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height);
+// GL_CHROMIUM_bind_uniform_location
+using GrGLBindUniformLocationFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLint location, const char* name);
+using GrGLSetFenceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint fence, GrGLenum condition);
+using GrGLShaderSourceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint shader, GrGLsizei count, const char* const* str, const GrGLint* length);
+using GrGLStencilFuncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum func, GrGLint ref, GrGLuint mask);
+using GrGLStencilFuncSeparateFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum face, GrGLenum func, GrGLint ref, GrGLuint mask);
+using GrGLStencilMaskFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint mask);
+using GrGLStencilMaskSeparateFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum face, GrGLuint mask);
+using GrGLStencilOpFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum fail, GrGLenum zfail, GrGLenum zpass);
+using GrGLStencilOpSeparateFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum face, GrGLenum fail, GrGLenum zfail, GrGLenum zpass);
+using GrGLTexBufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum internalformat, GrGLuint buffer);
+using GrGLTexBufferRangeFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum internalformat, GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr size);
+using GrGLTexImage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLint internalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLenum format, GrGLenum type, const GrGLvoid* pixels);
+using GrGLTexParameterfFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLfloat param);
+using GrGLTexParameterfvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, const GrGLfloat* params);
+using GrGLTexParameteriFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLint param);
+using GrGLTexParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, const GrGLint* params);
+using GrGLTexStorage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizei levels, GrGLenum internalformat, GrGLsizei width, GrGLsizei height);
+using GrGLDiscardFramebufferFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLsizei numAttachments, const GrGLenum* attachments);
+using GrGLTestFenceFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLuint fence);
+using GrGLTexSubImage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, const GrGLvoid* pixels);
+using GrGLTextureBarrierFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLUniform1fFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLfloat v0);
+using GrGLUniform1iFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLint v0);
+using GrGLUniform1fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLfloat* v);
+using GrGLUniform1ivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLint* v);
+using GrGLUniform2fFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLfloat v0, GrGLfloat v1);
+using GrGLUniform2iFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLint v0, GrGLint v1);
+using GrGLUniform2fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLfloat* v);
+using GrGLUniform2ivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLint* v);
+using GrGLUniform3fFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2);
+using GrGLUniform3iFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2);
+using GrGLUniform3fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLfloat* v);
+using GrGLUniform3ivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLint* v);
+using GrGLUniform4fFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2, GrGLfloat v3);
+using GrGLUniform4iFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2, GrGLint v3);
+using GrGLUniform4fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLfloat* v);
+using GrGLUniform4ivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, const GrGLint* v);
+using GrGLUniformMatrix2fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value);
+using GrGLUniformMatrix3fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value);
+using GrGLUniformMatrix4fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value);
+using GrGLUnmapBufferFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLenum target);
+using GrGLUnmapBufferSubDataFn = GrGLvoid GR_GL_FUNCTION_TYPE(const GrGLvoid* mem);
+using GrGLUnmapTexSubImage2DFn = GrGLvoid GR_GL_FUNCTION_TYPE(const GrGLvoid* mem);
+using GrGLUseProgramFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program);
+using GrGLVertexAttrib1fFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint indx, const GrGLfloat value);
+using GrGLVertexAttrib2fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint indx, const GrGLfloat* values);
+using GrGLVertexAttrib3fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint indx, const GrGLfloat* values);
+using GrGLVertexAttrib4fvFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint indx, const GrGLfloat* values);
+using GrGLVertexAttribDivisorFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint index, GrGLuint divisor);
+using GrGLVertexAttribIPointerFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint indx, GrGLint size, GrGLenum type, GrGLsizei stride, const GrGLvoid* ptr);
+using GrGLVertexAttribPointerFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint indx, GrGLint size, GrGLenum type, GrGLboolean normalized, GrGLsizei stride, const GrGLvoid* ptr);
+using GrGLViewportFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height);
+
+/* GL_NV_framebuffer_mixed_samples */
+using GrGLCoverageModulationFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum components);
+
+/* EXT_base_instance */
+using GrGLDrawArraysInstancedBaseInstanceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLint first, GrGLsizei count, GrGLsizei instancecount, GrGLuint baseinstance);
+using GrGLDrawElementsInstancedBaseVertexBaseInstanceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLsizei count, GrGLenum type, const void *indices, GrGLsizei instancecount, GrGLint basevertex, GrGLuint baseinstance);
+
+/* EXT_multi_draw_indirect */
+using GrGLMultiDrawArraysIndirectFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, const GrGLvoid* indirect, GrGLsizei drawcount, GrGLsizei stride);
+using GrGLMultiDrawElementsIndirectFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLenum type, const GrGLvoid* indirect, GrGLsizei drawcount, GrGLsizei stride);
+
+/* ANGLE_base_vertex_base_instance */
+using GrGLMultiDrawArraysInstancedBaseInstanceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, const GrGLint* firsts, const GrGLsizei* counts, const GrGLsizei* instanceCounts, const GrGLuint* baseInstances, const GrGLsizei drawcount);
+using GrGLMultiDrawElementsInstancedBaseVertexBaseInstanceFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, const GrGLint* counts, GrGLenum type, const GrGLvoid* const* indices, const GrGLsizei* instanceCounts, const GrGLint* baseVertices, const GrGLuint* baseInstances, const GrGLsizei drawcount);
+
+/* ARB_sync */
+using GrGLFenceSyncFn = GrGLsync GR_GL_FUNCTION_TYPE(GrGLenum condition, GrGLbitfield flags);
+using GrGLIsSyncFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLsync sync);
+using GrGLClientWaitSyncFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout);
+using GrGLWaitSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout);
+using GrGLDeleteSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync);
+
+/* ARB_internalformat_query */
+using GrGLGetInternalformativFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum internalformat, GrGLenum pname, GrGLsizei bufSize, GrGLint* params);
+
+/* KHR_debug */
+using GrGLDebugMessageControlFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum source, GrGLenum type, GrGLenum severity, GrGLsizei count, const GrGLuint* ids, GrGLboolean enabled);
+using GrGLDebugMessageInsertFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum source, GrGLenum type, GrGLuint id, GrGLenum severity, GrGLsizei length, const GrGLchar* buf);
+using GrGLDebugMessageCallbackFn = GrGLvoid GR_GL_FUNCTION_TYPE(GRGLDEBUGPROC callback, const GrGLvoid* userParam);
+using GrGLGetDebugMessageLogFn = GrGLuint GR_GL_FUNCTION_TYPE(GrGLuint count, GrGLsizei bufSize, GrGLenum* sources, GrGLenum* types, GrGLuint* ids, GrGLenum* severities, GrGLsizei* lengths, GrGLchar* messageLog);
+using GrGLPushDebugGroupFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum source, GrGLuint id, GrGLsizei length, const GrGLchar* message);
+using GrGLPopDebugGroupFn = GrGLvoid GR_GL_FUNCTION_TYPE();
+using GrGLObjectLabelFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum identifier, GrGLuint name, GrGLsizei length, const GrGLchar* label);
+
+/** EXT_window_rectangles */
+using GrGLWindowRectanglesFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum mode, GrGLsizei count, const GrGLint box[]);
+
+/** GL_QCOM_tiled_rendering */
+using GrGLStartTilingFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint x, GrGLuint y, GrGLuint width, GrGLuint height, GrGLbitfield preserveMask);
+using GrGLEndTilingFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLbitfield preserveMask);
+
+/** EGL functions */
+using GrEGLQueryStringFn = const char* GR_GL_FUNCTION_TYPE(GrEGLDisplay dpy, GrEGLint name);
+using GrEGLGetCurrentDisplayFn = GrEGLDisplay GR_GL_FUNCTION_TYPE();
+using GrEGLCreateImageFn = GrEGLImage GR_GL_FUNCTION_TYPE(GrEGLDisplay dpy, GrEGLContext ctx, GrEGLenum target, GrEGLClientBuffer buffer, const GrEGLint* attrib_list);
+using GrEGLDestroyImageFn = GrEGLBoolean GR_GL_FUNCTION_TYPE(GrEGLDisplay dpy, GrEGLImage image);
+}  // extern "C"
+
+// This is a lighter-weight std::function, trying to reduce code size and compile time
+// by only supporting the exact use cases we require.
+template <typename T> class GrGLFunction;
+
+template <typename R, typename... Args>
+class GrGLFunction<R GR_GL_FUNCTION_TYPE(Args...)> {
+public:
+    using Fn = R GR_GL_FUNCTION_TYPE(Args...);
+    // Construct empty.
+    GrGLFunction() = default;
+    GrGLFunction(std::nullptr_t) {}
+
+    // Construct from a simple function pointer.
+    GrGLFunction(Fn* fn_ptr) {
+        static_assert(sizeof(fn_ptr) <= sizeof(fBuf), "fBuf is too small");
+        if (fn_ptr) {
+            memcpy(fBuf, &fn_ptr, sizeof(fn_ptr));
+            fCall = [](const void* buf, Args... args) {
+                return (*(Fn* const *)buf)(std::forward<Args>(args)...);
+            };
+        }
+    }
+
+    // Construct from a small closure.
+    template <typename Closure>
+    GrGLFunction(Closure closure) : GrGLFunction() {
+        static_assert(sizeof(Closure) <= sizeof(fBuf), "fBuf is too small");
+#if defined(__APPLE__)  // I am having serious trouble getting these to work with all STLs...
+        static_assert(std::is_trivially_copyable<Closure>::value, "");
+        static_assert(std::is_trivially_destructible<Closure>::value, "");
+#endif
+
+        memcpy(fBuf, &closure, sizeof(closure));
+        fCall = [](const void* buf, Args... args) {
+            auto closure = (const Closure*)buf;
+            return (*closure)(args...);
+        };
+    }
+
+    R operator()(Args... args) const {
+        SkASSERT(fCall);
+        return fCall(fBuf, std::forward<Args>(args)...);
+    }
+
+    explicit operator bool() const { return fCall != nullptr; }
+
+    void reset() { fCall = nullptr; }
+
+private:
+    using Call = R(const void* buf, Args...);
+    Call* fCall = nullptr;
+    size_t fBuf[4];
+};
+
+#endif

package/cpp/skia/include/gpu/ganesh/gl/GrGLInterface.h

@@ -0,0 +1,338 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLInterface_DEFINED
+#define GrGLInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/ganesh/gl/GrGLExtensions.h"
+#include "include/gpu/ganesh/gl/GrGLFunctions.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+typedef void(*GrGLFuncPtr)();
+struct GrGLInterface;
+
+
+#if !defined(SK_DISABLE_LEGACY_GL_MAKE_NATIVE_INTERFACE)
+/**
+ * Rather than depend on platform-specific GL headers and libraries, we require
+ * the client to provide a struct of GL function pointers. This struct can be
+ * specified per-GrContext as a parameter to GrContext::MakeGL. If no interface is
+ * passed to MakeGL then a default GL interface is created using GrGLMakeNativeInterface().
+ * If this returns nullptr then GrContext::MakeGL() will fail.
+ *
+ * The implementation of GrGLMakeNativeInterface is platform-specific. Several
+ * implementations have been provided (for GLX, WGL, EGL, etc), along with an
+ * implementation that simply returns nullptr. Clients should select the most
+ * appropriate one to build.
+ */
+SK_API sk_sp<const GrGLInterface> GrGLMakeNativeInterface();
+#endif
+
+/**
+ * GrContext uses the following interface to make all calls into OpenGL. When a
+ * GrContext is created it is given a GrGLInterface. The interface's function
+ * pointers must be valid for the OpenGL context associated with the GrContext.
+ * On some platforms, such as Windows, function pointers for OpenGL extensions
+ * may vary between OpenGL contexts. So the caller must be careful to use a
+ * GrGLInterface initialized for the correct context. All functions that should
+ * be available based on the OpenGL's version and extension string must be
+ * non-NULL or GrContext creation will fail. This can be tested with the
+ * validate() method when the OpenGL context has been made current.
+ */
+struct SK_API GrGLInterface : public SkRefCnt {
+private:
+    using INHERITED = SkRefCnt;
+
+#if GR_GL_CHECK_ERROR
+    // This is here to avoid having our debug code that checks for a GL error after most GL calls
+    // accidentally swallow an OOM that should be reported.
+    mutable bool fOOMed = false;
+    bool fSuppressErrorLogging = false;
+#endif
+
+public:
+    GrGLInterface();
+
+    // Validates that the GrGLInterface supports its advertised standard. This means the necessary
+    // function pointers have been initialized for both the GL version and any advertised
+    // extensions.
+    bool validate() const;
+
+#if GR_GL_CHECK_ERROR
+    GrGLenum checkError(const char* location, const char* call) const;
+    bool checkAndResetOOMed() const;
+    void suppressErrorLogging();
+#endif
+
+#if defined(GPU_TEST_UTILS)
+    GrGLInterface(const GrGLInterface& that)
+            : fStandard(that.fStandard)
+            , fExtensions(that.fExtensions)
+            , fFunctions(that.fFunctions) {}
+#endif
+
+    // Indicates the type of GL implementation
+    GrGLStandard fStandard;
+    GrGLExtensions fExtensions;
+
+    bool hasExtension(const char ext[]) const { return fExtensions.has(ext); }
+
+    /**
+     * The function pointers are in a struct so that we can have a compiler generated assignment
+     * operator.
+     */
+    struct Functions {
+        GrGLFunction<GrGLActiveTextureFn> fActiveTexture;
+        GrGLFunction<GrGLAttachShaderFn> fAttachShader;
+        GrGLFunction<GrGLBeginQueryFn> fBeginQuery;
+        GrGLFunction<GrGLBindAttribLocationFn> fBindAttribLocation;
+        GrGLFunction<GrGLBindBufferFn> fBindBuffer;
+        GrGLFunction<GrGLBindFragDataLocationFn> fBindFragDataLocation;
+        GrGLFunction<GrGLBindFragDataLocationIndexedFn> fBindFragDataLocationIndexed;
+        GrGLFunction<GrGLBindFramebufferFn> fBindFramebuffer;
+        GrGLFunction<GrGLBindRenderbufferFn> fBindRenderbuffer;
+        GrGLFunction<GrGLBindSamplerFn> fBindSampler;
+        GrGLFunction<GrGLBindTextureFn> fBindTexture;
+        GrGLFunction<GrGLBindVertexArrayFn> fBindVertexArray;
+        GrGLFunction<GrGLBlendBarrierFn> fBlendBarrier;
+        GrGLFunction<GrGLBlendColorFn> fBlendColor;
+        GrGLFunction<GrGLBlendEquationFn> fBlendEquation;
+        GrGLFunction<GrGLBlendFuncFn> fBlendFunc;
+        GrGLFunction<GrGLBlitFramebufferFn> fBlitFramebuffer;
+        GrGLFunction<GrGLBufferDataFn> fBufferData;
+        GrGLFunction<GrGLBufferSubDataFn> fBufferSubData;
+        GrGLFunction<GrGLCheckFramebufferStatusFn> fCheckFramebufferStatus;
+        GrGLFunction<GrGLClearFn> fClear;
+        GrGLFunction<GrGLClearColorFn> fClearColor;
+        GrGLFunction<GrGLClearStencilFn> fClearStencil;
+        GrGLFunction<GrGLClearTexImageFn> fClearTexImage;
+        GrGLFunction<GrGLClearTexSubImageFn> fClearTexSubImage;
+        GrGLFunction<GrGLColorMaskFn> fColorMask;
+        GrGLFunction<GrGLCompileShaderFn> fCompileShader;
+        GrGLFunction<GrGLCompressedTexImage2DFn> fCompressedTexImage2D;
+        GrGLFunction<GrGLCompressedTexSubImage2DFn> fCompressedTexSubImage2D;
+        GrGLFunction<GrGLCopyBufferSubDataFn> fCopyBufferSubData;
+        GrGLFunction<GrGLCopyTexSubImage2DFn> fCopyTexSubImage2D;
+        GrGLFunction<GrGLCreateProgramFn> fCreateProgram;
+        GrGLFunction<GrGLCreateShaderFn> fCreateShader;
+        GrGLFunction<GrGLCullFaceFn> fCullFace;
+        GrGLFunction<GrGLDeleteBuffersFn> fDeleteBuffers;
+        GrGLFunction<GrGLDeleteFencesFn> fDeleteFences;
+        GrGLFunction<GrGLDeleteFramebuffersFn> fDeleteFramebuffers;
+        GrGLFunction<GrGLDeleteProgramFn> fDeleteProgram;
+        GrGLFunction<GrGLDeleteQueriesFn> fDeleteQueries;
+        GrGLFunction<GrGLDeleteRenderbuffersFn> fDeleteRenderbuffers;
+        GrGLFunction<GrGLDeleteSamplersFn> fDeleteSamplers;
+        GrGLFunction<GrGLDeleteShaderFn> fDeleteShader;
+        GrGLFunction<GrGLDeleteTexturesFn> fDeleteTextures;
+        GrGLFunction<GrGLDeleteVertexArraysFn> fDeleteVertexArrays;
+        GrGLFunction<GrGLDepthMaskFn> fDepthMask;
+        GrGLFunction<GrGLDisableFn> fDisable;
+        GrGLFunction<GrGLDisableVertexAttribArrayFn> fDisableVertexAttribArray;
+        GrGLFunction<GrGLDrawArraysFn> fDrawArrays;
+        GrGLFunction<GrGLDrawArraysIndirectFn> fDrawArraysIndirect;
+        GrGLFunction<GrGLDrawArraysInstancedFn> fDrawArraysInstanced;
+        GrGLFunction<GrGLDrawBufferFn> fDrawBuffer;
+        GrGLFunction<GrGLDrawBuffersFn> fDrawBuffers;
+        GrGLFunction<GrGLDrawElementsFn> fDrawElements;
+        GrGLFunction<GrGLDrawElementsIndirectFn> fDrawElementsIndirect;
+        GrGLFunction<GrGLDrawElementsInstancedFn> fDrawElementsInstanced;
+        GrGLFunction<GrGLDrawRangeElementsFn> fDrawRangeElements;
+        GrGLFunction<GrGLEnableFn> fEnable;
+        GrGLFunction<GrGLEnableVertexAttribArrayFn> fEnableVertexAttribArray;
+        GrGLFunction<GrGLEndQueryFn> fEndQuery;
+        GrGLFunction<GrGLFinishFn> fFinish;
+        GrGLFunction<GrGLFinishFenceFn> fFinishFence;
+        GrGLFunction<GrGLFlushFn> fFlush;
+        GrGLFunction<GrGLFlushMappedBufferRangeFn> fFlushMappedBufferRange;
+        GrGLFunction<GrGLFramebufferRenderbufferFn> fFramebufferRenderbuffer;
+        GrGLFunction<GrGLFramebufferTexture2DFn> fFramebufferTexture2D;
+        GrGLFunction<GrGLFramebufferTexture2DMultisampleFn> fFramebufferTexture2DMultisample;
+        GrGLFunction<GrGLFrontFaceFn> fFrontFace;
+        GrGLFunction<GrGLGenBuffersFn> fGenBuffers;
+        GrGLFunction<GrGLGenFencesFn> fGenFences;
+        GrGLFunction<GrGLGenFramebuffersFn> fGenFramebuffers;
+        GrGLFunction<GrGLGenerateMipmapFn> fGenerateMipmap;
+        GrGLFunction<GrGLGenQueriesFn> fGenQueries;
+        GrGLFunction<GrGLGenRenderbuffersFn> fGenRenderbuffers;
+        GrGLFunction<GrGLGenSamplersFn> fGenSamplers;
+        GrGLFunction<GrGLGenTexturesFn> fGenTextures;
+        GrGLFunction<GrGLGenVertexArraysFn> fGenVertexArrays;
+        GrGLFunction<GrGLGetBufferParameterivFn> fGetBufferParameteriv;
+        GrGLFunction<GrGLGetErrorFn> fGetError;
+        GrGLFunction<GrGLGetFramebufferAttachmentParameterivFn> fGetFramebufferAttachmentParameteriv;
+        GrGLFunction<GrGLGetFloatvFn> fGetFloatv;
+        GrGLFunction<GrGLGetIntegervFn> fGetIntegerv;
+        GrGLFunction<GrGLGetMultisamplefvFn> fGetMultisamplefv;
+        GrGLFunction<GrGLGetProgramBinaryFn> fGetProgramBinary;
+        GrGLFunction<GrGLGetProgramInfoLogFn> fGetProgramInfoLog;
+        GrGLFunction<GrGLGetProgramivFn> fGetProgramiv;
+        GrGLFunction<GrGLGetQueryObjecti64vFn> fGetQueryObjecti64v;
+        GrGLFunction<GrGLGetQueryObjectivFn> fGetQueryObjectiv;
+        GrGLFunction<GrGLGetQueryObjectui64vFn> fGetQueryObjectui64v;
+        GrGLFunction<GrGLGetQueryObjectuivFn> fGetQueryObjectuiv;
+        GrGLFunction<GrGLGetQueryivFn> fGetQueryiv;
+        GrGLFunction<GrGLGetRenderbufferParameterivFn> fGetRenderbufferParameteriv;
+        GrGLFunction<GrGLGetShaderInfoLogFn> fGetShaderInfoLog;
+        GrGLFunction<GrGLGetShaderivFn> fGetShaderiv;
+        GrGLFunction<GrGLGetShaderPrecisionFormatFn> fGetShaderPrecisionFormat;
+        GrGLFunction<GrGLGetStringFn> fGetString;
+        GrGLFunction<GrGLGetStringiFn> fGetStringi;
+        GrGLFunction<GrGLGetTexLevelParameterivFn> fGetTexLevelParameteriv;
+        GrGLFunction<GrGLGetUniformLocationFn> fGetUniformLocation;
+        GrGLFunction<GrGLInsertEventMarkerFn> fInsertEventMarker;
+        GrGLFunction<GrGLInvalidateBufferDataFn> fInvalidateBufferData;
+        GrGLFunction<GrGLInvalidateBufferSubDataFn> fInvalidateBufferSubData;
+        GrGLFunction<GrGLInvalidateFramebufferFn> fInvalidateFramebuffer;
+        GrGLFunction<GrGLInvalidateSubFramebufferFn> fInvalidateSubFramebuffer;
+        GrGLFunction<GrGLInvalidateTexImageFn> fInvalidateTexImage;
+        GrGLFunction<GrGLInvalidateTexSubImageFn> fInvalidateTexSubImage;
+        GrGLFunction<GrGLIsTextureFn> fIsTexture;
+        GrGLFunction<GrGLLineWidthFn> fLineWidth;
+        GrGLFunction<GrGLLinkProgramFn> fLinkProgram;
+        GrGLFunction<GrGLProgramBinaryFn> fProgramBinary;
+        GrGLFunction<GrGLProgramParameteriFn> fProgramParameteri;
+        GrGLFunction<GrGLMapBufferFn> fMapBuffer;
+        GrGLFunction<GrGLMapBufferRangeFn> fMapBufferRange;
+        GrGLFunction<GrGLMapBufferSubDataFn> fMapBufferSubData;
+        GrGLFunction<GrGLMapTexSubImage2DFn> fMapTexSubImage2D;
+        GrGLFunction<GrGLMemoryBarrierFn> fMemoryBarrier;
+        GrGLFunction<GrGLDrawArraysInstancedBaseInstanceFn> fDrawArraysInstancedBaseInstance;
+        GrGLFunction<GrGLDrawElementsInstancedBaseVertexBaseInstanceFn> fDrawElementsInstancedBaseVertexBaseInstance;
+        GrGLFunction<GrGLMultiDrawArraysIndirectFn> fMultiDrawArraysIndirect;
+        GrGLFunction<GrGLMultiDrawElementsIndirectFn> fMultiDrawElementsIndirect;
+        GrGLFunction<GrGLMultiDrawArraysInstancedBaseInstanceFn> fMultiDrawArraysInstancedBaseInstance;
+        GrGLFunction<GrGLMultiDrawElementsInstancedBaseVertexBaseInstanceFn> fMultiDrawElementsInstancedBaseVertexBaseInstance;
+        GrGLFunction<GrGLPatchParameteriFn> fPatchParameteri;
+        GrGLFunction<GrGLPixelStoreiFn> fPixelStorei;
+        GrGLFunction<GrGLPolygonModeFn> fPolygonMode;
+        GrGLFunction<GrGLPopGroupMarkerFn> fPopGroupMarker;
+        GrGLFunction<GrGLPushGroupMarkerFn> fPushGroupMarker;
+        GrGLFunction<GrGLQueryCounterFn> fQueryCounter;
+        GrGLFunction<GrGLReadBufferFn> fReadBuffer;
+        GrGLFunction<GrGLReadPixelsFn> fReadPixels;
+        GrGLFunction<GrGLRenderbufferStorageFn> fRenderbufferStorage;
+
+        //  On OpenGL ES there are multiple incompatible extensions that add support for MSAA
+        //  and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
+        //  older extensions for performance reasons or due to ES3 driver bugs. We want the function
+        //  that creates the GrGLInterface to provide all available functions and internally
+        //  we will select among them. They all have a method called glRenderbufferStorageMultisample*.
+        //  So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
+        //  GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
+        //  variations.
+        //
+        //  If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
+        //  assume the function pointers for the standard (or equivalent GL_ARB) version have
+        //  been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
+        //  functionality.
+
+        //  GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
+        GrGLFunction<GrGLRenderbufferStorageMultisampleFn> fRenderbufferStorageMultisampleES2EXT;
+        //  GL_APPLE_framebuffer_multisample
+        GrGLFunction<GrGLRenderbufferStorageMultisampleFn> fRenderbufferStorageMultisampleES2APPLE;
+
+        //  This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
+        //  the standard function in ES3+ or GL 3.0+.
+        GrGLFunction<GrGLRenderbufferStorageMultisampleFn> fRenderbufferStorageMultisample;
+
+        // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
+        GrGLFunction<GrGLBindUniformLocationFn> fBindUniformLocation;
+
+        GrGLFunction<GrGLResolveMultisampleFramebufferFn> fResolveMultisampleFramebuffer;
+        GrGLFunction<GrGLSamplerParameterfFn> fSamplerParameterf;
+        GrGLFunction<GrGLSamplerParameteriFn> fSamplerParameteri;
+        GrGLFunction<GrGLSamplerParameterivFn> fSamplerParameteriv;
+        GrGLFunction<GrGLScissorFn> fScissor;
+        GrGLFunction<GrGLSetFenceFn> fSetFence;
+        GrGLFunction<GrGLShaderSourceFn> fShaderSource;
+        GrGLFunction<GrGLStencilFuncFn> fStencilFunc;
+        GrGLFunction<GrGLStencilFuncSeparateFn> fStencilFuncSeparate;
+        GrGLFunction<GrGLStencilMaskFn> fStencilMask;
+        GrGLFunction<GrGLStencilMaskSeparateFn> fStencilMaskSeparate;
+        GrGLFunction<GrGLStencilOpFn> fStencilOp;
+        GrGLFunction<GrGLStencilOpSeparateFn> fStencilOpSeparate;
+        GrGLFunction<GrGLTestFenceFn> fTestFence;
+        GrGLFunction<GrGLTexBufferFn> fTexBuffer;
+        GrGLFunction<GrGLTexBufferRangeFn> fTexBufferRange;
+        GrGLFunction<GrGLTexImage2DFn> fTexImage2D;
+        GrGLFunction<GrGLTexParameterfFn> fTexParameterf;
+        GrGLFunction<GrGLTexParameterfvFn> fTexParameterfv;
+        GrGLFunction<GrGLTexParameteriFn> fTexParameteri;
+        GrGLFunction<GrGLTexParameterivFn> fTexParameteriv;
+        GrGLFunction<GrGLTexSubImage2DFn> fTexSubImage2D;
+        GrGLFunction<GrGLTexStorage2DFn> fTexStorage2D;
+        GrGLFunction<GrGLTextureBarrierFn> fTextureBarrier;
+        GrGLFunction<GrGLDiscardFramebufferFn> fDiscardFramebuffer;
+        GrGLFunction<GrGLUniform1fFn> fUniform1f;
+        GrGLFunction<GrGLUniform1iFn> fUniform1i;
+        GrGLFunction<GrGLUniform1fvFn> fUniform1fv;
+        GrGLFunction<GrGLUniform1ivFn> fUniform1iv;
+        GrGLFunction<GrGLUniform2fFn> fUniform2f;
+        GrGLFunction<GrGLUniform2iFn> fUniform2i;
+        GrGLFunction<GrGLUniform2fvFn> fUniform2fv;
+        GrGLFunction<GrGLUniform2ivFn> fUniform2iv;
+        GrGLFunction<GrGLUniform3fFn> fUniform3f;
+        GrGLFunction<GrGLUniform3iFn> fUniform3i;
+        GrGLFunction<GrGLUniform3fvFn> fUniform3fv;
+        GrGLFunction<GrGLUniform3ivFn> fUniform3iv;
+        GrGLFunction<GrGLUniform4fFn> fUniform4f;
+        GrGLFunction<GrGLUniform4iFn> fUniform4i;
+        GrGLFunction<GrGLUniform4fvFn> fUniform4fv;
+        GrGLFunction<GrGLUniform4ivFn> fUniform4iv;
+        GrGLFunction<GrGLUniformMatrix2fvFn> fUniformMatrix2fv;
+        GrGLFunction<GrGLUniformMatrix3fvFn> fUniformMatrix3fv;
+        GrGLFunction<GrGLUniformMatrix4fvFn> fUniformMatrix4fv;
+        GrGLFunction<GrGLUnmapBufferFn> fUnmapBuffer;
+        GrGLFunction<GrGLUnmapBufferSubDataFn> fUnmapBufferSubData;
+        GrGLFunction<GrGLUnmapTexSubImage2DFn> fUnmapTexSubImage2D;
+        GrGLFunction<GrGLUseProgramFn> fUseProgram;
+        GrGLFunction<GrGLVertexAttrib1fFn> fVertexAttrib1f;
+        GrGLFunction<GrGLVertexAttrib2fvFn> fVertexAttrib2fv;
+        GrGLFunction<GrGLVertexAttrib3fvFn> fVertexAttrib3fv;
+        GrGLFunction<GrGLVertexAttrib4fvFn> fVertexAttrib4fv;
+        GrGLFunction<GrGLVertexAttribDivisorFn> fVertexAttribDivisor;
+        GrGLFunction<GrGLVertexAttribIPointerFn> fVertexAttribIPointer;
+        GrGLFunction<GrGLVertexAttribPointerFn> fVertexAttribPointer;
+        GrGLFunction<GrGLViewportFn> fViewport;
+
+        /* ARB_sync */
+        GrGLFunction<GrGLFenceSyncFn> fFenceSync;
+        GrGLFunction<GrGLIsSyncFn> fIsSync;
+        GrGLFunction<GrGLClientWaitSyncFn> fClientWaitSync;
+        GrGLFunction<GrGLWaitSyncFn> fWaitSync;
+        GrGLFunction<GrGLDeleteSyncFn> fDeleteSync;
+
+        /* ARB_internalforamt_query */
+        GrGLFunction<GrGLGetInternalformativFn> fGetInternalformativ;
+
+        /* KHR_debug */
+        GrGLFunction<GrGLDebugMessageControlFn> fDebugMessageControl;
+        GrGLFunction<GrGLDebugMessageInsertFn> fDebugMessageInsert;
+        GrGLFunction<GrGLDebugMessageCallbackFn> fDebugMessageCallback;
+        GrGLFunction<GrGLGetDebugMessageLogFn> fGetDebugMessageLog;
+        GrGLFunction<GrGLPushDebugGroupFn> fPushDebugGroup;
+        GrGLFunction<GrGLPopDebugGroupFn> fPopDebugGroup;
+        GrGLFunction<GrGLObjectLabelFn> fObjectLabel;
+
+        /* EXT_window_rectangles */
+        GrGLFunction<GrGLWindowRectanglesFn> fWindowRectangles;
+
+        /* GL_QCOM_tiled_rendering */
+        GrGLFunction<GrGLStartTilingFn> fStartTiling;
+        GrGLFunction<GrGLEndTilingFn> fEndTiling;
+    } fFunctions;
+
+#if defined(GPU_TEST_UTILS)
+    // This exists for internal testing.
+    virtual void abandon() const;
+#endif
+};
+
+#endif