From 4979a49c3fdb872fcac93c6bfc02480ef14c5faf Mon Sep 17 00:00:00 2001
From: Shahbaz Youssefi <syoussefi@chromium.org>
Date: Sun, 20 Sep 2026 16:40:25 -0400
Subject: [PATCH] Always expand non-vec4 fragment outputs to vec4

... on hardened contexts.  The alpha channel is undefined if unwritten,
which leads to undefined values produced when blending.  Previously,
this was implemented as a driver bug workaround. which is now done for
all backends and drivers.

The MSL generator already does this during codegen regardless of
hardened contexts.  That's left alone for now and can be rethought
during the IR port.

Bug: chromium:563350676
Bug: chromium:563352451
Bug: chromium:563352515
Change-Id: Iafc64548b97811620d54bb195eb2b43a3212951e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/8427088
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
---
diff --git a/include/platform/gl_features.json b/include/platform/gl_features.json
index 080bf18..6557442 100644
--- a/include/platform/gl_features.json
+++ b/include/platform/gl_features.json
@@ -940,14 +940,6 @@
             "issue": "http://crbug.com/475877320"
         },
         {
-            "name": "expand_fragment_outputs_to_vec4",
-            "category": "Workarounds",
-            "description": [
-                "Expand fragment shader outputs to 4 components to work around compiler bugs."
-            ],
-            "issue": "http://crbug.com/491732188"
-        },
-        {
             "name": "recreate_mipmap_levels_before_generate",
             "category": "Workarounds",
             "description": [
diff --git a/src/compiler/translator/Compiler.cpp b/src/compiler/translator/Compiler.cpp
index d76cffe..8b15540 100644
--- a/src/compiler/translator/Compiler.cpp
+++ b/src/compiler/translator/Compiler.cpp
@@ -31,6 +31,7 @@
 #include "compiler/translator/tree_ops/DeferGlobalInitializers.h"
 #include "compiler/translator/tree_ops/EmulateGLFragColorBroadcast.h"
 #include "compiler/translator/tree_ops/EmulateMultiDrawShaderBuiltins.h"
+#include "compiler/translator/tree_ops/ExpandFragmentOutputsToVec4.h"
 #include "compiler/translator/tree_ops/FoldExpressions.h"
 #include "compiler/translator/tree_ops/InitializeVariables.h"
 #include "compiler/translator/tree_ops/PruneEmptyCases.h"
@@ -1172,6 +1173,14 @@
         }
     }
 
+    if (compileOptions.expandFragmentOutputsToVec4 && mShaderVersion >= 300)
+    {
+        if (!ExpandFragmentOutputsToVec4(this, root, &getSymbolTable()))
+        {
+            return false;
+        }
+    }
+
     return true;
 }
 
diff --git a/src/compiler/translator/glsl/TranslatorESSL.cpp b/src/compiler/translator/glsl/TranslatorESSL.cpp
index 69889c4..5c65939 100644
--- a/src/compiler/translator/glsl/TranslatorESSL.cpp
+++ b/src/compiler/translator/glsl/TranslatorESSL.cpp
@@ -17,7 +17,6 @@
 #include "compiler/translator/tree_ops/MonomorphizeUnsupportedFunctions.h"
 #include "compiler/translator/tree_ops/RecordConstantPrecision.h"
 #include "compiler/translator/tree_ops/RemoveDynamicIndexing.h"
-#include "compiler/translator/tree_ops/glsl/ExpandFragmentOutputsToVec4.h"
 #include "compiler/translator/tree_util/FindSymbolNode.h"
 #include "compiler/translator/tree_util/ReplaceClipCullDistanceVariable.h"
 #include "compiler/translator/tree_util/RunAtTheEndOfShader.h"
@@ -128,13 +127,6 @@
             return false;
         }
     }
-    if (compileOptions.expandFragmentOutputsToVec4)
-    {
-        if (!ExpandFragmentOutputsToVec4(this, root, &getSymbolTable()))
-        {
-            return false;
-        }
-    }
 
     // Write emulated built-in functions if needed.
     BuiltInFunctionEmulator builtInFunctionEmulator;
diff --git a/src/compiler/translator/glsl/TranslatorGLSL.cpp b/src/compiler/translator/glsl/TranslatorGLSL.cpp
index 6ee3f56..f63098a 100644
--- a/src/compiler/translator/glsl/TranslatorGLSL.cpp
+++ b/src/compiler/translator/glsl/TranslatorGLSL.cpp
@@ -18,7 +18,6 @@
 #include "compiler/translator/tree_ops/RemoveDynamicIndexing.h"
 #include "compiler/translator/tree_ops/RemoveInvariantDeclaration.h"
 #include "compiler/translator/tree_ops/RewriteTexelFetchOffset.h"
-#include "compiler/translator/tree_ops/glsl/ExpandFragmentOutputsToVec4.h"
 #include "compiler/translator/tree_ops/glsl/apple/RewriteRowMajorMatrices.h"
 
 namespace sh
@@ -138,13 +137,6 @@
             return false;
         }
     }
-    if (compileOptions.expandFragmentOutputsToVec4)
-    {
-        if (!ExpandFragmentOutputsToVec4(this, root, &getSymbolTable()))
-        {
-            return false;
-        }
-    }
 
     // Write emulated built-in functions if needed.
     BuiltInFunctionEmulator builtInFunctionEmulator;
diff --git a/src/compiler/translator/ir/src/compile.cpp b/src/compiler/translator/ir/src/compile.cpp
index dafb127..dfe05dc 100644
--- a/src/compiler/translator/ir/src/compile.cpp
+++ b/src/compiler/translator/ir/src/compile.cpp
@@ -155,6 +155,7 @@
     opt->retain_inactive_fragment_outputs            = options.retainInactiveFragmentOutputs;
     opt->scalarize_vec_and_mat_constructor_args      = options.scalarizeVecAndMatConstructorArgs;
     opt->clamp_indirect_indices                      = options.clampIndirectArrayBounds;
+    opt->expand_fragment_outputs_to_vec4             = options.expandFragmentOutputsToVec4;
 
     opt->rewrite_pixel_local_storage = compiler->hasPixelLocalStorageUniforms();
     opt->pls_options.implementation  = static_cast<ffi::PixelLocalStorageImpl>(options.pls.type);
diff --git a/src/compiler/translator/ir/src/compile.rs b/src/compiler/translator/ir/src/compile.rs
index 6dbfd5c..39411f0 100644
--- a/src/compiler/translator/ir/src/compile.rs
+++ b/src/compiler/translator/ir/src/compile.rs
@@ -219,6 +219,8 @@
         scalarize_vec_and_mat_constructor_args: bool,
         // Clamp non-constant indices to the bounds of the entity being indexed for robustness.
         clamp_indirect_indices: bool,
+        // Whether ESSL300 fragment outputs should be expanded to vec4s.
+        expand_fragment_outputs_to_vec4: bool,
 
         // Whether the ANGLE_pixel_local_storage extension has been used and there are PLS uniforms
         // to rewrite.
@@ -673,6 +675,11 @@
         };
         transform::run!(localized_workarounds, ir, &transform_options);
     }
+
+    if options.expand_fragment_outputs_to_vec4 && options.shader_version >= 300 {
+        debug_assert!(ir.meta.get_shader_type() == ShaderType::Fragment);
+        transform::run!(expand_fragment_outputs_to_vec4, ir);
+    }
 }
 
 fn initialize_global_pool_index_workaround() {
diff --git a/src/compiler/translator/ir/src/ir.rs b/src/compiler/translator/ir/src/ir.rs
index 68e95c4..48e2443 100644
--- a/src/compiler/translator/ir/src/ir.rs
+++ b/src/compiler/translator/ir/src/ir.rs
@@ -3354,17 +3354,18 @@
     // variable is replaced with the global variable and a new id is assigned to the interface
     // variable and returned.  This way, the shader does not need to be modified except for
     // possibly writing to the cache variable at the start of shader and reading from it at the
-    // end.
+    // end.  If requested, the original variable's type is overridden with a given type.
     pub fn declare_cached_global_for_variable(
         &mut self,
         variable_id: VariableId,
         cache_name: &'static str,
+        original_variable_type_override: Option<TypeId>,
     ) -> (VariableId, TypedId) {
         let variable = self.get_variable_mut(variable_id);
 
         // Replace the variable with a private global.
         let original_name = std::mem::replace(&mut variable.name, Name::new_temp(cache_name));
-        let type_id = variable.type_id;
+        let type_id = original_variable_type_override.unwrap_or(variable.type_id);
         let precision = variable.precision;
         let precise = variable.precise;
         let original_decorations =
diff --git a/src/compiler/translator/ir/src/transform.rs b/src/compiler/translator/ir/src/transform.rs
index cf13c07..4fb0668 100644
--- a/src/compiler/translator/ir/src/transform.rs
+++ b/src/compiler/translator/ir/src/transform.rs
@@ -9,6 +9,7 @@
 pub mod dealias;
 pub mod emulate_instanced_multiview;
 pub mod emulate_multi_draw;
+pub mod expand_fragment_outputs_to_vec4;
 pub mod initialize_uninitialized_variables;
 pub mod localized_workarounds;
 pub mod monomorphize_unsupported_functions;
diff --git a/src/compiler/translator/ir/src/transform/emulate_instanced_multiview.rs b/src/compiler/translator/ir/src/transform/emulate_instanced_multiview.rs
index 39ea3f1..7f8bbf0 100644
--- a/src/compiler/translator/ir/src/transform/emulate_instanced_multiview.rs
+++ b/src/compiler/translator/ir/src/transform/emulate_instanced_multiview.rs
@@ -84,7 +84,10 @@
 
     // Make a duplicate of gl_InstanceID to add to globals, and let the shader use the replacement.
     (
-        state.ir_meta.declare_cached_global_for_variable(replaced_instance_id, "InstanceID").1,
+        state
+            .ir_meta
+            .declare_cached_global_for_variable(replaced_instance_id, "InstanceID", None)
+            .1,
         replaced_instance_id_typed,
     )
 }
diff --git a/src/compiler/translator/ir/src/transform/emulate_multi_draw.rs b/src/compiler/translator/ir/src/transform/emulate_multi_draw.rs
index a942cef..d3d37ba 100644
--- a/src/compiler/translator/ir/src/transform/emulate_multi_draw.rs
+++ b/src/compiler/translator/ir/src/transform/emulate_multi_draw.rs
@@ -64,7 +64,7 @@
 fn add_base_vertex_to_vertex_id(ir: &mut IR) {
     if let Some(vertex_id) = ir.meta.get_built_in_variable(BuiltIn::VertexID) {
         let replaced_vertex_id = TypedId::from_variable_id(&ir.meta, vertex_id);
-        let vertex_id = ir.meta.declare_cached_global_for_variable(vertex_id, "VertexID").1;
+        let vertex_id = ir.meta.declare_cached_global_for_variable(vertex_id, "VertexID", None).1;
 
         let base_vertex = ir.meta.get_or_declare_built_in_variable(BuiltIn::BaseVertex).1;
 
diff --git a/src/compiler/translator/ir/src/transform/expand_fragment_outputs_to_vec4.rs b/src/compiler/translator/ir/src/transform/expand_fragment_outputs_to_vec4.rs
new file mode 100644
index 0000000..294f53e
--- /dev/null
+++ b/src/compiler/translator/ir/src/transform/expand_fragment_outputs_to_vec4.rs
@@ -0,0 +1,153 @@
+// Copyright 2026 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.
+//
+// Turn gvecN (N < 4) fragment outputs to gvec4, filling the missing components with 0.
+
+use crate::ir::*;
+use crate::*;
+
+pub fn run(ir: &mut IR) {
+    for variable_id in ir.meta.all_global_variables().clone() {
+        // Must be an `out` variable
+        let variable = ir.meta.get_variable(variable_id);
+        if !variable.decorations.has(Decoration::Output) {
+            continue;
+        }
+
+        // Must have fewer than 4 components.
+        let base_type_id = ir.meta.get_pointee_type(variable.type_id);
+        let (base_type_id, array_size) =
+            if let &Type::Array(base_type_id, size) = ir.meta.get_type(base_type_id) {
+                (base_type_id, Some(size))
+            } else {
+                (base_type_id, None)
+            };
+
+        if let Some((expanded_type_id, component_count, zero)) = expand_type_to_vec4(base_type_id) {
+            replace_output_variable(
+                ir,
+                variable_id,
+                variable.name.name,
+                expanded_type_id,
+                component_count,
+                array_size,
+                zero,
+            );
+        }
+    }
+}
+
+fn expand_type_to_vec4(type_id: TypeId) -> Option<(TypeId, u32, TypedId)> {
+    match type_id {
+        TYPE_ID_FLOAT => Some((TYPE_ID_VEC4, 1, TYPED_CONSTANT_ID_FLOAT_ZERO)),
+        TYPE_ID_VEC2 => Some((TYPE_ID_VEC4, 2, TYPED_CONSTANT_ID_FLOAT_ZERO)),
+        TYPE_ID_VEC3 => Some((TYPE_ID_VEC4, 3, TYPED_CONSTANT_ID_FLOAT_ZERO)),
+        TYPE_ID_INT => Some((TYPE_ID_IVEC4, 1, TYPED_CONSTANT_ID_INT_ZERO)),
+        TYPE_ID_IVEC2 => Some((TYPE_ID_IVEC4, 2, TYPED_CONSTANT_ID_INT_ZERO)),
+        TYPE_ID_IVEC3 => Some((TYPE_ID_IVEC4, 3, TYPED_CONSTANT_ID_INT_ZERO)),
+        TYPE_ID_UINT => Some((TYPE_ID_UVEC4, 1, TYPED_CONSTANT_ID_UINT_ZERO)),
+        TYPE_ID_UVEC2 => Some((TYPE_ID_UVEC4, 2, TYPED_CONSTANT_ID_UINT_ZERO)),
+        TYPE_ID_UVEC3 => Some((TYPE_ID_UVEC4, 3, TYPED_CONSTANT_ID_UINT_ZERO)),
+        _ => None,
+    }
+}
+
+fn replace_output_variable(
+    ir: &mut IR,
+    variable_id: VariableId,
+    name: &'static str,
+    expanded_type_id: TypeId,
+    component_count: u32,
+    array_size: Option<u32>,
+    basic_type_zero: TypedId,
+) {
+    let complete_type = if let Some(array_size) = array_size {
+        ir.meta.get_array_type_id(expanded_type_id, array_size)
+    } else {
+        expanded_type_id
+    };
+
+    // Use a global instead of the fragment output, declare a gvec4 fragment output instead and
+    // and at the end of the shader copy it over to the expanded variable.
+    let new_output =
+        ir.meta.declare_cached_global_for_variable(variable_id, name, Some(complete_type)).1;
+    let global = TypedId::from_variable_id(&ir.meta, variable_id);
+
+    let mut postamble = Block::new();
+
+    if let Some(array_size) = array_size {
+        for index in 0..array_size {
+            // globalN = AccessArrayElement global N
+            // outputN = AccessArrayElement output N
+            let index = ir.meta.get_constant_uint_typed(index, Precision::Low);
+            let global_indexed =
+                postamble.add_typed_instruction(instruction::index(&mut ir.meta, global, index));
+            let output_indexed = postamble.add_typed_instruction(instruction::index(
+                &mut ir.meta,
+                new_output,
+                index,
+            ));
+            copy_and_expand(
+                &mut ir.meta,
+                &mut postamble,
+                global_indexed,
+                output_indexed,
+                expanded_type_id,
+                component_count,
+                basic_type_zero,
+            );
+        }
+    } else {
+        copy_and_expand(
+            &mut ir.meta,
+            &mut postamble,
+            global,
+            new_output,
+            expanded_type_id,
+            component_count,
+            basic_type_zero,
+        );
+    }
+
+    ir.append_to_main(postamble);
+}
+
+fn copy_and_expand(
+    ir_meta: &mut IRMeta,
+    postamble: &mut Block,
+    global: TypedId,
+    output: TypedId,
+    expanded_type_id: TypeId,
+    component_count: u32,
+    basic_type_zero: TypedId,
+) {
+    // Produce statements like output = vec4(global.x, global.y, zero, zero).
+    let mut constructor_args = if component_count > 1 {
+        // x        = AccessVectorComponent global 0
+        // x'       = Load x
+        // y        = AccessVectorComponent global 1
+        // y'       = Load y
+        // expanded = ConstructVectorFromMultiple (x, y, zero, zero)
+        (0..component_count)
+            .map(|component| {
+                let swizzle = postamble.add_typed_instruction(instruction::vector_component(
+                    ir_meta, global, component,
+                ));
+                postamble.add_typed_instruction(instruction::load(ir_meta, swizzle))
+            })
+            .collect::<Vec<_>>()
+    } else {
+        // x        = Load global
+        // expanded = ConstructVectorFromMultiple (x, zero, zero, zero)
+        vec![postamble.add_typed_instruction(instruction::load(ir_meta, global))]
+    };
+    constructor_args.resize(4, basic_type_zero);
+    let expanded = postamble.add_typed_instruction(instruction::construct(
+        ir_meta,
+        expanded_type_id,
+        constructor_args,
+        None,
+    ));
+    postamble.add_void_instruction(OpCode::Store(output, expanded));
+}
diff --git a/src/compiler/translator/tree_ops/ExpandFragmentOutputsToVec4.cpp b/src/compiler/translator/tree_ops/ExpandFragmentOutputsToVec4.cpp
new file mode 100644
index 0000000..2875551
--- /dev/null
+++ b/src/compiler/translator/tree_ops/ExpandFragmentOutputsToVec4.cpp
@@ -0,0 +1,151 @@
+// Copyright 2026 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.
+
+#include "compiler/translator/tree_ops/ExpandFragmentOutputsToVec4.h"
+
+#include "compiler/translator/tree_util/IntermNode_util.h"
+#include "compiler/translator/tree_util/ReplaceVariable.h"
+#include "compiler/translator/tree_util/RunAtTheEndOfShader.h"
+
+namespace sh
... (file diff truncated)

diff --git a/src/tests/angle_end2end_tests_expectations.txt b/src/tests/angle_end2end_tests_expectations.txt
index 2382235e..76a3a9f 100644
--- a/src/tests/angle_end2end_tests_expectations.txt
+++ b/src/tests/angle_end2end_tests_expectations.txt
@@ -219,6 +219,9 @@
 535213600 WIN NVIDIA OPENGL : PbufferTestES3.BindTexImageAndCopyTextureInvertedSrc/* = SKIP
 535213600 WIN NVIDIA GLES : PbufferTestES3.BindTexImageAndCopyTextureInvertedSrc/* = SKIP
 535213600 WIN NVIDIA GLES : PbufferTestES3.BindTexImageAndCopyTexSubTextureInvertedDst/* = SKIP
+564530612 WIN INTEL D3D11 : HardenedContextBlendTest.AlphaBlendNoAlphaChannelInSrcAndDst/* = SKIP
+564530612 WIN INTEL D3D11 : HardenedContextBlendTest.AlphaBlendNoAlphaChannelInSrcAndDst2/* = SKIP
+564530612 WIN INTEL D3D11 : HardenedContextBlendTest.AlphaBlendNoAlphaChannelInSrcAndDstArray/* = SKIP
 
 42266241 PIXEL6 VULKAN : VertexAttributeTestES31.MismatchingSignsChangingAttributeType/* = SKIP
 42266241 PIXEL6 VULKAN : VertexAttributeTestES31.MismatchingSignsChangingProgramType/* = SKIP
diff --git a/src/tests/gl_tests/GLSLTest.cpp b/src/tests/gl_tests/GLSLTest.cpp
index 74b7fa4..8ccb1e5 100644
--- a/src/tests/gl_tests/GLSLTest.cpp
+++ b/src/tests/gl_tests/GLSLTest.cpp
@@ -24362,16 +24362,13 @@
     ASSERT_GL_NO_ERROR();
 }
 
-class GLSLTest_ES3_Blend : public GLSLTest_ES3
-{};
-
 // Test alpha blend where both the framebuffer and shader miss the alpha channel.  The spec says
 // that:
 //
 // > If a color buffer has no A value, then A_d is taken to be 1.
 //
 // But it says nothing about what happens if the shader does not write to alpha and A_s.
-TEST_P(GLSLTest_ES3_Blend, AlphaBlendNoAlphaChannelInSrcAndDst)
+TEST_P(GLSLTest_ES3, AlphaBlendNoAlphaChannelInSrcAndDst)
 {
     GLTexture color;
     glBindTexture(GL_TEXTURE_2D, color);
@@ -24407,7 +24404,7 @@
 }
 
 // Test alpha blend where the framebuffer misses the alpha channel, but the shader writes to alpha.
-TEST_P(GLSLTest_ES3_Blend, AlphaBlendNoAlphaChannelInDst)
+TEST_P(GLSLTest_ES3, AlphaBlendNoAlphaChannelInDst)
 {
     GLTexture color;
     glBindTexture(GL_TEXTURE_2D, color);
@@ -24438,7 +24435,7 @@
 
 // Test blend where the framebuffer misses the alpha channel.  Uses (GL_DST_COLOR, GL_ZERO) blend
 // that hits an optimization path in the mesa/Radeon driver.
-TEST_P(GLSLTest_ES3_Blend, ColorBlendNoAlphaChannelInDst)
+TEST_P(GLSLTest_ES3, ColorBlendNoAlphaChannelInDst)
 {
     GLTexture color;
     glBindTexture(GL_TEXTURE_2D, color);
@@ -26101,10 +26098,5 @@
                        ES3_METAL(),
                        ES3_VULKAN());
 
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GLSLTest_ES3_Blend);
-ANGLE_INSTANTIATE_TEST_ES3_AND(GLSLTest_ES3_Blend,
-                               ES3_OPENGL().enable(Feature::ExpandFragmentOutputsToVec4),
-                               ES3_OPENGLES().enable(Feature::ExpandFragmentOutputsToVec4));
-
 ANGLE_INSTANTIATE_TEST_ES2_AND(GLSLTestPassthrough,
                                ES2_OPENGLES().enable(Feature::ForcePassthroughShaders));
diff --git a/src/tests/gl_tests/WebGLCompatibilityTest.cpp b/src/tests/gl_tests/WebGLCompatibilityTest.cpp
index f00c1b5..0c21744 100644
--- a/src/tests/gl_tests/WebGLCompatibilityTest.cpp
+++ b/src/tests/gl_tests/WebGLCompatibilityTest.cpp
@@ -368,6 +368,9 @@
 class HardenedContextTestES31 : public HardenedContextTest
 {};
 
+class HardenedContextBlendTest : public HardenedContextTest
+{};
+
 // Context creation would fail if EGL_ANGLE_create_context_webgl_compatibility was not available so
 // the GL extension should always be present
 TEST_P(WebGLCompatibilityTest, ExtensionStringExposed)
@@ -9058,6 +9061,107 @@
     }
 }
 
+// Test alpha blend where both the framebuffer and shader miss the alpha channel.  The spec says
+// that:
+//
+// > If a color buffer has no A value, then A_d is taken to be 1.
+//
+// But it says nothing about what happens if the shader does not write to alpha and A_s.
+TEST_P(HardenedContextBlendTest, AlphaBlendNoAlphaChannelInSrcAndDst)
+{
+    GLTexture color;
+    glBindTexture(GL_TEXTURE_2D, color);
+    glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, 1, 1);
+    constexpr uint8_t kInitialValue = 0x10;
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RED, GL_UNSIGNED_BYTE, &kInitialValue);
+
+    GLFramebuffer fbo;
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color, 0);
+    ANGLE_SKIP_TEST_IF(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
+
+    constexpr char kFS[] = R"(#version 300 es
+out mediump float color;
+void main() {
+    color = 0.2;
+})";
+
+    ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), kFS);
+    // A_d is implicitly one.  But A_s is undefined.
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
+    glBlendEquation(GL_FUNC_ADD);
+    drawQuad(program, essl3_shaders::PositionAttrib(), 0.0f);
+    // Normally, the result cannot be known given A_s is undefined, but in hardened contexts it's
+    // set to 0.
+    EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor(0x10, 0, 0, 255), 1);
+    ASSERT_GL_NO_ERROR();
+}
+
+// Similar test as AlphaBlendNoAlphaChannelInSrcAndDst, but with a vec2
+TEST_P(HardenedContextBlendTest, AlphaBlendNoAlphaChannelInSrcAndDst2)
+{
+    GLTexture color;
+    glBindTexture(GL_TEXTURE_2D, color);
+    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG8, 1, 1);
+    constexpr std::array<uint8_t, 2> kInitialValue = {0x10, 0x30};
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RG, GL_UNSIGNED_BYTE, kInitialValue.data());
+
+    GLFramebuffer fbo;
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color, 0);
+    ANGLE_SKIP_TEST_IF(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
+
+    constexpr char kFS[] = R"(#version 300 es
+out mediump vec2 color;
+void main() {
+    color = vec2(0.2, 0.4);
+})";
+
+    ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), kFS);
+    // A_d is implicitly one.  But A_s is undefined.
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
+    glBlendEquation(GL_FUNC_ADD);
+    drawQuad(program, essl3_shaders::PositionAttrib(), 0.0f);
+    // Normally, the result cannot be known given A_s is undefined, but in hardened contexts it's
+    // set to 0.
+    EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor(0x10, 0x30, 0, 255), 1);
+    ASSERT_GL_NO_ERROR();
+}
+
+// Similar test as AlphaBlendNoAlphaChannelInSrcAndDst, but with an array
+TEST_P(HardenedContextBlendTest, AlphaBlendNoAlphaChannelInSrcAndDstArray)
+{
+    GLTexture color;
+    glBindTexture(GL_TEXTURE_2D, color);
+    glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, 1, 1);
+    constexpr uint8_t kInitialValue = 0x10;
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RED, GL_UNSIGNED_BYTE, &kInitialValue);
+
+    GLFramebuffer fbo;
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color, 0);
+    ANGLE_SKIP_TEST_IF(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE);
+
+    constexpr char kFS[] = R"(#version 300 es
+out mediump float color[1];
+void main() {
+    color[0] = 0.2;
+})";
+
+    ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), kFS);
+    // A_d is implicitly one.  But A_s is undefined.
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
+    glBlendEquation(GL_FUNC_ADD);
+    drawQuad(program, essl3_shaders::PositionAttrib(), 0.0f);
+    // Normally, the result cannot be known given A_s is undefined, but in hardened contexts it's
+    // set to 0.
+    EXPECT_PIXEL_COLOR_NEAR(0, 0, GLColor(0x10, 0, 0, 255), 1);
+    ASSERT_GL_NO_ERROR();
+}
+
 ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(WebGLCompatibilityTest);
 
 ANGLE_INSTANTIATE_TEST_ES2(WebGL1CompatibilityTest);
@@ -9068,6 +9172,9 @@
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HardenedContextTest);
 ANGLE_INSTANTIATE_TEST_ES3(HardenedContextTest);
 
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HardenedContextBlendTest);
+ANGLE_INSTANTIATE_TEST_ES3(HardenedContextBlendTest);
+
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HardenedContextTestRestrictBaseLevel);
 ANGLE_INSTANTIATE_TEST(
     HardenedContextTestRestrictBaseLevel,