The Tor Browser: gfx/angle/src/libGLESv2/Program.cpp@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 #include "precompiled.h"

     2 //

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

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

     5 // found in the LICENSE file.

     6 //

     8 // Program.cpp: Implements the gl::Program class. Implements GL program objects

     9 // and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28.

    11 #include "libGLESv2/Program.h"

    12 #include "libGLESv2/ProgramBinary.h"

    13 #include "libGLESv2/ResourceManager.h"

    15 #include <algorithm>

    17 namespace gl

    18 {

    19 const char * const g_fakepath = "C:\\fakepath";

    21 AttributeBindings::AttributeBindings()

    22 {

    23 }

    25 AttributeBindings::~AttributeBindings()

    26 {

    27 }

    29 InfoLog::InfoLog() : mInfoLog(NULL)

    30 {

    31 }

    33 InfoLog::~InfoLog()

    34 {

    35     delete[] mInfoLog;

    36 }

    39 int InfoLog::getLength() const

    40 {

    41     if (!mInfoLog)

    42     {

    43         return 0;

    44     }

    45     else

    46     {

    47        return strlen(mInfoLog) + 1;

    48     }

    49 }

    51 void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog)

    52 {

    53     int index = 0;

    55     if (bufSize > 0)

    56     {

    57         if (mInfoLog)

    58         {

    59             index = std::min(bufSize - 1, (int)strlen(mInfoLog));

    60             memcpy(infoLog, mInfoLog, index);

    61         }

    63         infoLog[index] = '\0';

    64     }

    66     if (length)

    67     {

    68         *length = index;

    69     }

    70 }

    72 // append a santized message to the program info log.

    73 // The D3D compiler includes a fake file path in some of the warning or error

    74 // messages, so lets remove all occurrences of this fake file path from the log.

    75 void InfoLog::appendSanitized(const char *message)

    76 {

    77     std::string msg(message);

    79     size_t found;

    80     do

    81     {

    82         found = msg.find(g_fakepath);

    83         if (found != std::string::npos)

    84         {

    85             msg.erase(found, strlen(g_fakepath));

    86         }

    87     }

    88     while (found != std::string::npos);

    90     append("%s", msg.c_str());

    91 }

    93 void InfoLog::append(const char *format, ...)

    94 {

    95     if (!format)

    96     {

    97         return;

    98     }

   100     char info[1024];

   102     va_list vararg;

   103     va_start(vararg, format);

   104     vsnprintf(info, sizeof(info), format, vararg);

   105     va_end(vararg);

   107     size_t infoLength = strlen(info);

   109     if (!mInfoLog)

   110     {

   111         mInfoLog = new char[infoLength + 2];

   112         strcpy(mInfoLog, info);

   113         strcpy(mInfoLog + infoLength, "\n");

   114     }

   115     else

   116     {

   117         size_t logLength = strlen(mInfoLog);

   118         char *newLog = new char[logLength + infoLength + 2];

   119         strcpy(newLog, mInfoLog);

   120         strcpy(newLog + logLength, info);

   121         strcpy(newLog + logLength + infoLength, "\n");

   123         delete[] mInfoLog;

   124         mInfoLog = newLog;

   125     }

   126 }

   128 void InfoLog::reset()

   129 {

   130     if (mInfoLog)

   131     {

   132         delete [] mInfoLog;

   133         mInfoLog = NULL;

   134     }

   135 }

   137 Program::Program(rx::Renderer *renderer, ResourceManager *manager, GLuint handle) : mResourceManager(manager), mHandle(handle)

   138 {

   139     mFragmentShader = NULL;

   140     mVertexShader = NULL;

   141     mProgramBinary.set(NULL);

   142     mDeleteStatus = false;

   143     mLinked = false;

   144     mRefCount = 0;

   145     mRenderer = renderer;

   146 }

   148 Program::~Program()

   149 {

   150     unlink(true);

   152     if (mVertexShader != NULL)

   153     {

   154         mVertexShader->release();

   155     }

   157     if (mFragmentShader != NULL)

   158     {

   159         mFragmentShader->release();

   160     }

   161 }

   163 bool Program::attachShader(Shader *shader)

   164 {

   165     if (shader->getType() == GL_VERTEX_SHADER)

   166     {

   167         if (mVertexShader)

   168         {

   169             return false;

   170         }

   172         mVertexShader = (VertexShader*)shader;

   173         mVertexShader->addRef();

   174     }

   175     else if (shader->getType() == GL_FRAGMENT_SHADER)

   176     {

   177         if (mFragmentShader)

   178         {

   179             return false;

   180         }

   182         mFragmentShader = (FragmentShader*)shader;

   183         mFragmentShader->addRef();

   184     }

   185     else UNREACHABLE();

   187     return true;

   188 }

   190 bool Program::detachShader(Shader *shader)

   191 {

   192     if (shader->getType() == GL_VERTEX_SHADER)

   193     {

   194         if (mVertexShader != shader)

   195         {

   196             return false;

   197         }

   199         mVertexShader->release();

   200         mVertexShader = NULL;

   201     }

   202     else if (shader->getType() == GL_FRAGMENT_SHADER)

   203     {

   204         if (mFragmentShader != shader)

   205         {

   206             return false;

   207         }

   209         mFragmentShader->release();

   210         mFragmentShader = NULL;

   211     }

   212     else UNREACHABLE();

   214     return true;

   215 }

   217 int Program::getAttachedShadersCount() const

   218 {

   219     return (mVertexShader ? 1 : 0) + (mFragmentShader ? 1 : 0);

   220 }

   222 void AttributeBindings::bindAttributeLocation(GLuint index, const char *name)

   223 {

   224     if (index < MAX_VERTEX_ATTRIBS)

   225     {

   226         for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)

   227         {

   228             mAttributeBinding[i].erase(name);

   229         }

   231         mAttributeBinding[index].insert(name);

   232     }

   233 }

   235 void Program::bindAttributeLocation(GLuint index, const char *name)

   236 {

   237     mAttributeBindings.bindAttributeLocation(index, name);

   238 }

   240 // Links the HLSL code of the vertex and pixel shader by matching up their varyings,

   241 // compiling them into binaries, determining the attribute mappings, and collecting

   242 // a list of uniforms

   243 bool Program::link()

   244 {

   245     unlink(false);

   247     mInfoLog.reset();

   249     mProgramBinary.set(new ProgramBinary(mRenderer));

   250     mLinked = mProgramBinary->link(mInfoLog, mAttributeBindings, mFragmentShader, mVertexShader);

   252     return mLinked;

   253 }

   255 int AttributeBindings::getAttributeBinding(const std::string &name) const

   256 {

   257     for (int location = 0; location < MAX_VERTEX_ATTRIBS; location++)

   258     {

   259         if (mAttributeBinding[location].find(name) != mAttributeBinding[location].end())

   260         {

   261             return location;

   262         }

   263     }

   265     return -1;

   266 }

   268 // Returns the program object to an unlinked state, before re-linking, or at destruction

   269 void Program::unlink(bool destroy)

   270 {

   271     if (destroy)   // Object being destructed

   272     {

   273         if (mFragmentShader)

   274         {

   275             mFragmentShader->release();

   276             mFragmentShader = NULL;

   277         }

   279         if (mVertexShader)

   280         {

   281             mVertexShader->release();

   282             mVertexShader = NULL;

   283         }

   284     }

   286     mProgramBinary.set(NULL);

   287     mLinked = false;

   288 }

   290 bool Program::isLinked()

   291 {

   292     return mLinked;

   293 }

   295 ProgramBinary* Program::getProgramBinary()

   296 {

   297     return mProgramBinary.get();

   298 }

   300 bool Program::setProgramBinary(const void *binary, GLsizei length)

   301 {

   302     unlink(false);

   304     mInfoLog.reset();

   306     mProgramBinary.set(new ProgramBinary(mRenderer));

   307     mLinked = mProgramBinary->load(mInfoLog, binary, length);

   308     if (!mLinked)

   309     {

   310         mProgramBinary.set(NULL);

   311     }

   313     return mLinked;

   314 }

   316 void Program::release()

   317 {

   318     mRefCount--;

   320     if (mRefCount == 0 && mDeleteStatus)

   321     {

   322         mResourceManager->deleteProgram(mHandle);

   323     }

   324 }

   326 void Program::addRef()

   327 {

   328     mRefCount++;

   329 }

   331 unsigned int Program::getRefCount() const

   332 {

   333     return mRefCount;

   334 }

   336 GLint Program::getProgramBinaryLength() const

   337 {

   338     ProgramBinary *programBinary = mProgramBinary.get();

   339     if (programBinary)

   340     {

   341         return programBinary->getLength();

   342     }

   343     else

   344     {

   345         return 0;

   346     }

   347 }

   349 int Program::getInfoLogLength() const

   350 {

   351     return mInfoLog.getLength();

   352 }

   354 void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog)

   355 {

   356     return mInfoLog.getLog(bufSize, length, infoLog);

   357 }

   359 void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)

   360 {

   361     int total = 0;

   363     if (mVertexShader)

   364     {

   365         if (total < maxCount)

   366         {

   367             shaders[total] = mVertexShader->getHandle();

   368         }

   370         total++;

   371     }

   373     if (mFragmentShader)

   374     {

   375         if (total < maxCount)

   376         {

   377             shaders[total] = mFragmentShader->getHandle();

   378         }

   380         total++;

   381     }

   383     if (count)

   384     {

   385         *count = total;

   386     }

   387 }

   389 void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)

   390 {

   391     ProgramBinary *programBinary = getProgramBinary();

   392     if (programBinary)

   393     {

   394         programBinary->getActiveAttribute(index, bufsize, length, size, type, name);

   395     }

   396     else

   397     {

   398         if (bufsize > 0)

   399         {

   400             name[0] = '\0';

   401         }

   403         if (length)

   404         {

   405             *length = 0;

   406         }

   408         *type = GL_NONE;

   409         *size = 1;

   410     }

   411 }

   413 GLint Program::getActiveAttributeCount()

   414 {

   415     ProgramBinary *programBinary = getProgramBinary();

   416     if (programBinary)

   417     {

   418         return programBinary->getActiveAttributeCount();

   419     }

   420     else

   421     {

   422         return 0;

   423     }

   424 }

   426 GLint Program::getActiveAttributeMaxLength()

   427 {

   428     ProgramBinary *programBinary = getProgramBinary();

   429     if (programBinary)

   430     {

   431         return programBinary->getActiveAttributeMaxLength();

   432     }

   433     else

   434     {

   435         return 0;

   436     }

   437 }

   439 void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)

   440 {

   441     ProgramBinary *programBinary = getProgramBinary();

   442     if (programBinary)

   443     {

   444         return programBinary->getActiveUniform(index, bufsize, length, size, type, name);

   445     }

   446     else

   447     {

   448         if (bufsize > 0)

   449         {

   450             name[0] = '\0';

   451         }

   453         if (length)

   454         {

   455             *length = 0;

   456         }

   458         *size = 0;

   459         *type = GL_NONE;

   460     }

   461 }

   463 GLint Program::getActiveUniformCount()

   464 {

   465     ProgramBinary *programBinary = getProgramBinary();

   466     if (programBinary)

   467     {

   468         return programBinary->getActiveUniformCount();

   469     }

   470     else

   471     {

   472         return 0;

   473     }

   474 }

   476 GLint Program::getActiveUniformMaxLength()

   477 {

   478     ProgramBinary *programBinary = getProgramBinary();

   479     if (programBinary)

   480     {

   481         return programBinary->getActiveUniformMaxLength();

   482     }

   483     else

   484     {

   485         return 0;

   486     }

   487 }

   489 void Program::flagForDeletion()

   490 {

   491     mDeleteStatus = true;

   492 }

   494 bool Program::isFlaggedForDeletion() const

   495 {

   496     return mDeleteStatus;

   497 }

   499 void Program::validate()

   500 {

   501     mInfoLog.reset();

   503     ProgramBinary *programBinary = getProgramBinary();

   504     if (isLinked() && programBinary)

   505     {

   506         programBinary->validate(mInfoLog);

   507     }

   508     else

   509     {

   510         mInfoLog.append("Program has not been successfully linked.");

   511     }

   512 }

   514 bool Program::isValidated() const

   515 {

   516     ProgramBinary *programBinary = mProgramBinary.get();

   517     if (programBinary)

   518     {

   519         return programBinary->isValidated();

   520     }

   521     else

   522     {

   523         return false;

   524     }

   525 }

   527 }

The Tor Browser / file revision

gfx/angle/src/libGLESv2/Program.cpp@129ffea94266

gfx/angle/src/libGLESv2/Program.cpp