BASELINE: Update chromium to 45.0.2454.40

Change-Id: Id2121d9f11a8fc633677236c65a3e41feef589e4
Reviewed-by: Andras Becsi <andras.becsi@theqtcompany.com>

1 files changed, 92 insertions, 57 deletions

diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
index 1edd24ca6a4..6cd42e2809c 100644
--- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
+++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
@@ -45,7 +45,7 @@ static void ApplyVertices(const gl::Extents &framebufferSize, const gl::Rectangl
     float bottom = 1.0f;
 
     // Clip the quad coordinates to the scissor if needed
-    if (scissor != NULL)
+    if (scissor != nullptr)
     {
         left = std::max(left, (scissor->x / float(framebufferSize.width)) * 2.0f - 1.0f);
         right = std::min(right, ((scissor->x + scissor->width) / float(framebufferSize.width)) * 2.0f - 1.0f);
@@ -59,34 +59,43 @@ static void ApplyVertices(const gl::Extents &framebufferSize, const gl::Rectangl
     d3d11::SetPositionDepthColorVertex<T>(vertices + 3, right, top,    depthClear, color);
 }
 
-template <unsigned int vsSize, unsigned int psSize>
-Clear11::ClearShader Clear11::CreateClearShader(ID3D11Device *device, DXGI_FORMAT colorType, const BYTE (&vsByteCode)[vsSize], const BYTE (&psByteCode)[psSize])
+Clear11::ClearShader::ClearShader(DXGI_FORMAT colorType,
+                                  const char *inputLayoutName,
+                                  const BYTE *vsByteCode,
+                                  size_t vsSize,
+                                  const char *vsDebugName,
+                                  const BYTE *psByteCode,
+                                  size_t psSize,
+                                  const char *psDebugName)
+    : inputLayout(nullptr),
+      vertexShader(vsByteCode, vsSize, vsDebugName),
+      pixelShader(psByteCode, psSize, psDebugName)
 {
-    HRESULT result;
-
-    ClearShader shader = { 0 };
-
     D3D11_INPUT_ELEMENT_DESC quadLayout[] =
     {
         { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
         { "COLOR",    0, colorType,                   0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
     };
 
-    result = device->CreateInputLayout(quadLayout, ArraySize(quadLayout), vsByteCode, vsSize, &shader.inputLayout);
-    ASSERT(SUCCEEDED(result));
-
-    result = device->CreateVertexShader(vsByteCode, vsSize, NULL, &shader.vertexShader);
-    ASSERT(SUCCEEDED(result));
-
-    result = device->CreatePixelShader(psByteCode, psSize, NULL, &shader.pixelShader);
-    ASSERT(SUCCEEDED(result));
+    inputLayout = new d3d11::LazyInputLayout(quadLayout, 2, vsByteCode, vsSize, inputLayoutName);
+}
 
-    return shader;
+Clear11::ClearShader::~ClearShader()
+{
+    SafeDelete(inputLayout);
+    vertexShader.release();
+    pixelShader.release();
 }
 
 Clear11::Clear11(Renderer11 *renderer)
-    : mRenderer(renderer), mClearBlendStates(StructLessThan<ClearBlendInfo>), mClearDepthStencilStates(StructLessThan<ClearDepthStencilInfo>),
-      mVertexBuffer(NULL), mRasterizerState(NULL)
+    : mRenderer(renderer),
+      mClearBlendStates(StructLessThan<ClearBlendInfo>),
+      mFloatClearShader(nullptr),
+      mUintClearShader(nullptr),
+      mIntClearShader(nullptr),
+      mClearDepthStencilStates(StructLessThan<ClearDepthStencilInfo>),
+      mVertexBuffer(nullptr),
+      mRasterizerState(nullptr)
 {
     TRACE_EVENT0("gpu.angle", "Clear11::Clear11");
 
@@ -101,7 +110,7 @@ Clear11::Clear11(Renderer11 *renderer)
     vbDesc.MiscFlags = 0;
     vbDesc.StructureByteStride = 0;
 
-    result = device->CreateBuffer(&vbDesc, NULL, &mVertexBuffer);
+    result = device->CreateBuffer(&vbDesc, nullptr, &mVertexBuffer);
     ASSERT(SUCCEEDED(result));
     d3d11::SetDebugName(mVertexBuffer, "Clear11 masked clear vertex buffer");
 
@@ -123,17 +132,45 @@ Clear11::Clear11(Renderer11 *renderer)
 
     if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
-        mFloatClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_FLOAT, g_VS_ClearFloat, g_PS_ClearFloat_FL9);
+        mFloatClearShader = new ClearShader(DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                            "Clear11 Float IL",
+                                            g_VS_ClearFloat,
+                                            ArraySize(g_VS_ClearFloat),
+                                            "Clear11 Float VS",
+                                            g_PS_ClearFloat_FL9,
+                                            ArraySize(g_PS_ClearFloat_FL9),
+                                            "Clear11 Float PS");
     }
     else
     {
-        mFloatClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_FLOAT, g_VS_ClearFloat, g_PS_ClearFloat);
+        mFloatClearShader = new ClearShader(DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                            "Clear11 Float IL",
+                                            g_VS_ClearFloat,
+                                            ArraySize(g_VS_ClearFloat),
+                                            "Clear11 Float VS",
+                                            g_PS_ClearFloat,
+                                            ArraySize(g_PS_ClearFloat),
+                                            "Clear11 Float PS");
     }
 
     if (renderer->isES3Capable())
     {
-        mUintClearShader  = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_UINT,  g_VS_ClearUint,  g_PS_ClearUint );
-        mIntClearShader   = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_SINT,  g_VS_ClearSint,  g_PS_ClearSint );
+        mUintClearShader = new ClearShader(DXGI_FORMAT_R32G32B32A32_UINT,
+                                           "Clear11 UINT IL",
+                                           g_VS_ClearUint,
+                                           ArraySize(g_VS_ClearUint),
+                                           "Clear11 UINT VS",
+                                           g_PS_ClearUint,
+                                           ArraySize(g_PS_ClearUint),
+                                           "Clear11 UINT PS");
+        mIntClearShader = new ClearShader(DXGI_FORMAT_R32G32B32A32_UINT,
+                                          "Clear11 SINT IL",
+                                          g_VS_ClearSint,
+                                          ArraySize(g_VS_ClearSint),
+                                          "Clear11 SINT VS",
+                                          g_PS_ClearSint,
+                                          ArraySize(g_PS_ClearSint),
+                                          "Clear11 SINT PS");
     }
 }
 
@@ -145,20 +182,9 @@ Clear11::~Clear11()
     }
     mClearBlendStates.clear();
 
-    SafeRelease(mFloatClearShader.inputLayout);
-    SafeRelease(mFloatClearShader.vertexShader);
-    SafeRelease(mFloatClearShader.pixelShader);
-
-    if (mRenderer->isES3Capable())
-    {
-        SafeRelease(mUintClearShader.inputLayout);
-        SafeRelease(mUintClearShader.vertexShader);
-        SafeRelease(mUintClearShader.pixelShader);
-
-        SafeRelease(mIntClearShader.inputLayout);
-        SafeRelease(mIntClearShader.vertexShader);
-        SafeRelease(mIntClearShader.pixelShader);
-    }
+    SafeDelete(mFloatClearShader);
+    SafeDelete(mUintClearShader);
+    SafeDelete(mIntClearShader);
 
     for (ClearDepthStencilStateMap::iterator i = mClearDepthStencilStates.begin(); i != mClearDepthStencilStates.end(); i++)
     {
@@ -239,10 +265,11 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
                                                              clearParams.scissor.y + clearParams.scissor.height < framebufferSize.height);
 
     std::vector<MaskedRenderTarget> maskedClearRenderTargets;
-    RenderTarget11* maskedClearDepthStencil = NULL;
+    RenderTarget11* maskedClearDepthStencil = nullptr;
 
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
     ID3D11DeviceContext1 *deviceContext1 = mRenderer->getDeviceContext1IfSupported();
+    ID3D11Device *device = mRenderer->getDevice();
 
     for (size_t colorAttachment = 0; colorAttachment < colorAttachments.size(); colorAttachment++)
     {
@@ -252,7 +279,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
             attachment.isAttached() &&
             drawBufferStates[colorAttachment] != GL_NONE)
         {
-            RenderTarget11 *renderTarget = NULL;
+            RenderTarget11 *renderTarget = nullptr;
             gl::Error error = attachment.getRenderTarget(&renderTarget);
             if (error.isError())
             {
@@ -307,7 +334,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
 
                 // Check if the actual format has a channel that the internal format does not and set them to the
                 // default values
-                const float clearValues[4] =
+                float clearValues[4] =
                 {
                     ((formatInfo.redBits   == 0 && dxgiFormatInfo.redBits   > 0) ? 0.0f : clearParams.colorFClearValue.red),
                     ((formatInfo.greenBits == 0 && dxgiFormatInfo.greenBits > 0) ? 0.0f : clearParams.colorFClearValue.green),
@@ -315,6 +342,14 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
                     ((formatInfo.alphaBits == 0 && dxgiFormatInfo.alphaBits > 0) ? 1.0f : clearParams.colorFClearValue.alpha),
                 };
 
+                if (dxgiFormatInfo.alphaBits == 1)
+                {
+                    // Some drivers do not correctly handle calling Clear() on a format with 1-bit alpha.
+                    // They can incorrectly round all non-zero values up to 1.0f. Note that WARP does not do this.
+                    // We should handle the rounding for them instead.
+                    clearValues[3] = (clearParams.colorFClearValue.alpha >= 0.5f) ? 1.0f : 0.0f;
+                }
+
                 if (needScissoredClear)
                 {
                     // We shouldn't reach here if deviceContext1 is unavailable.
@@ -341,7 +376,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
         const gl::FramebufferAttachment *attachment = (depthAttachment != nullptr) ? depthAttachment : stencilAttachment;
         ASSERT(attachment != nullptr);
 
-        RenderTarget11 *renderTarget = NULL;
+        RenderTarget11 *renderTarget = nullptr;
         gl::Error error = attachment->getRenderTarget(&renderTarget);
         if (error.isError())
         {
@@ -413,7 +448,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
 
             rtvs[i] = rtv;
         }
-        ID3D11DepthStencilView *dsv = maskedClearDepthStencil ? maskedClearDepthStencil->getDepthStencilView() : NULL;
+        ID3D11DepthStencilView *dsv = maskedClearDepthStencil ? maskedClearDepthStencil->getDepthStencilView() : nullptr;
 
         ID3D11BlendState *blendState = getBlendState(maskedClearRenderTargets);
         const FLOAT blendFactors[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
@@ -425,7 +460,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
         // Set the vertices
         UINT vertexStride = 0;
         const UINT startIdx = 0;
-        const ClearShader* shader = NULL;
+        ClearShader *shader = nullptr;
         D3D11_MAPPED_SUBRESOURCE mappedResource;
         HRESULT result = deviceContext->Map(mVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
         if (FAILED(result))
@@ -433,25 +468,25 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
             return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal masked clear vertex buffer, HRESULT: 0x%X.", result);
         }
 
-        const gl::Rectangle *scissorPtr = clearParams.scissorEnabled ? &clearParams.scissor : NULL;
+        const gl::Rectangle *scissorPtr = clearParams.scissorEnabled ? &clearParams.scissor : nullptr;
         switch (clearParams.colorClearType)
         {
           case GL_FLOAT:
             ApplyVertices(framebufferSize, scissorPtr, clearParams.colorFClearValue, clearParams.depthClearValue, mappedResource.pData);
             vertexStride = sizeof(d3d11::PositionDepthColorVertex<float>);
-            shader = &mFloatClearShader;
+            shader = mFloatClearShader;
             break;
 
           case GL_UNSIGNED_INT:
             ApplyVertices(framebufferSize, scissorPtr, clearParams.colorUIClearValue, clearParams.depthClearValue, mappedResource.pData);
             vertexStride = sizeof(d3d11::PositionDepthColorVertex<unsigned int>);
-            shader = &mUintClearShader;
+            shader = mUintClearShader;
             break;
 
           case GL_INT:
             ApplyVertices(framebufferSize, scissorPtr, clearParams.colorIClearValue, clearParams.depthClearValue, mappedResource.pData);
             vertexStride = sizeof(d3d11::PositionDepthColorVertex<int>);
-            shader = &mIntClearShader;
+            shader = mIntClearShader;
             break;
 
           default:
@@ -477,17 +512,17 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
         deviceContext->RSSetState(mRasterizerState);
 
         // Apply shaders
-        deviceContext->IASetInputLayout(shader->inputLayout);
-        deviceContext->VSSetShader(shader->vertexShader, NULL, 0);
-        deviceContext->PSSetShader(shader->pixelShader, NULL, 0);
-        deviceContext->GSSetShader(NULL, NULL, 0);
+        deviceContext->IASetInputLayout(shader->inputLayout->resolve(device));
+        deviceContext->VSSetShader(shader->vertexShader.resolve(device), nullptr, 0);
+        deviceContext->PSSetShader(shader->pixelShader.resolve(device), nullptr, 0);
+        deviceContext->GSSetShader(nullptr, nullptr, 0);
 
         // Apply vertex buffer
         deviceContext->IASetVertexBuffers(0, 1, &mVertexBuffer, &vertexStride, &startIdx);
         deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
         // Apply render targets
-        deviceContext->OMSetRenderTargets(rtvs.size(), (rtvs.empty() ? NULL : &rtvs[0]), dsv);
+        deviceContext->OMSetRenderTargets(rtvs.size(), (rtvs.empty() ? nullptr : &rtvs[0]), dsv);
 
         // Draw the clear quad
         deviceContext->Draw(4, 0);
@@ -501,7 +536,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
 
 ID3D11BlendState *Clear11::getBlendState(const std::vector<MaskedRenderTarget>& rts)
 {
-    ClearBlendInfo blendKey = { 0 };
+    ClearBlendInfo blendKey = {};
     for (unsigned int i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
     {
         if (i < rts.size())
@@ -544,12 +579,12 @@ ID3D11BlendState *Clear11::getBlendState(const std::vector<MaskedRenderTarget>&
         }
 
         ID3D11Device *device = mRenderer->getDevice();
-        ID3D11BlendState* blendState = NULL;
+        ID3D11BlendState* blendState = nullptr;
         HRESULT result = device->CreateBlendState(&blendDesc, &blendState);
         if (FAILED(result) || !blendState)
         {
             ERR("Unable to create a ID3D11BlendState, HRESULT: 0x%X.", result);
-            return NULL;
+            return nullptr;
         }
 
         mClearBlendStates[blendKey] = blendState;
@@ -589,12 +624,12 @@ ID3D11DepthStencilState *Clear11::getDepthStencilState(const ClearParameters &cl
         dsDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 
         ID3D11Device *device = mRenderer->getDevice();
-        ID3D11DepthStencilState* dsState = NULL;
+        ID3D11DepthStencilState* dsState = nullptr;
         HRESULT result = device->CreateDepthStencilState(&dsDesc, &dsState);
         if (FAILED(result) || !dsState)
         {
             ERR("Unable to create a ID3D11DepthStencilState, HRESULT: 0x%X.", result);
-            return NULL;
+            return nullptr;
         }
 
         mClearDepthStencilStates[dsKey] = dsState;