The Tor Browser: gfx/angle/src/libGLESv2/renderer/RenderTarget11.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) 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 // RenderTarget11.cpp: Implements a DX11-specific wrapper for ID3D11View pointers

     9 // retained by Renderbuffers.

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

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

    14 #include "libGLESv2/renderer/renderer11_utils.h"

    15 #include "libGLESv2/main.h"

    17 namespace rx

    18 {

    20 static unsigned int getRTVSubresourceIndex(ID3D11Texture2D *texture, ID3D11RenderTargetView *view)

    21 {

    22     D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;

    23     view->GetDesc(&rtvDesc);

    25     D3D11_TEXTURE2D_DESC texDesc;

    26     texture->GetDesc(&texDesc);

    28     unsigned int mipSlice = 0;

    29     unsigned int arraySlice = 0;

    30     unsigned int mipLevels = texDesc.MipLevels;

    32     switch (rtvDesc.ViewDimension)

    33     {

    34       case D3D11_RTV_DIMENSION_TEXTURE1D:

    35         mipSlice = rtvDesc.Texture1D.MipSlice;

    36         arraySlice = 0;

    37         break;

    39       case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:

    40         mipSlice = rtvDesc.Texture1DArray.MipSlice;

    41         arraySlice = rtvDesc.Texture1DArray.FirstArraySlice;

    42         break;

    44       case D3D11_RTV_DIMENSION_TEXTURE2D:

    45         mipSlice = rtvDesc.Texture2D.MipSlice;

    46         arraySlice = 0;

    47         break;

    49       case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:

    50         mipSlice = rtvDesc.Texture2DArray.MipSlice;

    51         arraySlice = rtvDesc.Texture2DArray.FirstArraySlice;

    52         break;

    54       case D3D11_RTV_DIMENSION_TEXTURE2DMS:

    55         mipSlice = 0;

    56         arraySlice = 0;

    57         break;

    59       case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:

    60         mipSlice = 0;

    61         arraySlice = rtvDesc.Texture2DMSArray.FirstArraySlice;

    62         break;

    64       case D3D11_RTV_DIMENSION_TEXTURE3D:

    65         mipSlice = rtvDesc.Texture3D.MipSlice;

    66         arraySlice = 0;

    67         break;

    69       case D3D11_RTV_DIMENSION_UNKNOWN:

    70       case D3D11_RTV_DIMENSION_BUFFER:

    71         UNIMPLEMENTED();

    72         break;

    74       default:

    75         UNREACHABLE();

    76         break;

    77     }

    79     return D3D11CalcSubresource(mipSlice, arraySlice, mipLevels);

    80 }

    82 static unsigned int getDSVSubresourceIndex(ID3D11Texture2D *texture, ID3D11DepthStencilView *view)

    83 {

    84     D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;

    85     view->GetDesc(&dsvDesc);

    87     D3D11_TEXTURE2D_DESC texDesc;

    88     texture->GetDesc(&texDesc);

    90     unsigned int mipSlice = 0;

    91     unsigned int arraySlice = 0;

    92     unsigned int mipLevels = texDesc.MipLevels;

    94     switch (dsvDesc.ViewDimension)

    95     {

    96       case D3D11_DSV_DIMENSION_TEXTURE1D:

    97         mipSlice = dsvDesc.Texture1D.MipSlice;

    98         arraySlice = 0;

    99         break;

   101       case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:

   102         mipSlice = dsvDesc.Texture1DArray.MipSlice;

   103         arraySlice = dsvDesc.Texture1DArray.FirstArraySlice;

   104         break;

   106       case D3D11_DSV_DIMENSION_TEXTURE2D:

   107         mipSlice = dsvDesc.Texture2D.MipSlice;

   108         arraySlice = 0;

   109         break;

   111       case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:

   112         mipSlice = dsvDesc.Texture2DArray.MipSlice;

   113         arraySlice = dsvDesc.Texture2DArray.FirstArraySlice;

   114         break;

   116       case D3D11_DSV_DIMENSION_TEXTURE2DMS:

   117         mipSlice = 0;

   118         arraySlice = 0;

   119         break;

   121       case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:

   122         mipSlice = 0;

   123         arraySlice = dsvDesc.Texture2DMSArray.FirstArraySlice;

   124         break;

   126       case D3D11_RTV_DIMENSION_UNKNOWN:

   127         UNIMPLEMENTED();

   128         break;

   130       default:

   131         UNREACHABLE();

   132         break;

   133     }

   135     return D3D11CalcSubresource(mipSlice, arraySlice, mipLevels);

   136 }

   138 RenderTarget11::RenderTarget11(Renderer *renderer, ID3D11RenderTargetView *rtv, ID3D11Texture2D *tex, ID3D11ShaderResourceView *srv, GLsizei width, GLsizei height)

   139 {

   140     mRenderer = Renderer11::makeRenderer11(renderer);

   141     mTexture = tex;

   142     mRenderTarget = rtv;

   143     mDepthStencil = NULL;

   144     mShaderResource = srv;

   145     mSubresourceIndex = 0;

   147     if (mRenderTarget && mTexture)

   148     {

   149         D3D11_RENDER_TARGET_VIEW_DESC desc;

   150         mRenderTarget->GetDesc(&desc);

   152         D3D11_TEXTURE2D_DESC texDesc;

   153         mTexture->GetDesc(&texDesc);

   155         mSubresourceIndex = getRTVSubresourceIndex(mTexture, mRenderTarget);

   156         mWidth = width;

   157         mHeight = height;

   158         mSamples = (texDesc.SampleDesc.Count > 1) ? texDesc.SampleDesc.Count : 0;

   160         mInternalFormat = d3d11_gl::ConvertTextureInternalFormat(desc.Format);

   161         mActualFormat = d3d11_gl::ConvertTextureInternalFormat(desc.Format);

   162     }

   163 }

   165 RenderTarget11::RenderTarget11(Renderer *renderer, ID3D11DepthStencilView *dsv, ID3D11Texture2D *tex, ID3D11ShaderResourceView *srv, GLsizei width, GLsizei height)

   166 {

   167     mRenderer = Renderer11::makeRenderer11(renderer);

   168     mTexture = tex;

   169     mRenderTarget = NULL;

   170     mDepthStencil = dsv;

   171     mShaderResource = srv;

   172     mSubresourceIndex = 0;

   174     if (mDepthStencil && mTexture)

   175     {

   176         D3D11_DEPTH_STENCIL_VIEW_DESC desc;

   177         mDepthStencil->GetDesc(&desc);

   179         D3D11_TEXTURE2D_DESC texDesc;

   180         mTexture->GetDesc(&texDesc);

   182         mSubresourceIndex = getDSVSubresourceIndex(mTexture, mDepthStencil);

   183         mWidth = width;

   184         mHeight = height;

   185         mSamples = (texDesc.SampleDesc.Count > 1) ? texDesc.SampleDesc.Count : 0;

   187         mInternalFormat = d3d11_gl::ConvertTextureInternalFormat(desc.Format);

   188         mActualFormat = d3d11_gl::ConvertTextureInternalFormat(desc.Format);

   189     }

   190 }

   192 RenderTarget11::RenderTarget11(Renderer *renderer, GLsizei width, GLsizei height, GLenum format, GLsizei samples, bool depth)

   193 {

   194     mRenderer = Renderer11::makeRenderer11(renderer);

   195     mTexture = NULL;

   196     mRenderTarget = NULL;

   197     mDepthStencil = NULL;

   198     mShaderResource = NULL;

   200     DXGI_FORMAT requestedFormat = gl_d3d11::ConvertRenderbufferFormat(format);

   202     int supportedSamples = mRenderer->getNearestSupportedSamples(requestedFormat, samples);

   203     if (supportedSamples < 0)

   204     {

   205         gl::error(GL_OUT_OF_MEMORY);

   206         return;

   207     }

   209     if (width > 0 && height > 0)

   210     {

   211         // Create texture resource

   212         D3D11_TEXTURE2D_DESC desc;

   213         desc.Width = width;

   214         desc.Height = height;

   215         desc.MipLevels = 1;

   216         desc.ArraySize = 1;

   217         desc.Format = requestedFormat;

   218         desc.SampleDesc.Count = (supportedSamples == 0) ? 1 : supportedSamples;

   219         desc.SampleDesc.Quality = 0;

   220         desc.Usage = D3D11_USAGE_DEFAULT;

   221         desc.CPUAccessFlags = 0;

   222         desc.MiscFlags = 0;

   223         desc.BindFlags = (depth ? D3D11_BIND_DEPTH_STENCIL : (D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE));

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

   226         HRESULT result = device->CreateTexture2D(&desc, NULL, &mTexture);

   228         if (result == E_OUTOFMEMORY)

   229         {

   230             gl::error(GL_OUT_OF_MEMORY);

   231             return;

   232         }

   233         ASSERT(SUCCEEDED(result));

   235         if (depth)

   236         {

   237             D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;

   238             dsvDesc.Format = requestedFormat;

   239             dsvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_DSV_DIMENSION_TEXTURE2D : D3D11_DSV_DIMENSION_TEXTURE2DMS;

   240             dsvDesc.Texture2D.MipSlice = 0;

   241             dsvDesc.Flags = 0;

   242             result = device->CreateDepthStencilView(mTexture, &dsvDesc, &mDepthStencil);

   244             if (result == E_OUTOFMEMORY)

   245             {

   246                 mTexture->Release();

   247                 mTexture = NULL;

   248                 gl::error(GL_OUT_OF_MEMORY);

   249             }

   250             ASSERT(SUCCEEDED(result));

   251         }

   252         else

   253         {

   254             D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;

   255             rtvDesc.Format = requestedFormat;

   256             rtvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_RTV_DIMENSION_TEXTURE2D : D3D11_RTV_DIMENSION_TEXTURE2DMS;

   257             rtvDesc.Texture2D.MipSlice = 0;

   258             result = device->CreateRenderTargetView(mTexture, &rtvDesc, &mRenderTarget);

   260             if (result == E_OUTOFMEMORY)

   261             {

   262                 mTexture->Release();

   263                 mTexture = NULL;

   264                 gl::error(GL_OUT_OF_MEMORY);

   265                 return;

   266             }

   267             ASSERT(SUCCEEDED(result));

   269             D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;

   270             srvDesc.Format = requestedFormat;

   271             srvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS;

   272             srvDesc.Texture2D.MostDetailedMip = 0;

   273             srvDesc.Texture2D.MipLevels = 1;

   274             result = device->CreateShaderResourceView(mTexture, &srvDesc, &mShaderResource);

   276             if (result == E_OUTOFMEMORY)

   277             {

   278                 mTexture->Release();

   279                 mTexture = NULL;

   280                 mRenderTarget->Release();

   281                 mRenderTarget = NULL;

   282                 gl::error(GL_OUT_OF_MEMORY);

   283                 return;

   284             }

   285             ASSERT(SUCCEEDED(result));

   286         }

   287     }

   289     mWidth = width;

   290     mHeight = height;

   291     mInternalFormat = format;

   292     mSamples = supportedSamples;

   293     mActualFormat = d3d11_gl::ConvertTextureInternalFormat(requestedFormat);

   294     mSubresourceIndex = D3D11CalcSubresource(0, 0, 1);

   295 }

   297 RenderTarget11::~RenderTarget11()

   298 {

   299     if (mTexture)

   300     {

   301         mTexture->Release();

   302         mTexture = NULL;

   303     }

   305     if (mRenderTarget)

   306     {

   307         mRenderTarget->Release();

   308         mRenderTarget = NULL;

   309     }

   311     if (mDepthStencil)

   312     {

   313         mDepthStencil->Release();

   314         mDepthStencil = NULL;

   315     }

   317     if (mShaderResource)

   318     {

   319         mShaderResource->Release();

   320         mShaderResource = NULL;

   321     }

   322 }

   324 RenderTarget11 *RenderTarget11::makeRenderTarget11(RenderTarget *target)

   325 {

   326     ASSERT(HAS_DYNAMIC_TYPE(rx::RenderTarget11*, target));

   327     return static_cast<rx::RenderTarget11*>(target);

   328 }

   330 ID3D11Texture2D *RenderTarget11::getTexture() const

   331 {

   332     return mTexture;

   333 }

   335 ID3D11RenderTargetView *RenderTarget11::getRenderTargetView() const

   336 {

   337     return mRenderTarget;

   338 }

   340 ID3D11DepthStencilView *RenderTarget11::getDepthStencilView() const

   341 {

   342     return mDepthStencil;

   343 }

   345 ID3D11ShaderResourceView *RenderTarget11::getShaderResourceView() const

   346 {

   347     return mShaderResource;

   348 }

   350 unsigned int RenderTarget11::getSubresourceIndex() const

   351 {

   352     return mSubresourceIndex;

   353 }

   355 }

The Tor Browser / file revision

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

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