The Tor Browser: gfx/angle/src/libGLESv2/renderer/BufferStorage11.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) 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 // BufferStorage11.cpp Defines the BufferStorage11 class.

    10 #include "libGLESv2/renderer/BufferStorage11.h"

    11 #include "libGLESv2/main.h"

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

    14 namespace rx

    15 {

    17 BufferStorage11::BufferStorage11(Renderer11 *renderer)

    18 {

    19     mRenderer = renderer;

    21     mStagingBuffer = NULL;

    22     mStagingBufferSize = 0;

    24     mBuffer = NULL;

    25     mBufferSize = 0;

    27     mSize = 0;

    29     mResolvedData = NULL;

    30     mResolvedDataSize = 0;

    31     mResolvedDataValid = false;

    33     mReadUsageCount = 0;

    34     mWriteUsageCount = 0;

    35 }

    37 BufferStorage11::~BufferStorage11()

    38 {

    39     if (mStagingBuffer)

    40     {

    41         mStagingBuffer->Release();

    42         mStagingBuffer = NULL;

    43     }

    45     if (mBuffer)

    46     {

    47         mBuffer->Release();

    48         mBuffer = NULL;

    49     }

    51     if (mResolvedData)

    52     {

    53         free(mResolvedData);

    54         mResolvedData = NULL;

    55     }

    56 }

    58 BufferStorage11 *BufferStorage11::makeBufferStorage11(BufferStorage *bufferStorage)

    59 {

    60     ASSERT(HAS_DYNAMIC_TYPE(BufferStorage11*, bufferStorage));

    61     return static_cast<BufferStorage11*>(bufferStorage);

    62 }

    64 void *BufferStorage11::getData()

    65 {

    66     if (!mResolvedDataValid)

    67     {

    68         ID3D11Device *device = mRenderer->getDevice();

    69         ID3D11DeviceContext *context = mRenderer->getDeviceContext();

    70         HRESULT result;

    72         if (!mStagingBuffer || mStagingBufferSize < mBufferSize)

    73         {

    74             if (mStagingBuffer)

    75             {

    76                 mStagingBuffer->Release();

    77                 mStagingBuffer = NULL;

    78                 mStagingBufferSize = 0;

    79             }

    81             D3D11_BUFFER_DESC bufferDesc;

    82             bufferDesc.ByteWidth = mSize;

    83             bufferDesc.Usage = D3D11_USAGE_STAGING;

    84             bufferDesc.BindFlags = 0;

    85             bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;

    86             bufferDesc.MiscFlags = 0;

    87             bufferDesc.StructureByteStride = 0;

    89             result = device->CreateBuffer(&bufferDesc, NULL, &mStagingBuffer);

    90             if (FAILED(result))

    91             {

    92                 return gl::error(GL_OUT_OF_MEMORY, (void*)NULL);

    93             }

    95             mStagingBufferSize = bufferDesc.ByteWidth;

    96         }

    98         if (!mResolvedData || mResolvedDataSize < mBufferSize)

    99         {

   100             free(mResolvedData);

   101             mResolvedData = malloc(mSize);

   102             mResolvedDataSize = mSize;

   103         }

   105         D3D11_BOX srcBox;

   106         srcBox.left = 0;

   107         srcBox.right = mSize;

   108         srcBox.top = 0;

   109         srcBox.bottom = 1;

   110         srcBox.front = 0;

   111         srcBox.back = 1;

   113         context->CopySubresourceRegion(mStagingBuffer, 0, 0, 0, 0, mBuffer, 0, &srcBox);

   115         D3D11_MAPPED_SUBRESOURCE mappedResource;

   116         result = context->Map(mStagingBuffer, 0, D3D11_MAP_READ, 0, &mappedResource);

   117         if (FAILED(result))

   118         {

   119             return gl::error(GL_OUT_OF_MEMORY, (void*)NULL);

   120         }

   122         memcpy(mResolvedData, mappedResource.pData, mSize);

   124         context->Unmap(mStagingBuffer, 0);

   126         mResolvedDataValid = true;

   127     }

   129     mReadUsageCount = 0;

   131     return mResolvedData;

   132 }

   134 void BufferStorage11::setData(const void* data, unsigned int size, unsigned int offset)

   135 {

   136     ID3D11Device *device = mRenderer->getDevice();

   137     ID3D11DeviceContext *context = mRenderer->getDeviceContext();

   138     HRESULT result;

   140     unsigned int requiredBufferSize = size + offset;

   141     unsigned int requiredStagingSize = size;

   142     bool directInitialization = offset == 0 && (!mBuffer || mBufferSize < size + offset);

   144     if (!directInitialization)

   145     {

   146         if (!mStagingBuffer || mStagingBufferSize < requiredStagingSize)

   147         {

   148             if (mStagingBuffer)

   149             {

   150                 mStagingBuffer->Release();

   151                 mStagingBuffer = NULL;

   152                 mStagingBufferSize = 0;

   153             }

   155             D3D11_BUFFER_DESC bufferDesc;

   156             bufferDesc.ByteWidth = size;

   157             bufferDesc.Usage = D3D11_USAGE_STAGING;

   158             bufferDesc.BindFlags = 0;

   159             bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;

   160             bufferDesc.MiscFlags = 0;

   161             bufferDesc.StructureByteStride = 0;

   163             if (data)

   164             {

   165                 D3D11_SUBRESOURCE_DATA initialData;

   166                 initialData.pSysMem = data;

   167                 initialData.SysMemPitch = size;

   168                 initialData.SysMemSlicePitch = 0;

   170                 result = device->CreateBuffer(&bufferDesc, &initialData, &mStagingBuffer);

   171             }

   172             else

   173             {

   174                 result = device->CreateBuffer(&bufferDesc, NULL, &mStagingBuffer);

   175             }

   177             if (FAILED(result))

   178             {

   179                 return gl::error(GL_OUT_OF_MEMORY);

   180             }

   182             mStagingBufferSize = size;

   183         }

   184         else if (data)

   185         {

   186             D3D11_MAPPED_SUBRESOURCE mappedResource;

   187             result = context->Map(mStagingBuffer, 0, D3D11_MAP_WRITE, 0, &mappedResource);

   188             if (FAILED(result))

   189             {

   190                 return gl::error(GL_OUT_OF_MEMORY);

   191             }

   193             memcpy(mappedResource.pData, data, size);

   195             context->Unmap(mStagingBuffer, 0);

   196         }

   197     }

   199     if (!mBuffer || mBufferSize < size + offset)

   200     {

   201         D3D11_BUFFER_DESC bufferDesc;

   202         bufferDesc.ByteWidth = requiredBufferSize;

   203         bufferDesc.Usage = D3D11_USAGE_DEFAULT;

   204         bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_INDEX_BUFFER;

   205         bufferDesc.CPUAccessFlags = 0;

   206         bufferDesc.MiscFlags = 0;

   207         bufferDesc.StructureByteStride = 0;

   209         if (directInitialization)

   210         {

   211             // Since the data will fill the entire buffer (being larger than the initial size and having

   212             // no offset), the buffer can be initialized with the data so no staging buffer is required

   214             // No longer need the old buffer

   215             if (mBuffer)

   216             {

   217                 mBuffer->Release();

   218                 mBuffer = NULL;

   219                 mBufferSize = 0;

   220             }

   222             if (data)

   223             {

   224                 D3D11_SUBRESOURCE_DATA initialData;

   225                 initialData.pSysMem = data;

   226                 initialData.SysMemPitch = size;

   227                 initialData.SysMemSlicePitch = 0;

   229                 result = device->CreateBuffer(&bufferDesc, &initialData, &mBuffer);

   230             }

   231             else

   232             {

   233                 result = device->CreateBuffer(&bufferDesc, NULL, &mBuffer);

   234             }

   236             if (FAILED(result))

   237             {

   238                 return gl::error(GL_OUT_OF_MEMORY);

   239             }

   240         }

   241         else if (mBuffer && offset > 0)

   242         {

   243             // If offset is greater than zero and the buffer is non-null, need to preserve the data from

   244             // the old buffer up to offset

   245             ID3D11Buffer *newBuffer = NULL;

   247             result = device->CreateBuffer(&bufferDesc, NULL, &newBuffer);

   248             if (FAILED(result))

   249             {

   250                 return gl::error(GL_OUT_OF_MEMORY);

   251             }

   253             D3D11_BOX srcBox;

   254             srcBox.left = 0;

   255             srcBox.right = std::min(offset, mBufferSize);

   256             srcBox.top = 0;

   257             srcBox.bottom = 1;

   258             srcBox.front = 0;

   259             srcBox.back = 1;

   261             context->CopySubresourceRegion(newBuffer, 0, 0, 0, 0, mBuffer, 0, &srcBox);

   263             mBuffer->Release();

   264             mBuffer = newBuffer;

   265         }

   266         else

   267         {

   268             // Simple case, nothing needs to be copied from the old buffer to the new one, just create

   269             // a new buffer

   271             // No longer need the old buffer

   272             if (mBuffer)

   273             {

   274                 mBuffer->Release();

   275                 mBuffer = NULL;

   276                 mBufferSize = 0;

   277             }

   279             // Create a new buffer for data storage

   280             result = device->CreateBuffer(&bufferDesc, NULL, &mBuffer);

   281             if (FAILED(result))

   282             {

   283                 return gl::error(GL_OUT_OF_MEMORY);

   284             }

   285         }

   287         updateSerial();

   288         mBufferSize = bufferDesc.ByteWidth;

   289     }

   291     if (!directInitialization)

   292     {

   293         ASSERT(mStagingBuffer && mStagingBufferSize >= requiredStagingSize);

   295         // Data is already put into the staging buffer, copy it over to the data buffer

   296         D3D11_BOX srcBox;

   297         srcBox.left = 0;

   298         srcBox.right = size;

   299         srcBox.top = 0;

   300         srcBox.bottom = 1;

   301         srcBox.front = 0;

   302         srcBox.back = 1;

   304         context->CopySubresourceRegion(mBuffer, 0, offset, 0, 0, mStagingBuffer, 0, &srcBox);

   305     }

   307     mSize = std::max(mSize, offset + size);

   309     mWriteUsageCount = 0;

   311     mResolvedDataValid = false;

   312 }

   314 void BufferStorage11::clear()

   315 {

   316     mResolvedDataValid = false;

   317     mSize = 0;

   318 }

   320 unsigned int BufferStorage11::getSize() const

   321 {

   322     return mSize;

   323 }

   325 bool BufferStorage11::supportsDirectBinding() const

   326 {

   327     return true;

   328 }

   330 void BufferStorage11::markBufferUsage()

   331 {

   332     mReadUsageCount++;

   333     mWriteUsageCount++;

   335     static const unsigned int usageLimit = 5;

   337     if (mReadUsageCount > usageLimit && mResolvedData)

   338     {

   339         free(mResolvedData);

   340         mResolvedData = NULL;

   341         mResolvedDataSize = 0;

   342         mResolvedDataValid = false;

   343     }

   345     if (mReadUsageCount > usageLimit && mWriteUsageCount > usageLimit && mStagingBuffer)

   346     {

   347         mStagingBuffer->Release();

   348         mStagingBuffer = NULL;

   349         mStagingBufferSize = 0;

   350     }

   351 }

   353 ID3D11Buffer *BufferStorage11::getBuffer() const

   354 {

   355     return mBuffer;

   356 }

   358 }

The Tor Browser / file revision

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

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