The Tor Browser: gfx/angle/src/libGLESv2/renderer/VertexDeclarationCache.cpp@129ffea94266 (annotated)

gfx/angle/src/libGLESv2/renderer/VertexDeclarationCache.cpp@129ffea94266 (annotated)

gfx/angle/src/libGLESv2/renderer/VertexDeclarationCache.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

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.

 #include "precompiled.h"
 //
 // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // VertexDeclarationCache.cpp: Implements a helper class to construct and cache vertex declarations.
 #include "libGLESv2/ProgramBinary.h"
 #include "libGLESv2/Context.h"
 #include "libGLESv2/renderer/VertexBuffer9.h"
 #include "libGLESv2/renderer/VertexDeclarationCache.h"
 namespace rx
 {
 VertexDeclarationCache::VertexDeclarationCache() : mMaxLru(0)
 {
     for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++)
     {
         mVertexDeclCache[i].vertexDeclaration = NULL;
         mVertexDeclCache[i].lruCount = 0;
     }
     for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
     {
         mAppliedVBs[i].serial = 0;
     }
     mLastSetVDecl = NULL;
     mInstancingEnabled = true;
 }
 VertexDeclarationCache::~VertexDeclarationCache()
 {
     for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++)
     {
         if (mVertexDeclCache[i].vertexDeclaration)
         {
             mVertexDeclCache[i].vertexDeclaration->Release();
         }
     }
 }
 GLenum VertexDeclarationCache::applyDeclaration(IDirect3DDevice9 *device, TranslatedAttribute attributes[], gl::ProgramBinary *programBinary, GLsizei instances, GLsizei *repeatDraw)
 {
     *repeatDraw = 1;
     int indexedAttribute = gl::MAX_VERTEX_ATTRIBS;
     int instancedAttribute = gl::MAX_VERTEX_ATTRIBS;
     if (instances > 0)
     {
         // Find an indexed attribute to be mapped to D3D stream 0
         for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
         {
             if (attributes[i].active)
             {
                 if (indexedAttribute == gl::MAX_VERTEX_ATTRIBS && attributes[i].divisor == 0)
                 {
                     indexedAttribute = i;
                 }
                 else if (instancedAttribute == gl::MAX_VERTEX_ATTRIBS && attributes[i].divisor != 0)
                 {
                     instancedAttribute = i;
                 }
                 if (indexedAttribute != gl::MAX_VERTEX_ATTRIBS && instancedAttribute != gl::MAX_VERTEX_ATTRIBS)
                     break;   // Found both an indexed and instanced attribute
             }
         }
         if (indexedAttribute == gl::MAX_VERTEX_ATTRIBS)
         {
             return GL_INVALID_OPERATION;
         }
     }
     D3DVERTEXELEMENT9 elements[gl::MAX_VERTEX_ATTRIBS + 1];
     D3DVERTEXELEMENT9 *element = &elements[0];
     for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
     {
         if (attributes[i].active)
         {
             // Directly binding the storage buffer is not supported for d3d9
             ASSERT(attributes[i].storage == NULL);
             int stream = i;
             if (instances > 0)
             {
                 // Due to a bug on ATI cards we can't enable instancing when none of the attributes are instanced.
                 if (instancedAttribute == gl::MAX_VERTEX_ATTRIBS)
                 {
                     *repeatDraw = instances;
                 }
                 else
                 {
                     if (i == indexedAttribute)
                     {
                         stream = 0;
                     }
                     else if (i == 0)
                     {
                         stream = indexedAttribute;
                     }
                     UINT frequency = 1;
                     if (attributes[i].divisor == 0)
                     {
                         frequency = D3DSTREAMSOURCE_INDEXEDDATA | instances;
                     }
                     else
                     {
                         frequency = D3DSTREAMSOURCE_INSTANCEDATA | attributes[i].divisor;
                     }
                     device->SetStreamSourceFreq(stream, frequency);
                     mInstancingEnabled = true;
                 }
             }
             VertexBuffer9 *vertexBuffer = VertexBuffer9::makeVertexBuffer9(attributes[i].vertexBuffer);
             if (mAppliedVBs[stream].serial != attributes[i].serial ||
                 mAppliedVBs[stream].stride != attributes[i].stride ||
                 mAppliedVBs[stream].offset != attributes[i].offset)
             {
                 device->SetStreamSource(stream, vertexBuffer->getBuffer(), attributes[i].offset, attributes[i].stride);
                 mAppliedVBs[stream].serial = attributes[i].serial;
                 mAppliedVBs[stream].stride = attributes[i].stride;
                 mAppliedVBs[stream].offset = attributes[i].offset;
             }
             element->Stream = stream;
             element->Offset = 0;
             element->Type = attributes[i].attribute->mArrayEnabled ? vertexBuffer->getDeclType(*attributes[i].attribute) : D3DDECLTYPE_FLOAT4;
             element->Method = D3DDECLMETHOD_DEFAULT;
             element->Usage = D3DDECLUSAGE_TEXCOORD;
             element->UsageIndex = programBinary->getSemanticIndex(i);
             element++;
         }
     }
     if (instances == 0 || instancedAttribute == gl::MAX_VERTEX_ATTRIBS)
     {
         if (mInstancingEnabled)
         {
             for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
             {
                 device->SetStreamSourceFreq(i, 1);
             }
             mInstancingEnabled = false;
         }
     }
     static const D3DVERTEXELEMENT9 end = D3DDECL_END();
     *(element++) = end;
     for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++)
     {
         VertexDeclCacheEntry *entry = &mVertexDeclCache[i];
         if (memcmp(entry->cachedElements, elements, (element - elements) * sizeof(D3DVERTEXELEMENT9)) == 0 && entry->vertexDeclaration)
         {
             entry->lruCount = ++mMaxLru;
             if(entry->vertexDeclaration != mLastSetVDecl)
             {
                 device->SetVertexDeclaration(entry->vertexDeclaration);
                 mLastSetVDecl = entry->vertexDeclaration;
             }
             return GL_NO_ERROR;
         }
     }
     VertexDeclCacheEntry *lastCache = mVertexDeclCache;
     for (int i = 0; i < NUM_VERTEX_DECL_CACHE_ENTRIES; i++)
     {
         if (mVertexDeclCache[i].lruCount < lastCache->lruCount)
         {
             lastCache = &mVertexDeclCache[i];
         }
     }
     if (lastCache->vertexDeclaration != NULL)
     {
         lastCache->vertexDeclaration->Release();
         lastCache->vertexDeclaration = NULL;
         // mLastSetVDecl is set to the replacement, so we don't have to worry
         // about it.
     }
     memcpy(lastCache->cachedElements, elements, (element - elements) * sizeof(D3DVERTEXELEMENT9));
     device->CreateVertexDeclaration(elements, &lastCache->vertexDeclaration);
     device->SetVertexDeclaration(lastCache->vertexDeclaration);
     mLastSetVDecl = lastCache->vertexDeclaration;
     lastCache->lruCount = ++mMaxLru;
     return GL_NO_ERROR;
 }
 void VertexDeclarationCache::markStateDirty()
 {
     for (int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
     {
         mAppliedVBs[i].serial = 0;
     }
     mLastSetVDecl = NULL;
     mInstancingEnabled = true;   // Forces it to be disabled when not used
 }
 }

The Tor Browser / annotate

gfx/angle/src/libGLESv2/renderer/VertexDeclarationCache.cpp@129ffea94266 (annotated)

gfx/angle/src/libGLESv2/renderer/VertexDeclarationCache.cpp