Rework BoxBorderPainter's mitre clipping logic

Source/core/paint/BoxBorderPainter.cpp

 // Copyright 2015 The Chromium 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 "config.h"
 #include "core/paint/BoxBorderPainter.h"
 
 #include "core/paint/BoxPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/style/BorderEdge.h"
@@ skipping 62 matching lines @@
         const BorderEdgeFlags bottomLeftFlags = edgeFlagForSide(BSBottom) | edgeFlagForSide(BSLeft);
 
         BorderEdgeFlags flags = edgeFlagForSide(side) | edgeFlagForSide(adjacentSide);
         return flags == topRightFlags || flags == bottomLeftFlags;
     }
     return false;
 }
 
 inline bool colorsMatchAtCorner(BoxSide side, BoxSide adjacentSide, const BorderEdge edges[])
 {
-    if (edges[side].shouldRender() != edges[adjacentSide].shouldRender())
+    if (!edges[adjacentSide].shouldRender())
         return false;
 
     if (!edges[side].sharesColorWith(edges[adjacentSide]))
         return false;
 
     return !borderStyleHasUnmatchedColorsAtCorner(edges[side].borderStyle(), side, adjacentSide);
 }
 
-inline bool colorNeedsAntiAliasAtCorner(BoxSide side, BoxSide adjacentSide, const BorderEdge edges[])
-{
-    if (!edges[side].color.hasAlpha())
-        return false;
-
-    if (edges[side].shouldRender() != edges[adjacentSide].shouldRender())
-        return false;
-
-    if (!edges[side].sharesColorWith(edges[adjacentSide]))
-        return true;
-
-    return borderStyleHasUnmatchedColorsAtCorner(edges[side].borderStyle(), side, adjacentSide);
-}
-
 inline bool borderWillArcInnerEdge(const FloatSize& firstRadius, const FloatSize& secondRadius)
 {
     return !firstRadius.isZero() || !secondRadius.isZero();
 }
 
 inline bool willOverdraw(BoxSide side, EBorderStyle style, BorderEdgeFlags completedEdges)
 {
     // If we're done with this side, it will obviously not overdraw any portion of the current edge.
     if (includesEdge(completedEdges, side))
         return false;
 
     // The side is still to be drawn. It overdraws the current edge iff it has a solid fill style.
     return borderStyleFillsBorderArea(style);
 }
 
 inline bool borderStylesRequireMitre(BoxSide side, BoxSide adjacentSide, EBorderStyle style, EBorderStyle adjacentStyle)
 {
     if (style == DOUBLE || adjacentStyle == DOUBLE || adjacentStyle == GROOVE || adjacentStyle == RIDGE)
         return true;
 
     if (borderStyleIsDottedOrDashed(style) != borderStyleIsDottedOrDashed(adjacentStyle))
         return true;
 
     if (style != adjacentStyle)
         return true;
 
     return borderStyleHasUnmatchedColorsAtCorner(style, side, adjacentSide);
 }
 
-inline bool joinRequiresMitre(BoxSide side, BoxSide adjacentSide, const BorderEdge edges[],
-    bool allowOverdraw, BorderEdgeFlags completedEdges)
-{
-    if (!edges[adjacentSide].isPresent)
-        return false;
-
-    if (allowOverdraw && willOverdraw(adjacentSide, edges[adjacentSide].borderStyle(), completedEdges))
-        return false;
-
-    if (!edges[side].sharesColorWith(edges[adjacentSide]))
-        return true;
-
-    if (borderStylesRequireMitre(side, adjacentSide, edges[side].borderStyle(), edges[adjacentSide].borderStyle()))
-        return true;
-
-    return false;
-}
-
 FloatRect calculateSideRect(const FloatRoundedRect& outerBorder, const BorderEdge& edge, int side)
 {
     FloatRect sideRect = outerBorder.rect();
     int width = edge.width;
 
     if (side == BSTop)
         sideRect.setHeight(width);
     else if (side == BSBottom)
         sideRect.shiftYEdgeTo(sideRect.maxY() - width);
     else if (side == BSLeft)
@@ skipping 633 matching lines @@
 
         paintOneBorderSide(context, sideRect, BSRight, BSTop, BSBottom, path, borderInfo.antiAlias,
             color, completedEdges);
         break;
     }
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
+BoxBorderPainter::MitreType BoxBorderPainter::computeMitre(BoxSide side, BoxSide adjacentSide,
+    BorderEdgeFlags completedEdges, bool antialias) const
+{
+    const BorderEdge& adjacentEdge = m_edges[adjacentSide];
+
+    // No miters for missing edges.
+    if (!adjacentEdge.isPresent)
+        return NoMitre;
+
+    // Legacy behavior - preserve for now.
+    bool allowOverdraw = !antialias;
+
+    // The adjacent edge will overdraw this corner, resulting in a correct mitre.
+    if (allowOverdraw && willOverdraw(adjacentSide, adjacentEdge.borderStyle(), completedEdges))
+        return NoMitre;
+
+    // Color transitions require mitres. Use mitres compatible with the AA drawing mode to avoid
+    // introducing extra clips.
+    if (!colorsMatchAtCorner(side, adjacentSide, m_edges))
+        return antialias ? SoftMitre : HardMitre;
+
+    // Non-anti-aliased mitres ensure correct same-color seaming when required by style.
+    if (borderStylesRequireMitre(side, adjacentSide, m_edges[side].borderStyle(), adjacentEdge.borderStyle()))
+        return HardMitre;
+
+    // Overdraw the adjacent edge when the colors match and we have no style restrictions.
+    return NoMitre;
+}
+
+bool BoxBorderPainter::mitresRequireClipping(MitreType mitre1, MitreType mitre2, EBorderStyle style,
+    bool antialias)
+{
+    // Clipping is required if any of the present mitres doesn't match the current AA mode.
+    bool shouldClip = antialias
+        ? mitre1 == HardMitre || mitre2 == HardMitre
+        : mitre1 == SoftMitre || mitre2 == SoftMitre;
+
+    // Some styles require clipping for any type of mitre.
+    shouldClip = shouldClip
+        || ((mitre1 != NoMitre || mitre2 != NoMitre) && styleRequiresClipPolygon(style));
+
+    return shouldClip;
+}
+
 void BoxBorderPainter::paintOneBorderSide(GraphicsContext* graphicsContext,
     const FloatRect& sideRect, BoxSide side, BoxSide adjacentSide1, BoxSide adjacentSide2,
     const Path* path, bool antialias, Color color, BorderEdgeFlags completedEdges) const
 {
     const BorderEdge& edgeToRender = m_edges[side];
     ASSERT(edgeToRender.width);
     const BorderEdge& adjacentEdge1 = m_edges[adjacentSide1];
     const BorderEdge& adjacentEdge2 = m_edges[adjacentSide2];
 
     if (path) {
-        bool adjacentSide1StylesMatch = colorsMatchAtCorner(side, adjacentSide1, m_edges);
-        bool adjacentSide2StylesMatch = colorsMatchAtCorner(side, adjacentSide2, m_edges);
+        MitreType mitre1 = colorsMatchAtCorner(side, adjacentSide1, m_edges) ? HardMitre : SoftMitre;
+        MitreType mitre2 = colorsMatchAtCorner(side, adjacentSide2, m_edges) ? HardMitre : SoftMitre;
 
         GraphicsContextStateSaver stateSaver(*graphicsContext);
         if (m_inner.isRenderable())
-            clipBorderSidePolygon(graphicsContext, side, adjacentSide1StylesMatch, adjacentSide2StylesMatch);
+            clipBorderSidePolygon(graphicsContext, side, mitre1, mitre2);
         else
             clipBorderSideForComplexInnerPath(graphicsContext, side);
         float thickness = std::max(std::max(edgeToRender.width, adjacentEdge1.width), adjacentEdge2.width);
         drawBoxSideFromPath(graphicsContext, LayoutRect(m_outer.rect()), *path, edgeToRender.width,
             thickness, side, color, edgeToRender.borderStyle());
     } else {
-        bool mitreAdjacentSide1 = joinRequiresMitre(side, adjacentSide1, m_edges, !antialias, completedEdges);
-        bool mitreAdjacentSide2 = joinRequiresMitre(side, adjacentSide2, m_edges, !antialias, completedEdges);
-
-        bool clipForStyle = styleRequiresClipPolygon(edgeToRender.borderStyle())
-            && (mitreAdjacentSide1 || mitreAdjacentSide2);
-        bool clipAdjacentSide1 = colorNeedsAntiAliasAtCorner(side, adjacentSide1, m_edges) && mitreAdjacentSide1;
-        bool clipAdjacentSide2 = colorNeedsAntiAliasAtCorner(side, adjacentSide2, m_edges) && mitreAdjacentSide2;
-        bool shouldClip = clipForStyle || clipAdjacentSide1 || clipAdjacentSide2;
+        MitreType mitre1 = computeMitre(side, adjacentSide1, completedEdges, antialias);
+        MitreType mitre2 = computeMitre(side, adjacentSide2, completedEdges, antialias);
+        bool shouldClip = mitresRequireClipping(mitre1, mitre2, edgeToRender.borderStyle(), antialias);
 
         GraphicsContextStateSaver clipStateSaver(*graphicsContext, shouldClip);
         if (shouldClip) {
-            bool aliasAdjacentSide1 = clipAdjacentSide1 || (clipForStyle && mitreAdjacentSide1);
-            bool aliasAdjacentSide2 = clipAdjacentSide2 || (clipForStyle && mitreAdjacentSide2);
-            clipBorderSidePolygon(graphicsContext, side, !aliasAdjacentSide1, !aliasAdjacentSide2);
-            // Since we clipped, no need to draw with a mitre.
-            mitreAdjacentSide1 = false;
-            mitreAdjacentSide2 = false;
+            clipBorderSidePolygon(graphicsContext, side, mitre1, mitre2);
+
+            // Mitres are applied via clipping, no need to draw them.
+            mitre1 = mitre2 = NoMitre;
         }
 
         ObjectPainter::drawLineForBoxSide(graphicsContext, sideRect.x(), sideRect.y(),
             sideRect.maxX(), sideRect.maxY(), side, color, edgeToRender.borderStyle(),
-            mitreAdjacentSide1 ? adjacentEdge1.width : 0, mitreAdjacentSide2 ? adjacentEdge2.width : 0, antialias);
+            mitre1 != NoMitre ? adjacentEdge1.width : 0, mitre2 != NoMitre ? adjacentEdge2.width : 0,
+            antialias);
     }
 }
 
 void BoxBorderPainter::drawBoxSideFromPath(GraphicsContext* graphicsContext,
     const LayoutRect& borderRect, const Path& borderPath, float thickness, float drawThickness,
     BoxSide side, Color color, EBorderStyle borderStyle) const
 {
     if (thickness <= 0)
         return;
 
@@ skipping 133 matching lines @@
 void BoxBorderPainter::clipBorderSideForComplexInnerPath(GraphicsContext* graphicsContext,
     BoxSide side) const
 {
     graphicsContext->clip(calculateSideRectIncludingInner(m_outer, m_edges, side));
     FloatRoundedRect adjustedInnerRect = calculateAdjustedInnerBorder(m_inner, side);
     if (!adjustedInnerRect.isEmpty())
         graphicsContext->clipOutRoundedRect(adjustedInnerRect);
 }
 
 void BoxBorderPainter::clipBorderSidePolygon(GraphicsContext* graphicsContext, BoxSide side,
-    bool firstEdgeMatches, bool secondEdgeMatches) const
+    MitreType firstMitre, MitreType secondMitre) const
 {
+    ASSERT(firstMitre != NoMitre || secondMitre != NoMitre);
+
     FloatPoint quad[4];
 
     const LayoutRect outerRect(m_outer.rect());
     const LayoutRect innerRect(m_inner.rect());
 
     // For each side, create a quad that encompasses all parts of that side that may draw,
     // including areas inside the innerBorder.
     //
     //         0----------------3
     //       0  \              /  0
@@ skipping 117 matching lines @@
                     quad[2].x() - m_inner.radii().bottomRight().width(),
                     quad[2].y()),
                 FloatPoint(
                     quad[2].x(),
                     quad[2].y() - m_inner.radii().bottomRight().height()),
                 quad[2]);
         }
         break;
     }
 
-    // If the border matches both of its adjacent sides, don't anti-alias the clip, and
-    // if neither side matches, anti-alias the clip.
-    if (firstEdgeMatches == secondEdgeMatches) {
-        graphicsContext->clipPolygon(4, quad, !firstEdgeMatches);
+    if (firstMitre == secondMitre) {
+        graphicsContext->clipPolygon(4, quad, firstMitre == SoftMitre);
         return;
     }
 
     // If antialiasing settings for the first edge and second edge is different,
     // they have to be addressed separately. We do this by breaking the quad into
     // two parallelograms, made by moving quad[1] and quad[2].
     float ax = quad[1].x() - quad[0].x();
     float ay = quad[1].y() - quad[0].y();
     float bx = quad[2].x() - quad[1].x();
     float by = quad[2].y() - quad[1].y();
     float cx = quad[3].x() - quad[2].x();
     float cy = quad[3].y() - quad[2].y();
 
     const static float kEpsilon = 1e-2f;
     float r1, r2;
     if (fabsf(bx) < kEpsilon && fabsf(by) < kEpsilon) {
         // The quad was actually a triangle.
         r1 = r2 = 1.0f;
     } else {
         // Extend parallelogram a bit to hide calculation error
         const static float kExtendFill = 1e-2f;
 
         r1 = (-ax * by + ay * bx) / (cx * by - cy * bx) + kExtendFill;
         r2 = (-cx * by + cy * bx) / (ax * by - ay * bx) + kExtendFill;
     }
 
-    FloatPoint firstQuad[4];
-    firstQuad[0] = quad[0];
-    firstQuad[1] = quad[1];
-    firstQuad[2] = FloatPoint(quad[3].x() + r2 * ax, quad[3].y() + r2 * ay);
-    firstQuad[3] = quad[3];
-    graphicsContext->clipPolygon(4, firstQuad, !firstEdgeMatches);
+    if (firstMitre != NoMitre) {
+        FloatPoint firstQuad[4];
+        firstQuad[0] = quad[0];
+        firstQuad[1] = quad[1];
+        firstQuad[2] = FloatPoint(quad[3].x() + r2 * ax, quad[3].y() + r2 * ay);
+        firstQuad[3] = quad[3];
+        graphicsContext->clipPolygon(4, firstQuad, firstMitre == SoftMitre);
+    }
 
-    FloatPoint secondQuad[4];
-    secondQuad[0] = quad[0];
-    secondQuad[1] = FloatPoint(quad[0].x() - r1 * cx, quad[0].y() - r1 * cy);
-    secondQuad[2] = quad[2];
-    secondQuad[3] = quad[3];
-    graphicsContext->clipPolygon(4, secondQuad, !secondEdgeMatches);
+    if (secondMitre != NoMitre) {
+        FloatPoint secondQuad[4];
+        secondQuad[0] = quad[0];
+        secondQuad[1] = FloatPoint(quad[0].x() - r1 * cx, quad[0].y() - r1 * cy);
+        secondQuad[2] = quad[2];
+        secondQuad[3] = quad[3];
+        graphicsContext->clipPolygon(4, secondQuad, secondMitre == SoftMitre);
+    }
 }
 
 } // namespace blink