diff -r 000000000000 -r 6474c204b198 gfx/skia/trunk/include/gpu/gl/GrGLInterface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/skia/trunk/include/gpu/gl/GrGLInterface.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,368 @@
+/*
+ * 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 "GrGLFunctions.h"
+#include "GrGLExtensions.h"
+#include "SkRefCnt.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * 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::Create. If NULL is
+ * passed to Create then a "default" GL interface is created. If the default is
+ * also NULL GrContext creation will fail.
+ *
+ * The default interface is returned by GrGLDefaultInterface. This function's
+ * implementation is platform-specific. Several have been provided, along with
+ * an implementation that simply returns NULL.
+ *
+ * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a
+ * callback function that will be called prior to each GL function call. See
+ * comments in GrGLConfig.h
+ */
+
+struct GrGLInterface;
+
+const GrGLInterface* GrGLDefaultInterface();
+
+/**
+ * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,
+ * GLX on linux, AGL on Mac). The interface is only valid for the GL context
+ * that is current when the interface is created.
+ */
+const GrGLInterface* GrGLCreateNativeInterface();
+
+#if SK_MESA
+/**
+ * Creates a GrGLInterface for an OSMesa context.
+ */
+const GrGLInterface* GrGLCreateMesaInterface();
+#endif
+
+#if SK_ANGLE
+/**
+ * Creates a GrGLInterface for an ANGLE context.
+ */
+const GrGLInterface* GrGLCreateANGLEInterface();
+#endif
+
+/**
+ * Creates a null GrGLInterface that doesn't draw anything. Used for measuring
+ * CPU overhead.
+ */
+const SK_API GrGLInterface* GrGLCreateNullInterface();
+
+/**
+ * Creates a debugging GrGLInterface that doesn't draw anything. Used for
+ * finding memory leaks and invalid memory accesses.
+ */
+const GrGLInterface* GrGLCreateDebugInterface();
+
+#if GR_GL_PER_GL_FUNC_CALLBACK
+typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);
+typedef intptr_t GrGLInterfaceCallbackData;
+#endif
+
+/** Function that returns a new interface identical to "interface" but without support for
+    GL_NV_path_rendering. */
+const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);
+
+/** Function that returns a new interface identical to "interface" but with support for
+    test version of GL_EXT_debug_marker. */
+const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,
+                                                     GrGLInsertEventMarkerProc insertEventMarkerFn,
+                                                     GrGLPushGroupMarkerProc pushGroupMarkerFn,
+                                                     GrGLPopGroupMarkerProc popGroupMarkerFn);
+
+/**
+ * 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:
+    // simple wrapper class that exists only to initialize a pointer to NULL
+    template <typename FNPTR_TYPE> class GLPtr {
+    public:
+        GLPtr() : fPtr(NULL) {}
+        GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
+        operator FNPTR_TYPE() const { return fPtr; }
+    private:
+        FNPTR_TYPE fPtr;
+    };
+
+    // This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until
+    // they're updated to use the Functions struct.
+    template <typename FNPTR_TYPE> class GLPtrAlias {
+    public:
+        GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}
+        void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }
+    private:
+        GLPtr<FNPTR_TYPE>* fBase;
+    };
+
+    typedef SkRefCnt INHERITED;
+
+public:
+    SK_DECLARE_INST_COUNT(GrGLInterface)
+
+    GrGLInterface();
+
+    static GrGLInterface* NewClone(const 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;
+
+    // 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 {
+        GLPtr<GrGLActiveTextureProc> fActiveTexture;
+        GLPtr<GrGLAttachShaderProc> fAttachShader;
+        GLPtr<GrGLBeginQueryProc> fBeginQuery;
+        GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;
+        GLPtr<GrGLBindBufferProc> fBindBuffer;
+        GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;
+        GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;
+        GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;
+        GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;
+        GLPtr<GrGLBindTextureProc> fBindTexture;
+        GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;
+        GLPtr<GrGLBlendColorProc> fBlendColor;
+        GLPtr<GrGLBlendFuncProc> fBlendFunc;
+        GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;
+        GLPtr<GrGLBufferDataProc> fBufferData;
+        GLPtr<GrGLBufferSubDataProc> fBufferSubData;
+        GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;
+        GLPtr<GrGLClearProc> fClear;
+        GLPtr<GrGLClearColorProc> fClearColor;
+        GLPtr<GrGLClearStencilProc> fClearStencil;
+        GLPtr<GrGLColorMaskProc> fColorMask;
+        GLPtr<GrGLCompileShaderProc> fCompileShader;
+        GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;
+        GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
+        GLPtr<GrGLCreateProgramProc> fCreateProgram;
+        GLPtr<GrGLCreateShaderProc> fCreateShader;
+        GLPtr<GrGLCullFaceProc> fCullFace;
+        GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
+        GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
+        GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
+        GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
+        GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
+        GLPtr<GrGLDeleteShaderProc> fDeleteShader;
+        GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
+        GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
+        GLPtr<GrGLDepthMaskProc> fDepthMask;
+        GLPtr<GrGLDisableProc> fDisable;
+        GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
+        GLPtr<GrGLDrawArraysProc> fDrawArrays;
+        GLPtr<GrGLDrawBufferProc> fDrawBuffer;
+        GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
+        GLPtr<GrGLDrawElementsProc> fDrawElements;
+        GLPtr<GrGLEnableProc> fEnable;
+        GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
+        GLPtr<GrGLEndQueryProc> fEndQuery;
+        GLPtr<GrGLFinishProc> fFinish;
+        GLPtr<GrGLFlushProc> fFlush;
+        GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
+        GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
+        GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
+        GLPtr<GrGLFrontFaceProc> fFrontFace;
+        GLPtr<GrGLGenBuffersProc> fGenBuffers;
+        GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
+        GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
+        GLPtr<GrGLGenQueriesProc> fGenQueries;
+        GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
+        GLPtr<GrGLGenTexturesProc> fGenTextures;
+        GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
+        GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
+        GLPtr<GrGLGetErrorProc> fGetError;
+        GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
+        GLPtr<GrGLGetIntegervProc> fGetIntegerv;
+        GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
+        GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
+        GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
+        GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
+        GLPtr<GrGLGetQueryivProc> fGetQueryiv;
+        GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
+        GLPtr<GrGLGetProgramivProc> fGetProgramiv;
+        GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
+        GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
+        GLPtr<GrGLGetShaderivProc> fGetShaderiv;
+        GLPtr<GrGLGetStringProc> fGetString;
+        GLPtr<GrGLGetStringiProc> fGetStringi;
+        GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
+        GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
+        GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
+        GLPtr<GrGLLineWidthProc> fLineWidth;
+        GLPtr<GrGLLinkProgramProc> fLinkProgram;
+        GLPtr<GrGLLoadIdentityProc> fLoadIdentity;
+        GLPtr<GrGLLoadMatrixfProc> fLoadMatrixf;
+        GLPtr<GrGLMapBufferProc> fMapBuffer;
+        GLPtr<GrGLMatrixModeProc> fMatrixMode;
+        GLPtr<GrGLPixelStoreiProc> fPixelStorei;
+        GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
+        GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
+        GLPtr<GrGLQueryCounterProc> fQueryCounter;
+        GLPtr<GrGLReadBufferProc> fReadBuffer;
+        GLPtr<GrGLReadPixelsProc> fReadPixels;
+        GLPtr<GrGLRenderbufferStorageProc> 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
+        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
+        //  GL_APPLE_framebuffer_multisample
+        GLPtr<GrGLRenderbufferStorageMultisampleProc> 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+.
+        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;
+
+        // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
+        GLPtr<GrGLBindUniformLocation> fBindUniformLocation;
+
+        GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
+        GLPtr<GrGLScissorProc> fScissor;
+        GLPtr<GrGLShaderSourceProc> fShaderSource;
+        GLPtr<GrGLStencilFuncProc> fStencilFunc;
+        GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
+        GLPtr<GrGLStencilMaskProc> fStencilMask;
+        GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
+        GLPtr<GrGLStencilOpProc> fStencilOp;
+        GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
+        GLPtr<GrGLTexGenfvProc> fTexGenfv;
+        GLPtr<GrGLTexGeniProc> fTexGeni;
+        GLPtr<GrGLTexImage2DProc> fTexImage2D;
+        GLPtr<GrGLTexParameteriProc> fTexParameteri;
+        GLPtr<GrGLTexParameterivProc> fTexParameteriv;
+        GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
+        GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
+        GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
+        GLPtr<GrGLUniform1fProc> fUniform1f;
+        GLPtr<GrGLUniform1iProc> fUniform1i;
+        GLPtr<GrGLUniform1fvProc> fUniform1fv;
+        GLPtr<GrGLUniform1ivProc> fUniform1iv;
+        GLPtr<GrGLUniform2fProc> fUniform2f;
+        GLPtr<GrGLUniform2iProc> fUniform2i;
+        GLPtr<GrGLUniform2fvProc> fUniform2fv;
+        GLPtr<GrGLUniform2ivProc> fUniform2iv;
+        GLPtr<GrGLUniform3fProc> fUniform3f;
+        GLPtr<GrGLUniform3iProc> fUniform3i;
+        GLPtr<GrGLUniform3fvProc> fUniform3fv;
+        GLPtr<GrGLUniform3ivProc> fUniform3iv;
+        GLPtr<GrGLUniform4fProc> fUniform4f;
+        GLPtr<GrGLUniform4iProc> fUniform4i;
+        GLPtr<GrGLUniform4fvProc> fUniform4fv;
+        GLPtr<GrGLUniform4ivProc> fUniform4iv;
+        GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
+        GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
+        GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
+        GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
+        GLPtr<GrGLUseProgramProc> fUseProgram;
+        GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
+        GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
+        GLPtr<GrGLViewportProc> fViewport;
+
+        // Experimental: Functions for GL_NV_path_rendering. These will be
+        // alphabetized with the above functions once this is fully supported
+        // (and functions we are unlikely to use will possibly be omitted).
+        GLPtr<GrGLPathCommandsProc> fPathCommands;
+        GLPtr<GrGLPathCoordsProc> fPathCoords;
+        GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;
+        GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;
+        GLPtr<GrGLPathStringProc> fPathString;
+        GLPtr<GrGLPathGlyphsProc> fPathGlyphs;
+        GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;
+        GLPtr<GrGLWeightPathsProc> fWeightPaths;
+        GLPtr<GrGLCopyPathProc> fCopyPath;
+        GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;
+        GLPtr<GrGLTransformPathProc> fTransformPath;
+        GLPtr<GrGLPathParameterivProc> fPathParameteriv;
+        GLPtr<GrGLPathParameteriProc> fPathParameteri;
+        GLPtr<GrGLPathParameterfvProc> fPathParameterfv;
+        GLPtr<GrGLPathParameterfProc> fPathParameterf;
+        GLPtr<GrGLPathDashArrayProc> fPathDashArray;
+        GLPtr<GrGLGenPathsProc> fGenPaths;
+        GLPtr<GrGLDeletePathsProc> fDeletePaths;
+        GLPtr<GrGLIsPathProc> fIsPath;
+        GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
+        GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;
+        GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
+        GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
+        GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
+        GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
+        GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;
+        GLPtr<GrGLPathColorGenProc> fPathColorGen;
+        GLPtr<GrGLPathTexGenProc> fPathTexGen;
+        GLPtr<GrGLPathFogGenProc> fPathFogGen;
+        GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
+        GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
+        GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
+        GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
+        GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;
+        GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;
+        GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;
+        GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;
+        GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;
+        GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;
+        GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;
+        GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;
+        GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;
+        GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;
+        GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;
+        GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;
+        GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;
+        GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;
+        GLPtr<GrGLGetPathLengthProc> fGetPathLength;
+        GLPtr<GrGLPointAlongPathProc> fPointAlongPath;
+    } fFunctions;
+
+    // Per-GL func callback
+#if GR_GL_PER_GL_FUNC_CALLBACK
+    GrGLInterfaceCallbackProc fCallback;
+    GrGLInterfaceCallbackData fCallbackData;
+#endif
+};
+
+#endif