The Tor Browser: gfx/angle/src/libGLESv2/Shader.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 // Shader.h: Defines the abstract gl::Shader class and its concrete derived

     8 // classes VertexShader and FragmentShader. Implements GL shader objects and

     9 // related functionality. [OpenGL ES 2.0.24] section 2.10 page 24 and section

    10 // 3.8 page 84.

    12 #ifndef LIBGLESV2_SHADER_H_

    13 #define LIBGLESV2_SHADER_H_

    15 #define GL_APICALL

    16 #include <GLES2/gl2.h>

    17 #include <string>

    18 #include <list>

    19 #include <vector>

    21 #include "compiler/CompilerUniform.h"

    22 #include "common/angleutils.h"

    24 namespace rx

    25 {

    26 class Renderer;

    27 }

    29 namespace gl

    30 {

    31 class ResourceManager;

    33 struct Varying

    34 {

    35     Varying(GLenum type, const std::string &name, int size, bool array)

    36         : type(type), name(name), size(size), array(array), reg(-1), col(-1)

    37     {

    38     }

    40     GLenum type;

    41     std::string name;

    42     int size;   // Number of 'type' elements

    43     bool array;

    45     int reg;    // First varying register, assigned during link

    46     int col;    // First register element, assigned during link

    47 };

    49 typedef std::list<Varying> VaryingList;

    51 class Shader

    52 {

    53     friend class ProgramBinary;

    55   public:

    56     Shader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle);

    58     virtual ~Shader();

    60     virtual GLenum getType() = 0;

    61     GLuint getHandle() const;

    63     void deleteSource();

    64     void setSource(GLsizei count, const char **string, const GLint *length);

    65     int getInfoLogLength() const;

    66     void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog);

    67     int getSourceLength() const;

    68     void getSource(GLsizei bufSize, GLsizei *length, char *buffer);

    69     int getTranslatedSourceLength() const;

    70     void getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer);

    71     const sh::ActiveUniforms &getUniforms();

    73     virtual void compile() = 0;

    74     virtual void uncompile();

    75     bool isCompiled();

    76     const char *getHLSL();

    78     void addRef();

    79     void release();

    80     unsigned int getRefCount() const;

    81     bool isFlaggedForDeletion() const;

    82     void flagForDeletion();

    84     static void releaseCompiler();

    86   protected:

    87     void parseVaryings();

    88     void resetVaryingsRegisterAssignment();

    90     void compileToHLSL(void *compiler);

    92     void getSourceImpl(char *source, GLsizei bufSize, GLsizei *length, char *buffer);

    94     static GLenum parseType(const std::string &type);

    95     static bool compareVarying(const Varying &x, const Varying &y);

    97     const rx::Renderer *const mRenderer;

    99     VaryingList mVaryings;

   101     bool mUsesMultipleRenderTargets;

   102     bool mUsesFragColor;

   103     bool mUsesFragData;

   104     bool mUsesFragCoord;

   105     bool mUsesFrontFacing;

   106     bool mUsesPointSize;

   107     bool mUsesPointCoord;

   108     bool mUsesDepthRange;

   109     bool mUsesFragDepth;

   111     static void *mFragmentCompiler;

   112     static void *mVertexCompiler;

   114   private:

   115     DISALLOW_COPY_AND_ASSIGN(Shader);

   117     void initializeCompiler();

   119     const GLuint mHandle;

   120     unsigned int mRefCount;     // Number of program objects this shader is attached to

   121     bool mDeleteStatus;         // Flag to indicate that the shader can be deleted when no longer in use

   123     char *mSource;

   124     char *mHlsl;

   125     char *mInfoLog;

   126     sh::ActiveUniforms mActiveUniforms;

   128     ResourceManager *mResourceManager;

   129 };

   131 struct Attribute

   132 {

   133     Attribute() : type(GL_NONE), name("")

   134     {

   135     }

   137     Attribute(GLenum type, const std::string &name) : type(type), name(name)

   138     {

   139     }

   141     GLenum type;

   142     std::string name;

   143 };

   145 typedef std::vector<Attribute> AttributeArray;

   147 class VertexShader : public Shader

   148 {

   149     friend class ProgramBinary;

   151   public:

   152     VertexShader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle);

   154     ~VertexShader();

   156     virtual GLenum getType();

   157     virtual void compile();

   158     virtual void uncompile();

   159     int getSemanticIndex(const std::string &attributeName);

   161   private:

   162     DISALLOW_COPY_AND_ASSIGN(VertexShader);

   164     void parseAttributes();

   166     AttributeArray mAttributes;

   167 };

   169 class FragmentShader : public Shader

   170 {

   171   public:

   172     FragmentShader(ResourceManager *manager,const rx::Renderer *renderer, GLuint handle);

   174     ~FragmentShader();

   176     virtual GLenum getType();

   177     virtual void compile();

   179   private:

   180     DISALLOW_COPY_AND_ASSIGN(FragmentShader);

   181 };

   182 }

   184 #endif   // LIBGLESV2_SHADER_H_

The Tor Browser / file revision

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

gfx/angle/src/libGLESv2/Shader.h