@shopify/react-native-skia 0.1.115

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

@@ -0,0 +1,342 @@
+/*
+ * 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/gl/GrGLExtensions.h"
+#include "include/gpu/gl/GrGLFunctions.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+typedef void(*GrGLFuncPtr)();
+struct GrGLInterface;
+
+
+/**
+ * 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();
+// Deprecated alternative to GrGLMakeNativeInterface().
+SK_API const GrGLInterface* GrGLCreateNativeInterface();
+
+/**
+ * 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 GR_TEST_UTILS
+    GrGLInterface(const GrGLInterface& that)
+            : fStandard(that.fStandard)
+            , fExtensions(that.fExtensions)
+            , fFunctions(that.fFunctions) {}
+#endif
+
+    // Indicates the type of GL implementation
+    union {
+        GrGLStandard fStandard;
+        GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.
+    };
+
+    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<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<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<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;
+
+        /* NV_framebuffer_mixed_samples */
+        GrGLFunction<GrGLCoverageModulationFn> fCoverageModulation;
+
+        /* 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 GR_TEST_UTILS
+    // This exists for internal testing.
+    virtual void abandon() const;
+#endif
+};
+
+#endif

package/cpp/skia/include/gpu/gl/GrGLTypes.h

@@ -0,0 +1,207 @@
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLTypes_DEFINED
+#define GrGLTypes_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/gl/GrGLConfig.h"
+
+/**
+ * Classifies GL contexts by which standard they implement (currently as OpenGL vs. OpenGL ES).
+ */
+enum GrGLStandard {
+    kNone_GrGLStandard,
+    kGL_GrGLStandard,
+    kGLES_GrGLStandard,
+    kWebGL_GrGLStandard,
+};
+static const int kGrGLStandardCnt = 4;
+
+// The following allow certain interfaces to be turned off at compile time
+// (for example, to lower code size).
+#if SK_ASSUME_GL_ES
+    #define GR_IS_GR_GL(standard) false
+    #define GR_IS_GR_GL_ES(standard) true
+    #define GR_IS_GR_WEBGL(standard) false
+    #define SK_DISABLE_GL_INTERFACE 1
+    #define SK_DISABLE_WEBGL_INTERFACE 1
+#elif SK_ASSUME_GL
+    #define GR_IS_GR_GL(standard) true
+    #define GR_IS_GR_GL_ES(standard) false
+    #define GR_IS_GR_WEBGL(standard) false
+    #define SK_DISABLE_GL_ES_INTERFACE 1
+    #define SK_DISABLE_WEBGL_INTERFACE 1
+#elif SK_ASSUME_WEBGL
+    #define GR_IS_GR_GL(standard) false
+    #define GR_IS_GR_GL_ES(standard) false
+    #define GR_IS_GR_WEBGL(standard) true
+    #define SK_DISABLE_GL_ES_INTERFACE 1
+    #define SK_DISABLE_GL_INTERFACE 1
+#else
+    #define GR_IS_GR_GL(standard) (kGL_GrGLStandard == standard)
+    #define GR_IS_GR_GL_ES(standard) (kGLES_GrGLStandard == standard)
+    #define GR_IS_GR_WEBGL(standard) (kWebGL_GrGLStandard == standard)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The supported GL formats represented as an enum. Actual support by GrContext depends on GL
+ * context version and extensions.
+ */
+enum class GrGLFormat {
+    kUnknown,
+
+    kRGBA8,
+    kR8,
+    kALPHA8,
+    kLUMINANCE8,
+    kLUMINANCE8_ALPHA8,
+    kBGRA8,
+    kRGB565,
+    kRGBA16F,
+    kR16F,
+    kRGB8,
+    kRGBX8,
+    kRG8,
+    kRGB10_A2,
+    kRGBA4,
+    kSRGB8_ALPHA8,
+    kCOMPRESSED_ETC1_RGB8,
+    kCOMPRESSED_RGB8_ETC2,
+    kCOMPRESSED_RGB8_BC1,
+    kCOMPRESSED_RGBA8_BC1,
+    kR16,
+    kRG16,
+    kRGBA16,
+    kRG16F,
+    kLUMINANCE16F,
+
+    kLastColorFormat = kLUMINANCE16F,
+
+    // Depth/Stencil formats
+    kSTENCIL_INDEX8,
+    kSTENCIL_INDEX16,
+    kDEPTH24_STENCIL8,
+
+    kLast = kDEPTH24_STENCIL8
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Declares typedefs for all the GL functions used in GrGLInterface
+ */
+
+typedef unsigned int GrGLenum;
+typedef unsigned char GrGLboolean;
+typedef unsigned int GrGLbitfield;
+typedef signed char GrGLbyte;
+typedef char GrGLchar;
+typedef short GrGLshort;
+typedef int GrGLint;
+typedef int GrGLsizei;
+typedef int64_t GrGLint64;
+typedef unsigned char GrGLubyte;
+typedef unsigned short GrGLushort;
+typedef unsigned int GrGLuint;
+typedef uint64_t GrGLuint64;
+typedef unsigned short int GrGLhalf;
+typedef float GrGLfloat;
+typedef float GrGLclampf;
+typedef double GrGLdouble;
+typedef double GrGLclampd;
+typedef void GrGLvoid;
+#ifdef _WIN64
+typedef signed long long int GrGLintptr;
+typedef signed long long int GrGLsizeiptr;
+#else
+typedef signed long int GrGLintptr;
+typedef signed long int GrGLsizeiptr;
+#endif
+typedef void* GrGLeglImage;
+typedef struct __GLsync* GrGLsync;
+
+struct GrGLDrawArraysIndirectCommand {
+    GrGLuint fCount;
+    GrGLuint fInstanceCount;
+    GrGLuint fFirst;
+    GrGLuint fBaseInstance;  // Requires EXT_base_instance on ES.
+};
+
+// static_asserts must have messages in this file because its included in C++14 client code.
+static_assert(16 == sizeof(GrGLDrawArraysIndirectCommand), "");
+
+struct GrGLDrawElementsIndirectCommand {
+    GrGLuint fCount;
+    GrGLuint fInstanceCount;
+    GrGLuint fFirstIndex;
+    GrGLuint fBaseVertex;
+    GrGLuint fBaseInstance;  // Requires EXT_base_instance on ES.
+};
+
+static_assert(20 == sizeof(GrGLDrawElementsIndirectCommand), "");
+
+/**
+ * KHR_debug
+ */
+typedef void (GR_GL_FUNCTION_TYPE* GRGLDEBUGPROC)(GrGLenum source,
+                                                  GrGLenum type,
+                                                  GrGLuint id,
+                                                  GrGLenum severity,
+                                                  GrGLsizei length,
+                                                  const GrGLchar* message,
+                                                  const void* userParam);
+
+/**
+ * EGL types.
+ */
+typedef void* GrEGLImage;
+typedef void* GrEGLDisplay;
+typedef void* GrEGLContext;
+typedef void* GrEGLClientBuffer;
+typedef unsigned int GrEGLenum;
+typedef int32_t GrEGLint;
+typedef unsigned int GrEGLBoolean;
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Types for interacting with GL resources created externally to Skia. GrBackendObjects for GL
+ * textures are really const GrGLTexture*. The fFormat here should be a sized, internal format
+ * for the texture. We will try to use the sized format if the GL Context supports it, otherwise
+ * we will internally fall back to using the base internal formats.
+ */
+struct GrGLTextureInfo {
+    GrGLenum fTarget;
+    GrGLuint fID;
+    GrGLenum fFormat = 0;
+
+    bool operator==(const GrGLTextureInfo& that) const {
+        return fTarget == that.fTarget && fID == that.fID && fFormat == that.fFormat;
+    }
+};
+
+struct GrGLFramebufferInfo {
+    GrGLuint fFBOID;
+    GrGLenum fFormat = 0;
+
+    bool operator==(const GrGLFramebufferInfo& that) const {
+        return fFBOID == that.fFBOID && fFormat == that.fFormat;
+    }
+};
+
+struct GrGLSurfaceInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    GrProtected fProtected = GrProtected::kNo;
+
+    GrGLenum fTarget = 0;
+    GrGLenum fFormat = 0;
+};
+
+#endif

package/cpp/skia/include/gpu/gl/egl/GrGLMakeEGLInterface.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "include/gpu/GrTypes.h"
+
+#include "include/core/SkRefCnt.h"
+
+struct GrGLInterface;
+
+sk_sp<const GrGLInterface> GrGLMakeEGLInterface();

package/cpp/skia/include/gpu/gl/glx/GrGLMakeGLXInterface.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "include/gpu/GrTypes.h"
+
+#include "include/core/SkRefCnt.h"
+
+struct GrGLInterface;
+
+sk_sp<const GrGLInterface> GrGLMakeGLXInterface();