The Tor Browser: gfx/angle/src/libGLESv2/renderer/IndexBuffer.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-2012 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 // IndexBuffer.cpp: Defines the abstract IndexBuffer class and IndexBufferInterface

     9 // class with derivations, classes that perform graphics API agnostic index buffer operations.

    11 #include "libGLESv2/renderer/IndexBuffer.h"

    12 #include "libGLESv2/renderer/Renderer.h"

    14 namespace rx

    15 {

    17 unsigned int IndexBuffer::mNextSerial = 1;

    19 IndexBuffer::IndexBuffer()

    20 {

    21     updateSerial();

    22 }

    24 IndexBuffer::~IndexBuffer()

    25 {

    26 }

    28 unsigned int IndexBuffer::getSerial() const

    29 {

    30     return mSerial;

    31 }

    33 void IndexBuffer::updateSerial()

    34 {

    35     mSerial = mNextSerial++;

    36 }

    39 IndexBufferInterface::IndexBufferInterface(Renderer *renderer, bool dynamic) : mRenderer(renderer)

    40 {

    41     mIndexBuffer = renderer->createIndexBuffer();

    43     mDynamic = dynamic;

    44     mWritePosition = 0;

    45 }

    47 IndexBufferInterface::~IndexBufferInterface()

    48 {

    49     if (mIndexBuffer)

    50     {

    51         delete mIndexBuffer;

    52     }

    53 }

    55 GLenum IndexBufferInterface::getIndexType() const

    56 {

    57     return mIndexBuffer->getIndexType();

    58 }

    60 unsigned int IndexBufferInterface::getBufferSize() const

    61 {

    62     return mIndexBuffer->getBufferSize();

    63 }

    65 unsigned int IndexBufferInterface::getSerial() const

    66 {

    67     return mIndexBuffer->getSerial();

    68 }

    70 bool IndexBufferInterface::mapBuffer(unsigned int size, void** outMappedMemory, unsigned int *streamOffset)

    71 {

    72     // Protect against integer overflow

    73     if (mWritePosition + size < mWritePosition)

    74     {

    75         return false;

    76     }

    78     if (!mIndexBuffer->mapBuffer(mWritePosition, size, outMappedMemory))

    79     {

    80         if (outMappedMemory)

    81         {

    82             *outMappedMemory = NULL;

    83         }

    84         return false;

    85     }

    87     if (streamOffset)

    88     {

    89         *streamOffset = mWritePosition;

    90     }

    92     mWritePosition += size;

    93     return true;

    94 }

    96 bool IndexBufferInterface::unmapBuffer()

    97 {

    98     return mIndexBuffer->unmapBuffer();

    99 }

   101 IndexBuffer * IndexBufferInterface::getIndexBuffer() const

   102 {

   103     return mIndexBuffer;

   104 }

   106 unsigned int IndexBufferInterface::getWritePosition() const

   107 {

   108     return mWritePosition;

   109 }

   111 void IndexBufferInterface::setWritePosition(unsigned int writePosition)

   112 {

   113     mWritePosition = writePosition;

   114 }

   116 bool IndexBufferInterface::discard()

   117 {

   118     return mIndexBuffer->discard();

   119 }

   121 bool IndexBufferInterface::setBufferSize(unsigned int bufferSize, GLenum indexType)

   122 {

   123     if (mIndexBuffer->getBufferSize() == 0)

   124     {

   125         return mIndexBuffer->initialize(bufferSize, indexType, mDynamic);

   126     }

   127     else

   128     {

   129         return mIndexBuffer->setSize(bufferSize, indexType);

   130     }

   131 }

   133 StreamingIndexBufferInterface::StreamingIndexBufferInterface(Renderer *renderer) : IndexBufferInterface(renderer, true)

   134 {

   135 }

   137 StreamingIndexBufferInterface::~StreamingIndexBufferInterface()

   138 {

   139 }

   141 bool StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)

   142 {

   143     bool result = true;

   144     unsigned int curBufferSize = getBufferSize();

   145     unsigned int writePos = getWritePosition();

   146     if (size > curBufferSize)

   147     {

   148         result = setBufferSize(std::max(size, 2 * curBufferSize), indexType);

   149         setWritePosition(0);

   150     }

   151     else if (writePos + size > curBufferSize || writePos + size < writePos)

   152     {

   153         if (!discard())

   154         {

   155             return false;

   156         }

   157         setWritePosition(0);

   158     }

   160     return result;

   161 }

   164 StaticIndexBufferInterface::StaticIndexBufferInterface(Renderer *renderer) : IndexBufferInterface(renderer, false)

   165 {

   166 }

   168 StaticIndexBufferInterface::~StaticIndexBufferInterface()

   169 {

   170 }

   172 bool StaticIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)

   173 {

   174     unsigned int curSize = getBufferSize();

   175     if (curSize == 0)

   176     {

   177         return setBufferSize(size, indexType);

   178     }

   179     else if (curSize >= size && indexType == getIndexType())

   180     {

   181         return true;

   182     }

   183     else

   184     {

   185         ERR("Static index buffers can't be resized");

   186         UNREACHABLE();

   187         return false;

   188     }

   189 }

   191 IndexRangeCache *StaticIndexBufferInterface::getIndexRangeCache()

   192 {

   193     return &mIndexRangeCache;

   194 }

   196 }

The Tor Browser / file revision

gfx/angle/src/libGLESv2/renderer/IndexBuffer.cpp@129ffea94266

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