Optimized box border side painting order

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/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
+#include "wtf/Vector.h"
+#include <algorithm>
 
 namespace blink {
 
 namespace {
 
 enum BorderEdgeFlag {
     TopBorderEdge = 1 << BSTop,
     RightBorderEdge = 1 << BSRight,
     BottomBorderEdge = 1 << BSBottom,
     LeftBorderEdge = 1 << BSLeft,
@@ skipping 76 matching lines @@
         return true;
 
     return borderStyleHasUnmatchedColorsAtCorner(edges[side].borderStyle(), side, adjacentSide);
 }
 
 inline bool borderWillArcInnerEdge(const FloatSize& firstRadius, const FloatSize& secondRadius)
 {
     return !firstRadius.isZero() || !secondRadius.isZero();
 }
 
-// This assumes that we draw in order: top, bottom, left, right.
-inline bool willBeOverdrawn(BoxSide side, BoxSide adjacentSide, const BorderEdge edges[])
+inline bool willOverdraw(BoxSide side, EBorderStyle style, BorderEdgeFlags completedEdges)
 {
-    switch (side) {
-    case BSTop:
-    case BSBottom:
-        if (edges[adjacentSide].presentButInvisible())
-            return false;
+    // If we're done with this side, it will obviously not overdraw any portion of the current edge.
+    if (includesEdge(completedEdges, side))
+        return false;
 
-        if (!edges[side].sharesColorWith(edges[adjacentSide]) && edges[adjacentSide].color.hasAlpha())
-            return false;
-
-        if (!borderStyleFillsBorderArea(edges[adjacentSide].borderStyle()))
-            return false;
-
-        return true;
-
-    case BSLeft:
-    case BSRight:
-        // These draw last, so are never overdrawn.
-        return false;
-    }
-    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)
+inline bool joinRequiresMitre(BoxSide side, BoxSide adjacentSide, const BorderEdge edges[],
+    bool allowOverdraw, BorderEdgeFlags completedEdges)
 {
-    if ((edges[side].isTransparent && edges[adjacentSide].isTransparent) || !edges[adjacentSide].isPresent)
+    if (!edges[adjacentSide].isPresent)
         return false;
 
-    if (allowOverdraw && willBeOverdrawn(side, adjacentSide, edges))
+    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;
 }
@@ skipping 189 matching lines @@
         context->fillDRRect(outer, inner, color);
         break;
     }
 }
 
 bool bleedAvoidanceIsClipping(BackgroundBleedAvoidance bleedAvoidance)
 {
     return bleedAvoidance == BackgroundBleedClipOnly || bleedAvoidance == BackgroundBleedClipLayer;
 }
 
+// The LUTs below assume specific enum values.
+static_assert(BNONE == 0, "unexpected EBorderStyle value");
+static_assert(BHIDDEN == 1, "unexpected EBorderStyle value");
+static_assert(INSET == 2, "unexpected EBorderStyle value");
+static_assert(GROOVE == 3, "unexpected EBorderStyle value");
+static_assert(OUTSET == 4, "unexpected EBorderStyle value");
+static_assert(RIDGE == 5, "unexpected EBorderStyle value");
+static_assert(DOTTED == 6, "unexpected EBorderStyle value");
+static_assert(DASHED == 7, "unexpected EBorderStyle value");
+static_assert(SOLID == 8, "unexpected EBorderStyle value");
+static_assert(DOUBLE == 9, "unexpected EBorderStyle value");
+
+static_assert(BSTop == 0, "unexpected BoxSide value");
+static_assert(BSRight == 1, "unexpected BoxSide value");
+static_assert(BSBottom == 2, "unexpected BoxSide value");
+static_assert(BSLeft == 3, "unexpected BoxSide value");
+
+// Style-based paint order: non-solid edges (dashed/dotted/double) are painted before
+// solid edges (inset/outset/groove/ridge/solid) to maximize overdraw opportunities.
+const unsigned kStylePriority[] = {
+    0 /* BNONE */,
+    0 /* BHIDDEN */,
+    2 /* INSET */,
+    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.
+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 {
+    OpacityGroup(unsigned alpha) : edgeFlags(0), alpha(alpha) { }
+
+    Vector<BoxSide, 4> sides;
+    BorderEdgeFlags edgeFlags;
+    unsigned alpha;
+};
+
 } // anonymous namespace
 
+// Holds edges grouped by opacity and sorted in paint order.
+struct BoxBorderPainter::ComplexBorderInfo {
+    ComplexBorderInfo(const BoxBorderPainter& borderPainter, bool antiAlias)
+        : antiAlias(antiAlias)
+    {
+        Vector<BoxSide, 4> sortedSides;
+
+        // First, collect all visible sides.
+        for (unsigned i = borderPainter.m_firstVisibleEdge; i < 4; ++i) {
+            BoxSide side = static_cast<BoxSide>(i);
+
+            if (includesEdge(borderPainter.m_visibleEdgeSet, side))
+                sortedSides.append(side);
+        }
+        ASSERT(!sortedSides.isEmpty());
+
+        // Then sort them in paint order, based on three (prioritized) criteria: alpha, style, side.
+        std::sort(sortedSides.begin(), sortedSides.end(),
+            [&borderPainter] (BoxSide a, BoxSide b) -> bool {
+            const BorderEdge& edgeA = borderPainter.m_edges[a];
+            const BorderEdge& edgeB = borderPainter.m_edges[b];
+
+            const unsigned alphaA = edgeA.color.alpha();
+            const unsigned alphaB = edgeB.color.alpha();
+            if (alphaA != alphaB)
+                return alphaA < alphaB;
+
+            const unsigned stylePriorityA = kStylePriority[edgeA.borderStyle()];
+            const unsigned stylePriorityB = kStylePriority[edgeB.borderStyle()];
+            if (stylePriorityA != stylePriorityB)
+                return stylePriorityA < stylePriorityB;
+
+            return kSidePriority[a] < kSidePriority[b];
+        });
+
+        // Finally, build the opacity group structures.
+        buildOpacityGroups(borderPainter, sortedSides);
+
+        if (borderPainter.m_isRounded)
+            roundedBorderPath.addRoundedRect(borderPainter.m_outer);
+    }
+
+    Vector<OpacityGroup, 4> opacityGroups;
+
+    // Potentially used when drawing rounded borders.
+    Path roundedBorderPath;
+
+    bool antiAlias;
+
+private:
+    void buildOpacityGroups(const BoxBorderPainter& borderPainter,
+        const Vector<BoxSide, 4>& sortedSides)
+    {
+        unsigned currentAlpha = 0;
+        for (BoxSide side : sortedSides) {
+            const BorderEdge& edge = borderPainter.m_edges[side];
+            const unsigned edgeAlpha = edge.color.alpha();
+
+            ASSERT(edgeAlpha > 0);
+            ASSERT(edgeAlpha >= currentAlpha);
+            if (edgeAlpha != currentAlpha) {
+                opacityGroups.append(OpacityGroup(edgeAlpha));
+                currentAlpha = edgeAlpha;
+            }
+
+            ASSERT(!opacityGroups.isEmpty());
+            OpacityGroup& currentGroup = opacityGroups.last();
+            currentGroup.sides.append(side);
+            currentGroup.edgeFlags |= edgeFlagForSide(side);
+        }
+
+        ASSERT(!opacityGroups.isEmpty());
+    }
+};
+
 void BoxBorderPainter::drawDoubleBorder(GraphicsContext* context, const LayoutRect& borderRect) const
 {
     ASSERT(m_isUniformColor);
     ASSERT(m_isUniformStyle);
     ASSERT(firstEdge().borderStyle() == DOUBLE);
     ASSERT(m_visibleEdgeSet == AllBorderEdges);
 
     const Color color = firstEdge().color;
 
     // outer stripe
@@ skipping 65 matching lines @@
     : m_style(style)
     , m_bleedAvoidance(bleedAvoidance)
     , m_includeLogicalLeftEdge(includeLogicalLeftEdge)
     , m_includeLogicalRightEdge(includeLogicalRightEdge)
     , m_visibleEdgeCount(0)
     , m_firstVisibleEdge(0)
     , m_visibleEdgeSet(0)
     , m_isUniformStyle(true)
     , m_isUniformWidth(true)
     , m_isUniformColor(true)
+    , m_isRounded(false)
     , m_hasAlpha(false)
 {
     style.getBorderEdgeInfo(m_edges, includeLogicalLeftEdge, includeLogicalRightEdge);
 
     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_edges); ++i) {
         const BorderEdge& edge = m_edges[i];
 
         if (!edge.shouldRender()) {
             if (edge.presentButInvisible()) {
                 m_isUniformWidth = false;
@@ skipping 26 matching lines @@
     m_inner = style.getRoundedInnerBorderFor(borderRect, includeLogicalLeftEdge, includeLogicalRightEdge);
 
     // If no corner intersects the clip region, we can pretend the outer border is
     // rectangular to improve performance.
     // FIXME: why is this predicated on uniform style & solid edges?
     if (m_isUniformStyle
         && firstEdge().borderStyle() == SOLID
         && m_outer.isRounded()
         && BoxPainter::allCornersClippedOut(m_outer, clipRect))
         m_outer.setRadii(FloatRoundedRect::Radii());
+
+    m_isRounded = m_outer.isRounded();
 }
 
 void BoxBorderPainter::paintBorder(const PaintInfo& info, const LayoutRect& rect) const
 {
     if (!m_visibleEdgeCount || m_outer.rect().isEmpty())
         return;
 
     GraphicsContext* graphicsContext = info.context;
 
     if (paintBorderFastPath(graphicsContext, rect))
         return;
 
     bool clipToOuterBorder = m_outer.isRounded();
     GraphicsContextStateSaver stateSaver(*graphicsContext, clipToOuterBorder);
     if (clipToOuterBorder) {
         // 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;
-    if (m_hasAlpha) {
-        paintTranslucentBorderSides(graphicsContext, antialias);
-    } else {
-        paintBorderSides(graphicsContext, m_visibleEdgeSet, antialias);
-    }
+
+    const ComplexBorderInfo borderInfo(*this, antialias);
+    paintOpacityGroup(graphicsContext, borderInfo, 0, 1);
 }
 
-void BoxBorderPainter::paintTranslucentBorderSides(GraphicsContext* graphicsContext,
-    bool antialias) const
+// 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]
+//   3) reverse-iterate over groups (decreasing opacity order), pushing nested transparency
+//      layers with adjusted/relative opacity [paintOpacityGroup]
+//   4) iterate over groups (increasing opacity order), painting actual group contents and
+//      then ending their corresponding transparency layer [paintOpacityGroup]
+//
+// Layers are created in decreasing opacity order (top -> bottom), while actual border sides are
+// drawn in increasing opacity order (bottom -> top). At each level, opacity is adjusted to acount
+// for accumulated/ancestor layer alpha. Because opacity is applied via layers, the actual draw
+// paint is opaque.
+//
+// As an example, let's consider a border with the following sides/opacities:
+//
+//   top:    1.0
+//   right:  0.25
+//   bottom: 0.5
+//   left:   0.25
+//
+// These are grouped and sorted in ComplexBorderInfo as follows:
+//
+//   group[0]: { alpha: 1.0,  sides: top }
+//   group[1]: { alpha: 0.5,  sides: bottom }
+//   group[2]: { alpha: 0.25, sides: right, left }
+//
+// Applying the algorithm yields the following paint sequence:
+//
+//                                 // no layer needed for group 0 (alpha == 1)
+//   beginLayer(0.5)               // layer for group 1
+//     beginLayer(0.5)             // layer for group 2 (effective opacity: 0.5 * 0.5 == 0.25)
+//       paintSides(right, left)   // paint group 2
+//     endLayer
+//     paintSides(bottom)          // paint group 1
+//   endLayer
+//   paintSides(top)               // paint group 0
+//
+// Note that we're always drawing using opaque paints on top of less-opaque content - hence
+// we can use overdraw to mask portions of the previous sides.
+//
+BorderEdgeFlags BoxBorderPainter::paintOpacityGroup(GraphicsContext* context,
+    const ComplexBorderInfo& borderInfo, unsigned index, float effectiveOpacity) const
 {
-    // willBeOverdrawn assumes that we draw in order: top, bottom, left, right.
-    // This is different from BoxSide enum order.
-    static const BoxSide paintOrder[] = { BSTop, BSBottom, BSLeft, BSRight };
+    ASSERT(effectiveOpacity > 0 && effectiveOpacity <= 1);
 
-    BorderEdgeFlags edgesToDraw = m_visibleEdgeSet;
-    while (edgesToDraw) {
-        // Find undrawn edges sharing a color.
-        Color commonColor;
+    const size_t opacityGroupCount = borderInfo.opacityGroups.size();
 
-        BorderEdgeFlags commonColorEdgeSet = 0;
-        for (size_t i = 0; i < sizeof(paintOrder) / sizeof(paintOrder[0]); ++i) {
-            BoxSide currSide = paintOrder[i];
-            if (!includesEdge(edgesToDraw, currSide))
-                continue;
+    // For overdraw logic purposes, treat missing/transparent edges as completed.
+    if (index >= opacityGroupCount)
+        return ~m_visibleEdgeSet;
 
-            bool includeEdge;
-            if (!commonColorEdgeSet) {
-                commonColor = m_edges[currSide].color;
-                includeEdge = true;
-            } else {
-                includeEdge = m_edges[currSide].color == commonColor;
-            }
+    // Groups are sorted in increasing opacity order, but we need to create layers in
+    // decreasing opacity order - hence the reverse iteration.
+    const OpacityGroup& group = borderInfo.opacityGroups[opacityGroupCount - index - 1];
 
-            if (includeEdge)
-                commonColorEdgeSet |= edgeFlagForSide(currSide);
-        }
+    // Adjust this group's paint opacity to account for ancestor transparency layers
+    // (needed in case we avoid creating a layer below).
+    unsigned paintAlpha = group.alpha / effectiveOpacity;
+    ASSERT(paintAlpha <= 255);
 
-        bool useTransparencyLayer = includesAdjacentEdges(commonColorEdgeSet) && commonColor.hasAlpha();
-        if (useTransparencyLayer) {
-            graphicsContext->beginLayer(static_cast<float>(commonColor.alpha()) / 255);
-            commonColor = Color(commonColor.red(), commonColor.green(), commonColor.blue());
-        }
+    // For the last (bottom) group, we can skip the layer even in the presence of opacity iff
+    // it contains no adjecent edges (no in-group overdraw possibility).
+    bool needsLayer = group.alpha != 255
+        && (includesAdjacentEdges(group.edgeFlags) || (index + 1 < borderInfo.opacityGroups.size()));
 
-        paintBorderSides(graphicsContext, commonColorEdgeSet, antialias, &commonColor);
+    if (needsLayer) {
+        const float groupOpacity = static_cast<float>(group.alpha) / 255;
+        ASSERT(groupOpacity < effectiveOpacity);
 
-        if (useTransparencyLayer)
-            graphicsContext->endLayer();
+        context->beginLayer(groupOpacity / effectiveOpacity);
+        effectiveOpacity = groupOpacity;
 
-        edgesToDraw &= ~commonColorEdgeSet;
+        // Group opacity is applied via a layer => we draw the members using opaque paint.
+        paintAlpha = 255;
+    }
+
+    // Recursion may seem unpalatable here, but
+    //   a) it has an upper bound of 4
+    //   b) only triggers at all when mixing border sides with different opacities
+    //   c) it allows us to express the layer nesting algorithm more naturally
+    BorderEdgeFlags completedEdges = paintOpacityGroup(context, borderInfo, index + 1, effectiveOpacity);
+
+    // Paint the actual group edges with an alpha adjusted to account for ancenstor layers opacity.
+    for (BoxSide side : group.sides) {
+        paintSide(context, borderInfo, side, paintAlpha, completedEdges);
+        completedEdges |= edgeFlagForSide(side);
+    }
+
+    if (needsLayer)
+        context->endLayer();
+
+    return completedEdges;
+}
+
+void BoxBorderPainter::paintSide(GraphicsContext* context, const ComplexBorderInfo& borderInfo,
+    BoxSide side, unsigned alpha, BorderEdgeFlags completedEdges) const
+{
+    const BorderEdge& edge = m_edges[side];
+    ASSERT(edge.shouldRender());
+    const Color color(edge.color.red(), edge.color.green(), edge.color.blue(), alpha);
+
+    FloatRect sideRect = m_outer.rect();
+    const Path* path = nullptr;
+
+    // TODO(fmalita): find a way to consolidate these without sacrificing readability.
+    switch (side) {
+    case BSTop: {
+        bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
+            || borderWillArcInnerEdge(m_inner.radii().topLeft(), m_inner.radii().topRight()));
+        if (usePath)
+            path = &borderInfo.roundedBorderPath;
+        else
+            sideRect.setHeight(edge.width);
+
+        paintOneBorderSide(context, sideRect, BSTop, BSLeft, BSRight, path, borderInfo.antiAlias,
+            color, completedEdges);
+        break;
+    }
+    case BSBottom: {
+        bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
+            || borderWillArcInnerEdge(m_inner.radii().bottomLeft(), m_inner.radii().bottomRight()));
+        if (usePath)
+            path = &borderInfo.roundedBorderPath;
+        else
+            sideRect.shiftYEdgeTo(sideRect.maxY() - edge.width);
+
+        paintOneBorderSide(context, sideRect, BSBottom, BSLeft, BSRight, path, borderInfo.antiAlias,
+            color, completedEdges);
+        break;
+    }
+    case BSLeft: {
+        bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
+            || borderWillArcInnerEdge(m_inner.radii().bottomLeft(), m_inner.radii().topLeft()));
+        if (usePath)
+            path = &borderInfo.roundedBorderPath;
+        else
+            sideRect.setWidth(edge.width);
+
+        paintOneBorderSide(context, sideRect, BSLeft, BSTop, BSBottom, path, borderInfo.antiAlias,
+            color, completedEdges);
+        break;
+    }
+    case BSRight: {
+        bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
+            || borderWillArcInnerEdge(m_inner.radii().bottomRight(), m_inner.radii().topRight()));
+        if (usePath)
+            path = &borderInfo.roundedBorderPath;
+        else
+            sideRect.shiftXEdgeTo(sideRect.maxX() - edge.width);
+
+        paintOneBorderSide(context, sideRect, BSRight, BSTop, BSBottom, path, borderInfo.antiAlias,
+            color, completedEdges);
+        break;
+    }
+    default:
+        ASSERT_NOT_REACHED();
     }
 }
 
 void BoxBorderPainter::paintOneBorderSide(GraphicsContext* graphicsContext,
     const FloatRect& sideRect, BoxSide side, BoxSide adjacentSide1, BoxSide adjacentSide2,
-    const Path* path, bool antialias, const Color* overrideColor) const
+    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];
 
-    const Color& colorToPaint = overrideColor ? *overrideColor : edgeToRender.color;
-
     if (path) {
         bool adjacentSide1StylesMatch = colorsMatchAtCorner(side, adjacentSide1, m_edges);
         bool adjacentSide2StylesMatch = colorsMatchAtCorner(side, adjacentSide2, m_edges);
 
         GraphicsContextStateSaver stateSaver(*graphicsContext);
         if (m_inner.isRenderable())
             clipBorderSidePolygon(graphicsContext, side, adjacentSide1StylesMatch, adjacentSide2StylesMatch);
         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, colorToPaint, edgeToRender.borderStyle());
+            thickness, side, color, edgeToRender.borderStyle());
     } else {
-        bool mitreAdjacentSide1 = joinRequiresMitre(side, adjacentSide1, m_edges, !antialias);
-        bool mitreAdjacentSide2 = joinRequiresMitre(side, adjacentSide2, m_edges, !antialias);
+        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;
 
         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;
         }
 
         ObjectPainter::drawLineForBoxSide(graphicsContext, sideRect.x(), sideRect.y(),
-            sideRect.maxX(), sideRect.maxY(), side, colorToPaint, edgeToRender.borderStyle(),
+            sideRect.maxX(), sideRect.maxY(), side, color, edgeToRender.borderStyle(),
             mitreAdjacentSide1 ? adjacentEdge1.width : 0, mitreAdjacentSide2 ? adjacentEdge2.width : 0, antialias);
     }
 }
 
-void BoxBorderPainter::paintBorderSides(GraphicsContext* graphicsContext, BorderEdgeFlags edgeSet,
-    bool antialias, const Color* overrideColor) const
-{
-    bool renderRadii = m_outer.isRounded();
-
-    Path roundedPath;
-    if (renderRadii)
-        roundedPath.addRoundedRect(m_outer);
-
-    // The inner border adjustment for bleed avoidance mode BackgroundBleedBackgroundOverBorder
-    // is only applied to sideRect, which is okay since BackgroundBleedBackgroundOverBorder
-    // is only to be used for solid borders and the shape of the border painted by drawBoxSideFromPath
-    // only depends on sideRect when painting solid borders.
-
-    if (includesEdge(edgeSet, BSTop)) {
-        const BorderEdge& edge = m_edges[BSTop];
-        ASSERT(edge.shouldRender());
-
-        FloatRect sideRect = m_outer.rect();
-        sideRect.setHeight(edge.width);
-
-        bool usePath = renderRadii && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().topLeft(), m_inner.radii().topRight()));
-        paintOneBorderSide(graphicsContext, sideRect, BSTop, BSLeft, BSRight,
-            usePath ? &roundedPath : 0, antialias, overrideColor);
-    }
-
-    if (includesEdge(edgeSet, BSBottom)) {
-        const BorderEdge& edge = m_edges[BSBottom];
-        ASSERT(edge.shouldRender());
-
-        FloatRect sideRect = m_outer.rect();
-        sideRect.shiftYEdgeTo(sideRect.maxY() - edge.width);
-
-        bool usePath = renderRadii && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().bottomLeft(), m_inner.radii().bottomRight()));
-        paintOneBorderSide(graphicsContext, sideRect, BSBottom, BSLeft, BSRight,
-            usePath ? &roundedPath : 0, antialias, overrideColor);
-    }
-
-    if (includesEdge(edgeSet, BSLeft)) {
-        const BorderEdge& edge = m_edges[BSLeft];
-        ASSERT(edge.shouldRender());
-
-        FloatRect sideRect = m_outer.rect();
-        sideRect.setWidth(edge.width);
-
-        bool usePath = renderRadii && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().bottomLeft(), m_inner.radii().topLeft()));
-        paintOneBorderSide(graphicsContext, sideRect, BSLeft, BSTop, BSBottom,
-            usePath ? &roundedPath : 0, antialias, overrideColor);
-    }
-
-    if (includesEdge(edgeSet, BSRight)) {
-        const BorderEdge& edge = m_edges[BSRight];
-        ASSERT(edge.shouldRender());
-
-        FloatRect sideRect = m_outer.rect();
-        sideRect.shiftXEdgeTo(sideRect.maxX() - edge.width);
-
-        bool usePath = renderRadii && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().bottomRight(), m_inner.radii().topRight()));
-        paintOneBorderSide(graphicsContext, sideRect, BSRight, BSTop, BSBottom,
-            usePath ? &roundedPath : 0, antialias, overrideColor);
-    }
-}
-
 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;
 
     if (borderStyle == DOUBLE && thickness < 3)
         borderStyle = SOLID;
 
@@ skipping 315 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