[SP] Always anti-alias borders

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"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "wtf/Vector.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace {
 
 enum BorderEdgeFlag {
@@ skipping 76 matching lines @@
 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)
+inline bool borderStylesRequireMiter(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;
 
@@ skipping 224 matching lines @@
     2 /* GROOVE */,
     2 /* OUTSET */,
     2 /* RIDGE */,
     1 /* DOTTED */,
     1 /* DASHED */,
     3 /* SOLID */,
     1 /* DOUBLE */
 };
 
 // Given the same style, prefer drawing in non-adjacent order to minimize the number of sides
-// which require mitres.
+// which require miters.
 const unsigned kSidePriority[] = {
     0, /* BSTop */
     2, /* BSRight */
     1, /* BSBottom */
     3, /* BSLeft */
 };
 
 // Edges sharing the same opacity. Stores both a side list and an edge bitfield to support
 // constant time iteration + membership tests.
 struct OpacityGroup {
@@ skipping 233 matching lines @@
         // For BackgroundBleedClip{Only,Layer}, the outer rrect clip is already applied.
         if (!bleedAvoidanceIsClipping(m_bleedAvoidance))
             graphicsContext->clipRoundedRect(m_outer);
 
         // For BackgroundBleedBackgroundOverBorder, we're going to draw an opaque background over
         // the inner rrect - so clipping is not needed (nor desirable due to backdrop bleeding).
         if (m_bleedAvoidance != BackgroundBleedBackgroundOverBorder && m_inner.isRenderable() && !m_inner.isEmpty())
             graphicsContext->clipOutRoundedRect(m_inner);
     }
 
-    // If only one edge visible antialiasing doesn't create seams
-    bool antialias = BoxPainter::shouldAntialiasLines(graphicsContext) || m_visibleEdgeCount == 1;
+    bool antialias =
+        RuntimeEnabledFeatures::slimmingPaintEnabled()
+        || m_visibleEdgeCount == 1
+        || BoxPainter::shouldAntialiasLines(graphicsContext);
 
     const ComplexBorderInfo borderInfo(*this, antialias);
     paintOpacityGroup(graphicsContext, borderInfo, 0, 1);
 }
 
 // In order to maximize the use of overdraw as a corner seam avoidance technique, we draw
 // translucent border sides using the following algorithm:
 //
 //   1) cluster sides sharing the same opacity into "opacity groups" [ComplexBorderInfo]
 //   2) sort groups in increasing opacity order [ComplexBorderInfo]
@@ skipping 146 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,
+BoxBorderPainter::MiterType BoxBorderPainter::computeMiter(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;
+        return NoMiter;
 
-    // Legacy behavior - preserve for now.
-    bool allowOverdraw = !antialias;
+    // The adjacent edge will overdraw this corner, resulting in a correct miter.
+    if (willOverdraw(adjacentSide, adjacentEdge.borderStyle(), completedEdges))
+        return NoMiter;
 
-    // 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
+    // Color transitions require miters. Use miters compatible with the AA drawing mode to avoid
     // introducing extra clips.
     if (!colorsMatchAtCorner(side, adjacentSide, m_edges))
-        return antialias ? SoftMitre : HardMitre;
+        return antialias ? SoftMiter : HardMiter;
 
-    // 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;
+    // Non-anti-aliased miters ensure correct same-color seaming when required by style.
+    if (borderStylesRequireMiter(side, adjacentSide, m_edges[side].borderStyle(), adjacentEdge.borderStyle()))
+        return HardMiter;
 
     // Overdraw the adjacent edge when the colors match and we have no style restrictions.
-    return NoMitre;
+    return NoMiter;
 }
 
-bool BoxBorderPainter::mitresRequireClipping(MitreType mitre1, MitreType mitre2, EBorderStyle style,
+bool BoxBorderPainter::mitersRequireClipping(MiterType miter1, MiterType miter2, EBorderStyle style,
     bool antialias)
 {
-    // Clipping is required if any of the present mitres doesn't match the current AA mode.
+    // Clipping is required if any of the present miters doesn't match the current AA mode.
     bool shouldClip = antialias
-        ? mitre1 == HardMitre || mitre2 == HardMitre
-        : mitre1 == SoftMitre || mitre2 == SoftMitre;
+        ? miter1 == HardMiter || miter2 == HardMiter
+        : miter1 == SoftMiter || miter2 == SoftMiter;
 
-    // Some styles require clipping for any type of mitre.
+    // Some styles require clipping for any type of miter.
     shouldClip = shouldClip
-        || ((mitre1 != NoMitre || mitre2 != NoMitre) && styleRequiresClipPolygon(style));
+        || ((miter1 != NoMiter || miter2 != NoMiter) && 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) {
-        MitreType mitre1 = colorsMatchAtCorner(side, adjacentSide1, m_edges) ? HardMitre : SoftMitre;
-        MitreType mitre2 = colorsMatchAtCorner(side, adjacentSide2, m_edges) ? HardMitre : SoftMitre;
+        MiterType miter1 = colorsMatchAtCorner(side, adjacentSide1, m_edges) ? HardMiter : SoftMiter;
+        MiterType miter2 = colorsMatchAtCorner(side, adjacentSide2, m_edges) ? HardMiter : SoftMiter;
 
         GraphicsContextStateSaver stateSaver(*graphicsContext);
         if (m_inner.isRenderable())
-            clipBorderSidePolygon(graphicsContext, side, mitre1, mitre2);
+            clipBorderSidePolygon(graphicsContext, side, miter1, miter2);
         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 {
-        MitreType mitre1 = computeMitre(side, adjacentSide1, completedEdges, antialias);
-        MitreType mitre2 = computeMitre(side, adjacentSide2, completedEdges, antialias);
-        bool shouldClip = mitresRequireClipping(mitre1, mitre2, edgeToRender.borderStyle(), antialias);
+        MiterType miter1 = computeMiter(side, adjacentSide1, completedEdges, antialias);
+        MiterType miter2 = computeMiter(side, adjacentSide2, completedEdges, antialias);
+        bool shouldClip = mitersRequireClipping(miter1, miter2, edgeToRender.borderStyle(), antialias);
 
         GraphicsContextStateSaver clipStateSaver(*graphicsContext, shouldClip);
         if (shouldClip) {
-            clipBorderSidePolygon(graphicsContext, side, mitre1, mitre2);
+            clipBorderSidePolygon(graphicsContext, side, miter1, miter2);
 
-            // Mitres are applied via clipping, no need to draw them.
-            mitre1 = mitre2 = NoMitre;
+            // Miters are applied via clipping, no need to draw them.
+            miter1 = miter2 = NoMiter;
         }
 
         ObjectPainter::drawLineForBoxSide(graphicsContext, sideRect.x(), sideRect.y(),
             sideRect.maxX(), sideRect.maxY(), side, color, edgeToRender.borderStyle(),
-            mitre1 != NoMitre ? adjacentEdge1.width : 0, mitre2 != NoMitre ? adjacentEdge2.width : 0,
+            miter1 != NoMiter ? adjacentEdge1.width : 0, miter2 != NoMiter ? 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 134 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,
-    MitreType firstMitre, MitreType secondMitre) const
+    MiterType firstMiter, MiterType secondMiter) const
 {
-    ASSERT(firstMitre != NoMitre || secondMitre != NoMitre);
+    ASSERT(firstMiter != NoMiter || secondMiter != NoMiter);
 
     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
@@ skipping 118 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 (firstMitre == secondMitre) {
-        graphicsContext->clipPolygon(4, quad, firstMitre == SoftMitre);
+    if (firstMiter == secondMiter) {
+        graphicsContext->clipPolygon(4, quad, firstMiter == SoftMiter);
         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;
     }
 
-    if (firstMitre != NoMitre) {
+    if (firstMiter != NoMiter) {
         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);
+        graphicsContext->clipPolygon(4, firstQuad, firstMiter == SoftMiter);
     }
 
-    if (secondMitre != NoMitre) {
+    if (secondMiter != NoMiter) {
         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);
+        graphicsContext->clipPolygon(4, secondQuad, secondMiter == SoftMiter);
     }
 }
 
 } // namespace blink