Cherry-pick 276876@main (5e49350). https://bugs.webkit.org/show_bug.cgi?id=271653

    [WPE] Holepunch doesn't work when the video element has rounded corners
    https://bugs.webkit.org/show_bug.cgi?id=271653

    Reviewed by Carlos Garcia Campos.

    Modify the rounded rectangle clipping in the TextureMapper so it can work
    when blending is disabled. To do this, the fragments that are out of rounded
    rectangle are discarded by the fragment shader, instead of painting them
    transparent.

    When blending is enabled, we can do some antialiasing of the pixels on the
    rounded corners by reducing their opacity depending on how much they are
    inside the rect.

    When blending is disabled we can't do antialiasing of the rounded corners,
    so the visual result is a bit worse. The good thing is that blending is
    only disabled when we're rendering a holepunch buffer, so it's not a big
    problem.

    * Source/WebCore/platform/graphics/texmap/TextureMapper.cpp:
    (WebCore::TextureMapper::drawSolidColor):
    * Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp:

    Canonical link: https://commits.webkit.org/276876@main

Author: magomez

Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp

@@ -712,15 +712,16 @@ void TextureMapperGL::drawSolidColor(const FloatRect& rect, const Transformation
         flags |= ShouldAntialias | (isBlendingAllowed ? ShouldBlend : 0);
     }
 
-    if (clipStack().isRoundedRectClipEnabled() && isBlendingAllowed) {
+    if (clipStack().isRoundedRectClipEnabled()) {
         options.add(TextureMapperShaderProgram::RoundedRectClip);
-        flags |= ShouldBlend;
+        if (isBlendingAllowed)
+            flags |= ShouldBlend;
     }
 
     Ref<TextureMapperShaderProgram> program = data().getShaderProgram(options);
     glUseProgram(program->programID());
 
-    if (options.contains(TextureMapperShaderProgram::RoundedRectClip))
+    if (clipStack().isRoundedRectClipEnabled())
         prepareRoundedRectClip(program.get(), clipStack().roundedRectComponents(), clipStack().roundedRectInverseTransformComponents(), clipStack().roundedRectCount());
 
     auto [r, g, b, a] = premultiplied(color.toColorTypeLossy<SRGBA<float>>()).resolved();

Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp

@@ -474,7 +474,23 @@ static const char* fragmentTemplateCommon =
                 vec2 topRightRadii = u_roundedRect[(rectIndex * 3) + 1].zw;
                 vec2 bottomLeftRadii = u_roundedRect[(rectIndex * 3) + 2].xy;
                 vec2 bottomRightRadii = u_roundedRect[(rectIndex * 3) + 2].zw;
-                color *= roundedRectCoverage(fragCoord.xy, bounds, topLeftRadii, topRightRadii, bottomLeftRadii, bottomRightRadii);
+                float coverage = roundedRectCoverage(fragCoord.xy, bounds, topLeftRadii, topRightRadii, bottomLeftRadii, bottomRightRadii);
+
+                // Pixels outside the rect have coverage 0.0.
+                // Pixels inside the rect have coverage 1.0.
+                // Pixels on the border of the rounded parts have coverage between 0.0 and 1.0.
+
+                // Discard the fragments that are outside the rect.
+                if (coverage == 0.0)
+                    discard;
+
+                // By multiplying the color by the coverage, pixels on the border of the rounded corners get
+                // a bit more transparent.
+                // If blending is enabled, this does some antialiasing on the border pixels.
+                // If blending is disabled it means that we're rendering a holepunch buffer, so the color
+                // is always (0,0,0,0). In this case, multiplying by the coverage doesn't cause any effect
+                // and no antialiasing is done.
+                color *= coverage;
             }
         }