reflow comments in core/paint

third_party/WebKit/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 "core/paint/BoxBorderPainter.h"
 
 #include "core/paint/BoxPainter.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/style/BorderEdge.h"
@@ skipping 19 matching lines @@
 
 inline BorderEdgeFlag edgeFlagForSide(BoxSide side) {
   return static_cast<BorderEdgeFlag>(1 << side);
 }
 
 inline bool includesEdge(BorderEdgeFlags flags, BoxSide side) {
   return flags & edgeFlagForSide(side);
 }
 
 inline bool includesAdjacentEdges(BorderEdgeFlags flags) {
-  // The set includes adjacent edges iff it contains at least one horizontal and one vertical edge.
+  // The set includes adjacent edges iff it contains at least one horizontal and
+  // one vertical edge.
   return (flags & (TopBorderEdge | BottomBorderEdge)) &&
          (flags & (LeftBorderEdge | RightBorderEdge));
 }
 
 inline bool styleRequiresClipPolygon(EBorderStyle style) {
   // These are drawn with a stroke, so we have to clip to get corner miters.
   return style == BorderStyleDotted || style == BorderStyleDashed;
 }
 
 inline bool borderStyleFillsBorderArea(EBorderStyle style) {
   return !(style == BorderStyleDotted || style == BorderStyleDashed ||
            style == BorderStyleDouble);
 }
 
 inline bool borderStyleHasInnerDetail(EBorderStyle style) {
   return style == BorderStyleGroove || style == BorderStyleRidge ||
          style == BorderStyleDouble;
 }
 
 inline bool borderStyleIsDottedOrDashed(EBorderStyle style) {
   return style == BorderStyleDotted || style == BorderStyleDashed;
 }
 
-// BorderStyleOutset darkens the bottom and right (and maybe lightens the top and left)
-// BorderStyleInset darkens the top and left (and maybe lightens the bottom and right)
+// BorderStyleOutset darkens the bottom and right (and maybe lightens the top
+// and left) BorderStyleInset darkens the top and left (and maybe lightens the
+// bottom and right).
 inline bool borderStyleHasUnmatchedColorsAtCorner(EBorderStyle style,
                                                   BoxSide side,
                                                   BoxSide adjacentSide) {
   // These styles match at the top/left and bottom/right.
   if (style == BorderStyleInset || style == BorderStyleGroove ||
       style == BorderStyleRidge || style == BorderStyleOutset) {
     const BorderEdgeFlags topRightFlags =
         edgeFlagForSide(BSTop) | edgeFlagForSide(BSRight);
     const BorderEdgeFlags bottomLeftFlags =
         edgeFlagForSide(BSBottom) | edgeFlagForSide(BSLeft);
@@ skipping 19 matching lines @@
 }
 
 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 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.
+  // The side is still to be drawn. It overdraws the current edge iff it has a
+  // solid fill style.
   return borderStyleFillsBorderArea(style);
 }
 
 inline bool borderStylesRequireMiter(BoxSide side,
                                      BoxSide adjacentSide,
                                      EBorderStyle style,
                                      EBorderStyle adjacentStyle) {
   if (style == BorderStyleDouble || adjacentStyle == BorderStyleDouble ||
       adjacentStyle == BorderStyleGroove || adjacentStyle == BorderStyleRidge)
     return true;
@@ skipping 50 matching lines @@
       sideRect.shiftXEdgeTo(sideRect.maxX() - width);
       break;
   }
 
   return sideRect;
 }
 
 FloatRoundedRect calculateAdjustedInnerBorder(
     const FloatRoundedRect& innerBorder,
     BoxSide side) {
-  // Expand the inner border as necessary to make it a rounded rect (i.e. radii contained within each edge).
-  // This function relies on the fact we only get radii not contained within each edge if one of the radii
-  // for an edge is zero, so we can shift the arc towards the zero radius corner.
+  // Expand the inner border as necessary to make it a rounded rect (i.e. radii
+  // contained within each edge).  This function relies on the fact we only get
+  // radii not contained within each edge if one of the radii for an edge is
+  // zero, so we can shift the arc towards the zero radius corner.
   FloatRoundedRect::Radii newRadii = innerBorder.getRadii();
   FloatRect newRect = innerBorder.rect();
 
   float overshoot;
   float maxRadii;
 
   switch (side) {
     case BSTop:
       overshoot = newRadii.topLeft().width() + newRadii.topRight().width() -
                   newRect.width();
-      // FIXME: once we start pixel-snapping rounded rects after this point, the overshoot concept
-      // should disappear.
+      // FIXME: once we start pixel-snapping rounded rects after this point, the
+      // overshoot concept should disappear.
       if (overshoot > 0.1) {
         newRect.setWidth(newRect.width() + overshoot);
         if (!newRadii.topLeft().width())
           newRect.move(-overshoot, 0);
       }
       newRadii.setBottomLeft(FloatSize(0, 0));
       newRadii.setBottomRight(FloatSize(0, 0));
       maxRadii =
           std::max(newRadii.topLeft().height(), newRadii.topRight().height());
       if (maxRadii > newRect.height())
@@ skipping 84 matching lines @@
     context.setShouldAntialias(false);
 }
 
 void drawBleedAdjustedDRRect(GraphicsContext& context,
                              BackgroundBleedAvoidance bleedAvoidance,
                              const FloatRoundedRect& outer,
                              const FloatRoundedRect& inner,
                              Color color) {
   switch (bleedAvoidance) {
     case BackgroundBleedClipLayer: {
-      // BackgroundBleedClipLayer clips the outer rrect for the whole layer. Based on this,
-      // we can avoid background bleeding by filling the *outside* of inner rrect, all the
-      // way to the layer bounds (enclosing int rect for the clip, in device space).
+      // BackgroundBleedClipLayer clips the outer rrect for the whole layer.
+      // Based on this, we can avoid background bleeding by filling the
+      // *outside* of inner rrect, all the way to the layer bounds (enclosing
+      // int rect for the clip, in device space).
       ASSERT(outer.isRounded());
 
       SkPath path;
       path.addRRect(inner);
       path.setFillType(SkPath::kInverseWinding_FillType);
 
       SkPaint paint;
       paint.setColor(color.rgb());
       paint.setStyle(SkPaint::kFill_Style);
       paint.setAntiAlias(true);
@@ skipping 31 matching lines @@
 static_assert(BorderStyleDotted == 6, "unexpected EBorderStyle value");
 static_assert(BorderStyleDashed == 7, "unexpected EBorderStyle value");
 static_assert(BorderStyleSolid == 8, "unexpected EBorderStyle value");
 static_assert(BorderStyleDouble == 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.
+// 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 /* BorderStyleNone */,   0 /* BorderStyleHidden */,
     2 /* BorderStyleInset */,  2 /* BorderStyleGroove */,
     2 /* BorderStyleOutset */, 2 /* BorderStyleRidge */,
     1 /* BorderStyleDotted */, 1 /* BorderStyleDashed */,
     3 /* BorderStyleSolid */,  1 /* BorderStyleDouble */
 };
 
-// Given the same style, prefer drawing in non-adjacent order to minimize the number of sides
-// which require miters.
+// Given the same style, prefer drawing in non-adjacent order to minimize the
+// number of sides 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.
+// 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;
 };
 
 void clipQuad(GraphicsContext& context,
               const FloatPoint quad[],
@@ skipping 17 matching lines @@
 
     // 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.
+    // 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;
@@ skipping 94 matching lines @@
       }
     } else {
       // 4-side, double border => 2x drawDRRect()
       ASSERT(firstEdge().borderStyle() == BorderStyleDouble);
       drawDoubleBorder(context, borderRect);
     }
 
     return true;
   }
 
-  // This is faster than the normal complex border path only if it avoids creating transparency
-  // layers (when the border is translucent).
+  // This is faster than the normal complex border path only if it avoids
+  // creating transparency layers (when the border is translucent).
   if (firstEdge().borderStyle() == BorderStyleSolid && !m_outer.isRounded() &&
       m_hasAlpha) {
     ASSERT(m_visibleEdgeSet != AllBorderEdges);
     // solid, rectangular border => one drawPath()
     Path path;
     path.setWindRule(RULE_NONZERO);
 
     for (int i = BSTop; i <= BSLeft; ++i) {
       const BorderEdge& currEdge = m_edges[i];
       if (currEdge.shouldRender())
@@ skipping 103 matching lines @@
     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.
+    // For BackgroundBleedClip{Only,Layer}, the outer rrect clip is already
+    // applied.
     if (!bleedAvoidanceIsClipping(m_bleedAvoidance))
       graphicsContext.clipRoundedRect(m_outer);
 
     if (m_inner.isRenderable() && !m_inner.isEmpty())
       graphicsContext.clipOutRoundedRect(m_inner);
   }
 
   const ComplexBorderInfo borderInfo(*this, true);
   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:
+// 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]
+//   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]
+//   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.
+// 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
+//                                // no layer needed for group 0 (alpha = 1)
+//   beginLayer(0.5)              // layer for group 1
+//     beginLayer(0.5)            // layer for group 2 (alpha: 0.5 * 0.5 = 0.25)
+//       paintSides(right, left)  // paint group 2
 //     endLayer
-//     paintSides(bottom)          // paint group 1
+//     paintSides(bottom)         // paint group 1
 //   endLayer
-//   paintSides(top)               // paint group 0
+//   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.
+// 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 {
   ASSERT(effectiveOpacity > 0 && effectiveOpacity <= 1);
 
   const size_t opacityGroupCount = borderInfo.opacityGroups.size();
 
   // For overdraw logic purposes, treat missing/transparent edges as completed.
   if (index >= opacityGroupCount)
     return ~m_visibleEdgeSet;
 
-  // Groups are sorted in increasing opacity order, but we need to create layers in
-  // decreasing opacity order - hence the reverse iteration.
+  // 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];
 
-  // Adjust this group's paint opacity to account for ancestor transparency layers
-  // (needed in case we avoid creating a layer below).
+  // 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);
 
-  // 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).
+  // 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()));
 
   if (needsLayer) {
     const float groupOpacity = static_cast<float>(group.alpha) / 255;
     ASSERT(groupOpacity < effectiveOpacity);
 
     context.beginLayer(groupOpacity / effectiveOpacity);
     effectiveOpacity = groupOpacity;
 
-    // Group opacity is applied via a layer => we draw the members using opaque paint.
+    // 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.
+  // 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.
+  // 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.getRadii().topLeft(),
                                              m_inner.getRadii().topRight()));
       if (usePath)
         path = &borderInfo.roundedBorderPath;
       else
         sideRect.setHeight(edge.width);
@@ skipping 57 matching lines @@
   const BorderEdge& adjacentEdge = m_edges[adjacentSide];
 
   // No miters for missing edges.
   if (!adjacentEdge.isPresent)
     return NoMiter;
 
   // The adjacent edge will overdraw this corner, resulting in a correct miter.
   if (willOverdraw(adjacentSide, adjacentEdge.borderStyle(), completedEdges))
     return NoMiter;
 
-  // Color transitions require miters. Use miters compatible with the AA drawing mode to avoid
-  // introducing extra clips.
+  // 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 ? SoftMiter : HardMiter;
 
-  // Non-anti-aliased miters ensure correct same-color seaming when required by style.
+  // 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.
+  // Overdraw the adjacent edge when the colors match and we have no style
+  // restrictions.
   return NoMiter;
 }
 
 bool BoxBorderPainter::mitersRequireClipping(MiterType miter1,
                                              MiterType miter2,
                                              EBorderStyle style,
                                              bool antialias) {
-  // Clipping is required if any of the present miters 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 ? miter1 == HardMiter || miter2 == HardMiter
                               : miter1 == SoftMiter || miter2 == SoftMiter;
 
   // Some styles require clipping for any type of miter.
   shouldClip = shouldClip || ((miter1 != NoMiter || miter2 != NoMiter) &&
                               styleRequiresClipPolygon(style));
 
   return shouldClip;
 }
 
@@ skipping 77 matching lines @@
       graphicsContext.setStrokeColor(color);
 
       // The stroke is doubled here because the provided path is the
       // outside edge of the border so half the stroke is clipped off.
       // The extra multiplier is so that the clipping mask can antialias
       // the edges to prevent jaggies.
       graphicsContext.setStrokeThickness(drawThickness * 2 * 1.1f);
       graphicsContext.setStrokeStyle(
           borderStyle == BorderStyleDashed ? DashedStroke : DottedStroke);
 
-      // If the number of dashes that fit in the path is odd and non-integral then we
-      // will have an awkwardly-sized dash at the end of the path. To try to avoid that
-      // here, we simply make the whitespace dashes ever so slightly bigger.
-      // FIXME: This could be even better if we tried to manipulate the dash offset
-      // and possibly the gapLength to get the corners dash-symmetrical.
+      // If the number of dashes that fit in the path is odd and non-integral
+      // then we will have an awkwardly-sized dash at the end of the path. To
+      // try to avoid that here, we simply make the whitespace dashes ever so
+      // slightly bigger.
+      // FIXME: This could be even better if we tried to manipulate the dash
+      // offset and possibly the gapLength to get the corners dash-symmetrical.
       float dashLength =
           thickness * ((borderStyle == BorderStyleDashed) ? 3.0f : 1.0f);
       float gapLength = dashLength;
       float numberOfDashes = borderPath.length() / dashLength;
       // Don't try to show dashes if we have less than 2 dashes + 2 gaps.
       // FIXME: should do this test per side.
       if (numberOfDashes >= 4) {
         bool evenNumberOfFullDashes = !((int)numberOfDashes % 2);
         bool integralNumberOfDashes = !(numberOfDashes - (int)numberOfDashes);
         if (!evenNumberOfFullDashes && !integralNumberOfDashes) {
           float numberOfGaps = numberOfDashes / 2;
           gapLength += (dashLength / numberOfGaps);
         }
 
         DashArray lineDash;
         lineDash.append(dashLength);
         lineDash.append(gapLength);
         graphicsContext.setLineDash(lineDash, dashLength);
       }
 
       // FIXME: stroking the border path causes issues with tight corners:
       // https://bugs.webkit.org/show_bug.cgi?id=58711
-      // Also, to get the best appearance we should stroke a path between the two borders.
+      // Also, to get the best appearance we should stroke a path between the
+      // two borders.
       graphicsContext.strokePath(borderPath);
       return;
     }
     case BorderStyleDouble: {
       // Draw inner border line
       {
         GraphicsContextStateSaver stateSaver(graphicsContext);
         const LayoutRectOutsets innerInsets =
             doubleStripeInsets(m_edges, BorderEdge::DoubleBorderStripeInner);
         FloatRoundedRect innerClip = m_style.getRoundedInnerBorderFor(
@@ skipping 93 matching lines @@
                                              BoxSide side,
                                              MiterType firstMiter,
                                              MiterType secondMiter) const {
   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.
+  // 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 |
   //       |/  1------------2  \|
   //       3  /              \  3
@@ skipping 150 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];
     clipQuad(graphicsContext, secondQuad, secondMiter == SoftMiter);
   }
 }
 
 }  // namespace blink