Anti-aliased box borders (overdraw)

Source/core/paint/BoxPainter.cpp

 // Copyright 2014 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/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/ImageQualityController.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedDeprecatedPaintLayerMapping.h"
 #include "core/style/BorderEdge.h"
 #include "core/style/ShadowList.h"
 #include "core/paint/BackgroundImageGeometry.h"
+#include "core/paint/BoxBorderPainter.h"
 #include "core/paint/BoxDecorationData.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/RoundedInnerRectClipper.h"
 #include "core/paint/ThemePainter.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/geometry/LayoutRectOutsets.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
@@ skipping 1108 matching lines @@
     else if (side == BSBottom)
         sideRect.shiftYEdgeTo(sideRect.maxY() - width);
     else if (side == BSLeft)
         sideRect.setWidth(width);
     else
         sideRect.shiftXEdgeTo(sideRect.maxX() - width);
 
     return sideRect;
 }
 
-enum BorderEdgeFlag {
-    TopBorderEdge = 1 << BSTop,
-    RightBorderEdge = 1 << BSRight,
-    BottomBorderEdge = 1 << BSBottom,
-    LeftBorderEdge = 1 << BSLeft,
-    AllBorderEdges = TopBorderEdge | BottomBorderEdge | LeftBorderEdge | RightBorderEdge
-};
-
 static inline BorderEdgeFlag edgeFlagForSide(BoxSide side)
 {
     return static_cast<BorderEdgeFlag>(1 << side);
 }
 
 static inline bool includesEdge(BorderEdgeFlags flags, BoxSide side)
 {
     return flags & edgeFlagForSide(side);
 }
 
@@ skipping 268 matching lines @@
 
     LayoutRect bottomRightRect(boundingRect.location(), LayoutSize(radii.bottomRight()));
     bottomRightRect.setX(boundingRect.maxX() - bottomRightRect.width());
     bottomRightRect.setY(boundingRect.maxY() - bottomRightRect.height());
     if (clipRect.intersects(bottomRightRect))
         return false;
 
     return true;
 }
 
-// TODO(fmalita): Border painting is complex enough to warrant a standalone class. Move all related
-//                logic out into BoxBorderPainter or such.
-// TODO(fmalita): Move static BoxPainter border methods to anonymous ns and update to use a
-//                BoxBorderInfo argument.
-struct BoxBorderInfo {
-    STACK_ALLOCATED();
-public:
-    BoxBorderInfo(const ComputedStyle& style, BackgroundBleedAvoidance bleedAvoidance,
-        bool includeLogicalLeftEdge, bool includeLogicalRightEdge)
-        : style(style)
-        , bleedAvoidance(bleedAvoidance)
-        , includeLogicalLeftEdge(includeLogicalLeftEdge)
-        , includeLogicalRightEdge(includeLogicalRightEdge)
-        , visibleEdgeCount(0)
-        , firstVisibleEdge(0)
-        , visibleEdgeSet(0)
-        , isUniformStyle(true)
-        , isUniformWidth(true)
-        , isUniformColor(true)
-        , hasAlpha(false)
-    {
-
-        style.getBorderEdgeInfo(edges, includeLogicalLeftEdge, includeLogicalRightEdge);
-
-        for (unsigned i = 0; i < WTF_ARRAY_LENGTH(edges); ++i) {
-            const BorderEdge& edge = edges[i];
-
-            if (!edge.shouldRender()) {
-                if (edge.presentButInvisible()) {
-                    isUniformWidth = false;
-                    isUniformColor = false;
-                }
-
-                continue;
-            }
-
-            visibleEdgeCount++;
-            visibleEdgeSet |= edgeFlagForSide(static_cast<BoxSide>(i));
-
-            hasAlpha = hasAlpha || edge.color.hasAlpha();
-
-            if (visibleEdgeCount == 1) {
-                firstVisibleEdge = i;
-                continue;
-            }
-
-            isUniformStyle = isUniformStyle && (edge.borderStyle() == edges[firstVisibleEdge].borderStyle());
-            isUniformWidth = isUniformWidth && (edge.width == edges[firstVisibleEdge].width);
-            isUniformColor = isUniformColor && (edge.color == edges[firstVisibleEdge].color);
-        }
-    }
-
-    const ComputedStyle& style;
-    const BackgroundBleedAvoidance bleedAvoidance;
-    const bool includeLogicalLeftEdge;
-    const bool includeLogicalRightEdge;
-
-    BorderEdge edges[4];
-
-    unsigned visibleEdgeCount;
-    unsigned firstVisibleEdge;
-    BorderEdgeFlags visibleEdgeSet;
-
-    bool isUniformStyle;
-    bool isUniformWidth;
-    bool isUniformColor;
-    bool hasAlpha;
-};
-
 LayoutRectOutsets doubleStripeInsets(const BorderEdge edges[], BorderEdge::DoubleBorderStripe stripe)
 {
     // Insets are representes as negative outsets.
     return LayoutRectOutsets(
         -edges[BSTop].getDoubleBorderStripeWidth(stripe),
         -edges[BSRight].getDoubleBorderStripeWidth(stripe),
         -edges[BSBottom].getDoubleBorderStripeWidth(stripe),
         -edges[BSLeft].getDoubleBorderStripeWidth(stripe));
 }
 
@@ skipping 167 matching lines @@
         // For BackgroundBleedClip{Only,Layer}, the outer rrect clip is already applied.
         if (!bleedAvoidanceIsClipping(bleedAvoidance))
             graphicsContext->clipRoundedRect(outerBorder);
 
         // 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 (bleedAvoidance != BackgroundBleedBackgroundOverBorder && innerBorder.isRenderable() && !innerBorder.isEmpty())
             graphicsContext->clipOutRoundedRect(innerBorder);
     }
 
+    if (RuntimeEnabledFeatures::antiAliasBordersEnabled() || RuntimeEnabledFeatures::slimmingPaintEnabled()) {
+        BoxBorderPainter(borderInfo, outerBorder, innerBorder).paint(graphicsContext);
+        return;
+    }
+
     // If only one edge visible antialiasing doesn't create seams
     bool antialias = shouldAntialiasLines(graphicsContext) || borderInfo.visibleEdgeCount == 1;
     if (borderInfo.hasAlpha) {
         paintTranslucentBorderSides(graphicsContext, style, outerBorder, innerBorder, borderInfo.edges,
-        borderInfo.visibleEdgeSet, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias);
+            borderInfo.visibleEdgeSet, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias);
     } else {
         paintBorderSides(graphicsContext, style, outerBorder, innerBorder, borderInfo.edges,
-        borderInfo.visibleEdgeSet, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias);
+            borderInfo.visibleEdgeSet, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias);
     }
 }
 
 static inline bool includesAdjacentEdges(BorderEdgeFlags flags)
 {
     // The set includes adjacent edges iff it contains at least one horizontal and one vertical edge.
     return (flags & (TopBorderEdge | BottomBorderEdge))
         && (flags & (LeftBorderEdge | RightBorderEdge));
 }
 
@@ skipping 398 matching lines @@
     }
 }
 
 void BoxPainter::clipBorderSidePolygon(GraphicsContext* graphicsContext, const FloatRoundedRect& outerBorder, const FloatRoundedRect& innerBorder, BoxSide side, bool firstEdgeMatches, bool secondEdgeMatches)
 {
     FloatPoint quad[4];
 
     const LayoutRect outerRect(outerBorder.rect());
     const LayoutRect innerRect(innerBorder.rect());
 
-    FloatPoint centerPoint(innerRect.location().x().toFloat() + innerRect.width().toFloat() / 2, innerRect.location().y().toFloat() + innerRect.height().toFloat() / 2);
-
     // 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
     //       |\  1----------- 2  /|
     //       | 1                1 |
     //       | |                | |
     //       | |                | |
     //       | 2                2 |
@@ skipping 158 matching lines @@
 
     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);
 }
 
 } // namespace blink