The Tor Browser: gfx/angle/src/libGLESv2/Context.h@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 //

     2 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.

     3 // Use of this source code is governed by a BSD-style license that can be

     4 // found in the LICENSE file.

     5 //

     7 // Context.h: Defines the gl::Context class, managing all GL state and performing

     8 // rendering operations. It is the GLES2 specific implementation of EGLContext.

    10 #ifndef LIBGLESV2_CONTEXT_H_

    11 #define LIBGLESV2_CONTEXT_H_

    13 #define GL_APICALL

    14 #include <GLES2/gl2.h>

    15 #include <GLES2/gl2ext.h>

    16 #define EGLAPI

    17 #include <EGL/egl.h>

    19 #include <string>

    20 #include <map>

    21 #ifdef _MSC_VER

    22 #include <hash_map>

    23 #else

    24 #include <unordered_map>

    25 #endif

    27 #include "common/angleutils.h"

    28 #include "common/RefCountObject.h"

    29 #include "libGLESv2/HandleAllocator.h"

    30 #include "libGLESv2/angletypes.h"

    31 #include "libGLESv2/Constants.h"

    33 namespace rx

    34 {

    35 class Renderer;

    36 }

    38 namespace egl

    39 {

    40 class Display;

    41 class Surface;

    42 }

    44 namespace gl

    45 {

    46 class Shader;

    47 class Program;

    48 class ProgramBinary;

    49 class Texture;

    50 class Texture2D;

    51 class TextureCubeMap;

    52 class Framebuffer;

    53 class Renderbuffer;

    54 class RenderbufferStorage;

    55 class Colorbuffer;

    56 class Depthbuffer;

    57 class Stencilbuffer;

    58 class DepthStencilbuffer;

    59 class Fence;

    60 class Query;

    61 class ResourceManager;

    62 class Buffer;

    64 enum QueryType

    65 {

    66     QUERY_ANY_SAMPLES_PASSED,

    67     QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE,

    69     QUERY_TYPE_COUNT

    70 };

    72 // Helper structure describing a single vertex attribute

    73 class VertexAttribute

    74 {

    75   public:

    76     VertexAttribute() : mType(GL_FLOAT), mSize(0), mNormalized(false), mStride(0), mPointer(NULL), mArrayEnabled(false), mDivisor(0)

    77     {

    78         mCurrentValue[0] = 0.0f;

    79         mCurrentValue[1] = 0.0f;

    80         mCurrentValue[2] = 0.0f;

    81         mCurrentValue[3] = 1.0f;

    82     }

    84     int typeSize() const

    85     {

    86         switch (mType)

    87         {

    88           case GL_BYTE:           return mSize * sizeof(GLbyte);

    89           case GL_UNSIGNED_BYTE:  return mSize * sizeof(GLubyte);

    90           case GL_SHORT:          return mSize * sizeof(GLshort);

    91           case GL_UNSIGNED_SHORT: return mSize * sizeof(GLushort);

    92           case GL_FIXED:          return mSize * sizeof(GLfixed);

    93           case GL_FLOAT:          return mSize * sizeof(GLfloat);

    94           default: UNREACHABLE(); return mSize * sizeof(GLfloat);

    95         }

    96     }

    98     GLsizei stride() const

    99     {

   100         return mStride ? mStride : typeSize();

   101     }

   103     // From glVertexAttribPointer

   104     GLenum mType;

   105     GLint mSize;

   106     bool mNormalized;

   107     GLsizei mStride;   // 0 means natural stride

   109     union

   110     {

   111         const void *mPointer;

   112         intptr_t mOffset;

   113     };

   115     BindingPointer<Buffer> mBoundBuffer;   // Captured when glVertexAttribPointer is called.

   117     bool mArrayEnabled;   // From glEnable/DisableVertexAttribArray

   118     float mCurrentValue[4];   // From glVertexAttrib

   119     unsigned int mDivisor;

   120 };

   122 // Helper structure to store all raw state

   123 struct State

   124 {

   125     Color colorClearValue;

   126     GLclampf depthClearValue;

   127     int stencilClearValue;

   129     RasterizerState rasterizer;

   130     bool scissorTest;

   131     Rectangle scissor;

   133     BlendState blend;

   134     Color blendColor;

   135     bool sampleCoverage;

   136     GLclampf sampleCoverageValue;

   137     bool sampleCoverageInvert;

   139     DepthStencilState depthStencil;

   140     GLint stencilRef;

   141     GLint stencilBackRef;

   143     GLfloat lineWidth;

   145     GLenum generateMipmapHint;

   146     GLenum fragmentShaderDerivativeHint;

   148     Rectangle viewport;

   149     float zNear;

   150     float zFar;

   152     unsigned int activeSampler;   // Active texture unit selector - GL_TEXTURE0

   153     BindingPointer<Buffer> arrayBuffer;

   154     BindingPointer<Buffer> elementArrayBuffer;

   155     GLuint readFramebuffer;

   156     GLuint drawFramebuffer;

   157     BindingPointer<Renderbuffer> renderbuffer;

   158     GLuint currentProgram;

   160     VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];

   161     BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][IMPLEMENTATION_MAX_COMBINED_TEXTURE_IMAGE_UNITS];

   162     BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];

   164     GLint unpackAlignment;

   165     GLint packAlignment;

   166     bool packReverseRowOrder;

   167 };

   169 class Context

   170 {

   171   public:

   172     Context(const gl::Context *shareContext, rx::Renderer *renderer, bool notifyResets, bool robustAccess);

   174     ~Context();

   176     void makeCurrent(egl::Surface *surface);

   178     virtual void markContextLost();

   179     bool isContextLost();

   181     // State manipulation

   182     void setClearColor(float red, float green, float blue, float alpha);

   184     void setClearDepth(float depth);

   186     void setClearStencil(int stencil);

   188     void setCullFace(bool enabled);

   189     bool isCullFaceEnabled() const;

   191     void setCullMode(GLenum mode);

   193     void setFrontFace(GLenum front);

   195     void setDepthTest(bool enabled);

   196     bool isDepthTestEnabled() const;

   198     void setDepthFunc(GLenum depthFunc);

   200     void setDepthRange(float zNear, float zFar);

   202     void setBlend(bool enabled);

   203     bool isBlendEnabled() const;

   205     void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);

   206     void setBlendColor(float red, float green, float blue, float alpha);

   207     void setBlendEquation(GLenum rgbEquation, GLenum alphaEquation);

   209     void setStencilTest(bool enabled);

   210     bool isStencilTestEnabled() const;

   212     void setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask);

   213     void setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask);

   214     void setStencilWritemask(GLuint stencilWritemask);

   215     void setStencilBackWritemask(GLuint stencilBackWritemask);

   216     void setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass);

   217     void setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass);

   219     void setPolygonOffsetFill(bool enabled);

   220     bool isPolygonOffsetFillEnabled() const;

   222     void setPolygonOffsetParams(GLfloat factor, GLfloat units);

   224     void setSampleAlphaToCoverage(bool enabled);

   225     bool isSampleAlphaToCoverageEnabled() const;

   227     void setSampleCoverage(bool enabled);

   228     bool isSampleCoverageEnabled() const;

   230     void setSampleCoverageParams(GLclampf value, bool invert);

   232     void setScissorTest(bool enabled);

   233     bool isScissorTestEnabled() const;

   235     void setDither(bool enabled);

   236     bool isDitherEnabled() const;

   238     void setLineWidth(GLfloat width);

   240     void setGenerateMipmapHint(GLenum hint);

   241     void setFragmentShaderDerivativeHint(GLenum hint);

   243     void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);

   245     void setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height);

   247     void setColorMask(bool red, bool green, bool blue, bool alpha);

   248     void setDepthMask(bool mask);

   250     void setActiveSampler(unsigned int active);

   252     GLuint getReadFramebufferHandle() const;

   253     GLuint getDrawFramebufferHandle() const;

   254     GLuint getRenderbufferHandle() const;

   256     GLuint getArrayBufferHandle() const;

   258     GLuint getActiveQuery(GLenum target) const;

   260     void setEnableVertexAttribArray(unsigned int attribNum, bool enabled);

   261     const VertexAttribute &getVertexAttribState(unsigned int attribNum);

   262     void setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type,

   263                               bool normalized, GLsizei stride, const void *pointer);

   264     const void *getVertexAttribPointer(unsigned int attribNum) const;

   266     void setUnpackAlignment(GLint alignment);

   267     GLint getUnpackAlignment() const;

   269     void setPackAlignment(GLint alignment);

   270     GLint getPackAlignment() const;

   272     void setPackReverseRowOrder(bool reverseRowOrder);

   273     bool getPackReverseRowOrder() const;

   275     // These create  and destroy methods are merely pass-throughs to

   276     // ResourceManager, which owns these object types

   277     GLuint createBuffer();

   278     GLuint createShader(GLenum type);

   279     GLuint createProgram();

   280     GLuint createTexture();

   281     GLuint createRenderbuffer();

   283     void deleteBuffer(GLuint buffer);

   284     void deleteShader(GLuint shader);

   285     void deleteProgram(GLuint program);

   286     void deleteTexture(GLuint texture);

   287     void deleteRenderbuffer(GLuint renderbuffer);

   289     // Framebuffers are owned by the Context, so these methods do not pass through

   290     GLuint createFramebuffer();

   291     void deleteFramebuffer(GLuint framebuffer);

   293     // Fences are owned by the Context.

   294     GLuint createFence();

   295     void deleteFence(GLuint fence);

   297     // Queries are owned by the Context;

   298     GLuint createQuery();

   299     void deleteQuery(GLuint query);

   301     void bindArrayBuffer(GLuint buffer);

   302     void bindElementArrayBuffer(GLuint buffer);

   303     void bindTexture2D(GLuint texture);

   304     void bindTextureCubeMap(GLuint texture);

   305     void bindReadFramebuffer(GLuint framebuffer);

   306     void bindDrawFramebuffer(GLuint framebuffer);

   307     void bindRenderbuffer(GLuint renderbuffer);

   308     void useProgram(GLuint program);

   309     void linkProgram(GLuint program);

   310     void setProgramBinary(GLuint program, const void *binary, GLint length);

   312     void beginQuery(GLenum target, GLuint query);

   313     void endQuery(GLenum target);

   315     void setFramebufferZero(Framebuffer *framebuffer);

   317     void setRenderbufferStorage(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);

   319     void setVertexAttrib(GLuint index, const GLfloat *values);

   320     void setVertexAttribDivisor(GLuint index, GLuint divisor);

   322     Buffer *getBuffer(GLuint handle);

   323     Fence *getFence(GLuint handle);

   324     Shader *getShader(GLuint handle);

   325     Program *getProgram(GLuint handle);

   326     Texture *getTexture(GLuint handle);

   327     Framebuffer *getFramebuffer(GLuint handle);

   328     Renderbuffer *getRenderbuffer(GLuint handle);

   329     Query *getQuery(GLuint handle, bool create, GLenum type);

   331     Buffer *getArrayBuffer();

   332     Buffer *getElementArrayBuffer();

   333     ProgramBinary *getCurrentProgramBinary();

   334     Texture2D *getTexture2D();

   335     TextureCubeMap *getTextureCubeMap();

   336     Texture *getSamplerTexture(unsigned int sampler, TextureType type);

   337     Framebuffer *getReadFramebuffer();

   338     Framebuffer *getDrawFramebuffer();

   340     bool getFloatv(GLenum pname, GLfloat *params);

   341     bool getIntegerv(GLenum pname, GLint *params);

   342     bool getBooleanv(GLenum pname, GLboolean *params);

   344     bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams);

   346     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);

   347     void clear(GLbitfield mask);

   348     void drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances);

   349     void drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instances);

   350     void sync(bool block);   // flush/finish

   352     void recordInvalidEnum();

   353     void recordInvalidValue();

   354     void recordInvalidOperation();

   355     void recordOutOfMemory();

   356     void recordInvalidFramebufferOperation();

   358     GLenum getError();

   359     GLenum getResetStatus();

   360     virtual bool isResetNotificationEnabled();

   362     int getMajorShaderModel() const;

   363     float getMaximumPointSize() const;

   364     unsigned int getMaximumCombinedTextureImageUnits() const;

   365     int getMaximumRenderbufferDimension() const;

   366     int getMaximumTextureDimension() const;

   367     int getMaximumCubeTextureDimension() const;

   368     int getMaximumTextureLevel() const;

   369     unsigned int getMaximumRenderTargets() const;

   370     GLsizei getMaxSupportedSamples() const;

   371     const char *getExtensionString() const;

   372     const char *getRendererString() const;

   373     bool supportsEventQueries() const;

   374     bool supportsOcclusionQueries() const;

   375     bool supportsBGRATextures() const;

   376     bool supportsDXT1Textures() const;

   377     bool supportsDXT3Textures() const;

   378     bool supportsDXT5Textures() const;

   379     bool supportsFloat32Textures() const;

   380     bool supportsFloat32LinearFilter() const;

   381     bool supportsFloat32RenderableTextures() const;

   382     bool supportsFloat16Textures() const;

   383     bool supportsFloat16LinearFilter() const;

   384     bool supportsFloat16RenderableTextures() const;

   385     bool supportsLuminanceTextures() const;

   386     bool supportsLuminanceAlphaTextures() const;

   387     bool supportsDepthTextures() const;

   388     bool supports32bitIndices() const;

   389     bool supportsNonPower2Texture() const;

   390     bool supportsInstancing() const;

   391     bool supportsTextureFilterAnisotropy() const;

   393     bool getCurrentReadFormatType(GLenum *format, GLenum *type);

   395     float getTextureMaxAnisotropy() const;

   397     void blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,

   398                          GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,

   399                          GLbitfield mask);

   401   private:

   402     DISALLOW_COPY_AND_ASSIGN(Context);

   404     bool applyRenderTarget(GLenum drawMode, bool ignoreViewport);

   405     void applyState(GLenum drawMode);

   406     void applyShaders();

   407     void applyTextures();

   408     void applyTextures(SamplerType type);

   410     void detachBuffer(GLuint buffer);

   411     void detachTexture(GLuint texture);

   412     void detachFramebuffer(GLuint framebuffer);

   413     void detachRenderbuffer(GLuint renderbuffer);

   415     Texture *getIncompleteTexture(TextureType type);

   417     bool skipDraw(GLenum drawMode);

   419     void initExtensionString();

   420     void initRendererString();

   422     rx::Renderer *const mRenderer;

   424     State mState;

   426     BindingPointer<Texture2D> mTexture2DZero;

   427     BindingPointer<TextureCubeMap> mTextureCubeMapZero;

   429 #ifndef HASH_MAP

   430 # ifdef _MSC_VER

   431 #  define HASH_MAP stdext::hash_map

   432 # else

   433 #  define HASH_MAP std::unordered_map

   434 # endif

   435 #endif

   437     typedef HASH_MAP<GLuint, Framebuffer*> FramebufferMap;

   438     FramebufferMap mFramebufferMap;

   439     HandleAllocator mFramebufferHandleAllocator;

   441     typedef HASH_MAP<GLuint, Fence*> FenceMap;

   442     FenceMap mFenceMap;

   443     HandleAllocator mFenceHandleAllocator;

   445     typedef HASH_MAP<GLuint, Query*> QueryMap;

   446     QueryMap mQueryMap;

   447     HandleAllocator mQueryHandleAllocator;

   449     const char *mExtensionString;

   450     const char *mRendererString;

   452     BindingPointer<Texture> mIncompleteTextures[TEXTURE_TYPE_COUNT];

   454     // Recorded errors

   455     bool mInvalidEnum;

   456     bool mInvalidValue;

   457     bool mInvalidOperation;

   458     bool mOutOfMemory;

   459     bool mInvalidFramebufferOperation;

   461     // Current/lost context flags

   462     bool mHasBeenCurrent;

   463     bool mContextLost;

   464     GLenum mResetStatus;

   465     GLenum mResetStrategy;

   466     bool mRobustAccess;

   468     BindingPointer<ProgramBinary> mCurrentProgramBinary;

   469     Framebuffer *mBoundDrawFramebuffer;

   471     int mMajorShaderModel;

   472     float mMaximumPointSize;

   473     bool mSupportsVertexTexture;

   474     bool mSupportsNonPower2Texture;

   475     bool mSupportsInstancing;

   476     int  mMaxViewportDimension;

   477     int  mMaxRenderbufferDimension;

   478     int  mMaxTextureDimension;

   479     int  mMaxCubeTextureDimension;

   480     int  mMaxTextureLevel;

   481     float mMaxTextureAnisotropy;

   482     bool mSupportsEventQueries;

   483     bool mSupportsOcclusionQueries;

   484     bool mSupportsBGRATextures;

   485     bool mSupportsDXT1Textures;

   486     bool mSupportsDXT3Textures;

   487     bool mSupportsDXT5Textures;

   488     bool mSupportsFloat32Textures;

   489     bool mSupportsFloat32LinearFilter;

   490     bool mSupportsFloat32RenderableTextures;

   491     bool mSupportsFloat16Textures;

   492     bool mSupportsFloat16LinearFilter;

   493     bool mSupportsFloat16RenderableTextures;

   494     bool mSupportsLuminanceTextures;

   495     bool mSupportsLuminanceAlphaTextures;

   496     bool mSupportsDepthTextures;

   497     bool mSupports32bitIndices;

   498     bool mSupportsTextureFilterAnisotropy;

   499     int mNumCompressedTextureFormats;

   501     ResourceManager *mResourceManager;

   502 };

   503 }

   505 #endif   // INCLUDE_CONTEXT_H_

The Tor Browser / file revision

gfx/angle/src/libGLESv2/Context.h@129ffea94266

gfx/angle/src/libGLESv2/Context.h