Support subpixel layout for borders.

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 118 matching lines @@
   if (style != adjacentStyle)
     return true;
 
   return borderStyleHasUnmatchedColorsAtCorner(style, side, adjacentSide);
 }
 
 FloatRect calculateSideRect(const FloatRoundedRect& outerBorder,
                             const BorderEdge& edge,
                             int side) {
   FloatRect sideRect = outerBorder.rect();
-  int width = edge.width;
+  float width = edge.width();
 
   if (side == BSTop)
     sideRect.setHeight(width);
   else if (side == BSBottom)
     sideRect.shiftYEdgeTo(sideRect.maxY() - width);
   else if (side == BSLeft)
     sideRect.setWidth(width);
   else
     sideRect.shiftXEdgeTo(sideRect.maxX() - width);
 
   return sideRect;
 }
 
 FloatRect calculateSideRectIncludingInner(const FloatRoundedRect& outerBorder,
                                           const BorderEdge edges[],
                                           BoxSide side) {
   FloatRect sideRect = outerBorder.rect();
-  int width;
+  float width;
 
   switch (side) {
     case BSTop:
-      width = sideRect.height() - edges[BSBottom].width;
+      width = sideRect.height() - edges[BSBottom].width();
       sideRect.setHeight(width);
       break;
     case BSBottom:
-      width = sideRect.height() - edges[BSTop].width;
+      width = sideRect.height() - edges[BSTop].width();
       sideRect.shiftYEdgeTo(sideRect.maxY() - width);
       break;
     case BSLeft:
-      width = sideRect.width() - edges[BSRight].width;
+      width = sideRect.width() - edges[BSRight].width();
       sideRect.setWidth(width);
       break;
     case BSRight:
-      width = sideRect.width() - edges[BSLeft].width;
+      width = sideRect.width() - edges[BSLeft].width();
       sideRect.shiftXEdgeTo(sideRect.maxX() - width);
       break;
   }
 
   return sideRect;
 }
 
 FloatRoundedRect calculateAdjustedInnerBorder(
     const FloatRoundedRect& innerBorder,
     BoxSide side) {
@@ skipping 89 matching lines @@
                            -edges[BSRight].getDoubleBorderStripeWidth(stripe),
                            -edges[BSBottom].getDoubleBorderStripeWidth(stripe),
                            -edges[BSLeft].getDoubleBorderStripeWidth(stripe));
 }
 
 void drawSolidBorderRect(GraphicsContext& context,
                          const FloatRect& borderRect,
                          float borderWidth,
                          const Color& color) {
   FloatRect strokeRect(borderRect);
+  borderWidth = roundf(borderWidth);

[pdr., 2017/01/24 06:57:31]

Should we divide then round, or is this needed to match other rounding?

[Karl Øygard, 2017/01/24 22:42:58]

This should be fine as it is.  The following division is just to place things
correctly for strokeRect().

   strokeRect.inflate(-borderWidth / 2);
 
   bool wasAntialias = context.shouldAntialias();
   if (!wasAntialias)
     context.setShouldAntialias(true);
 
   context.setStrokeStyle(SolidStroke);
   context.setStrokeColor(color);
   context.strokeRect(strokeRect, borderWidth);
 
@@ skipping 213 matching lines @@
     return false;
 
   if (firstEdge().borderStyle() != BorderStyleSolid &&
       firstEdge().borderStyle() != BorderStyleDouble)
     return false;
 
   if (m_visibleEdgeSet == AllBorderEdges) {
     if (firstEdge().borderStyle() == BorderStyleSolid) {
       if (m_isUniformWidth && !m_outer.isRounded()) {
         // 4-side, solid, uniform-width, rectangular border => one drawRect()
-        drawSolidBorderRect(context, m_outer.rect(), firstEdge().width,
+        drawSolidBorderRect(context, m_outer.rect(), firstEdge().width(),
                             firstEdge().color);
       } else {
         // 4-side, solid border => one drawDRRect()
         drawBleedAdjustedDRRect(context, m_bleedAvoidance, m_outer, m_inner,
                                 firstEdge().color);
       }
     } else {
       // 4-side, double border => 2x drawDRRect()
       DCHECK(firstEdge().borderStyle() == BorderStyleDouble);
       drawDoubleBorder(context, borderRect);
@@ skipping 102 matching lines @@
 
     m_hasAlpha |= edge.color.hasAlpha();
 
     if (m_visibleEdgeCount == 1) {
       m_firstVisibleEdge = i;
       continue;
     }
 
     m_isUniformStyle &=
         edge.borderStyle() == m_edges[m_firstVisibleEdge].borderStyle();
-    m_isUniformWidth &= edge.width == m_edges[m_firstVisibleEdge].width;
+    m_isUniformWidth &= edge.width() == m_edges[m_firstVisibleEdge].width();
     m_isUniformColor &= edge.color == m_edges[m_firstVisibleEdge].color;
   }
 }
 
 void BoxBorderPainter::paintBorder(const PaintInfo& info,
                                    const LayoutRect& rect) const {
   if (!m_visibleEdgeCount || m_outer.rect().isEmpty())
     return;
 
   GraphicsContext& graphicsContext = info.context;
@@ skipping 140 matching lines @@
   // 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);
+        sideRect.setHeight(roundf(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.getRadii().bottomLeft(),
                                              m_inner.getRadii().bottomRight()));
       if (usePath)
         path = &borderInfo.roundedBorderPath;
       else
-        sideRect.shiftYEdgeTo(sideRect.maxY() - edge.width);
+        sideRect.shiftYEdgeTo(sideRect.maxY() - roundf(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.getRadii().bottomLeft(),
                                              m_inner.getRadii().topLeft()));
       if (usePath)
         path = &borderInfo.roundedBorderPath;
       else
-        sideRect.setWidth(edge.width);
+        sideRect.setWidth(roundf(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.getRadii().bottomRight(),
                                              m_inner.getRadii().topRight()));
       if (usePath)
         path = &borderInfo.roundedBorderPath;
       else
-        sideRect.shiftXEdgeTo(sideRect.maxX() - edge.width);
+        sideRect.shiftXEdgeTo(sideRect.maxX() - roundf(edge.width()));
 
       paintOneBorderSide(context, sideRect, BSRight, BSTop, BSBottom, path,
                          borderInfo.antiAlias, color, completedEdges);
       break;
     }
     default:
       ASSERT_NOT_REACHED();
   }
 }
 
@@ skipping 48 matching lines @@
     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];
-  DCHECK(edgeToRender.width);
+  DCHECK(edgeToRender.width());
   const BorderEdge& adjacentEdge1 = m_edges[adjacentSide1];
   const BorderEdge& adjacentEdge2 = m_edges[adjacentSide2];
 
   if (path) {
     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, miter1, miter2);
     else
       clipBorderSideForComplexInnerPath(graphicsContext, side);
-    float thickness = std::max(
-        std::max(edgeToRender.width, adjacentEdge1.width), adjacentEdge2.width);
+    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.width(), thickness, side, color,
                         edgeToRender.borderStyle());
   } else {
     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, miter1, miter2);
 
       // 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(),
-        miter1 != NoMiter ? adjacentEdge1.width : 0,
-        miter2 != NoMiter ? adjacentEdge2.width : 0, antialias);
+        miter1 != NoMiter ? roundf(adjacentEdge1.width()) : 0,
+        miter2 != NoMiter ? roundf(adjacentEdge2.width()) : 0, antialias);
   }
 }
 
 void BoxBorderPainter::drawBoxSideFromPath(GraphicsContext& graphicsContext,
                                            const LayoutRect& borderRect,
                                            const Path& borderPath,
                                            float thickness,
                                            float drawThickness,
                                            BoxSide side,
                                            Color color,
@@ skipping 103 matching lines @@
         s1 = BorderStyleOutset;
         s2 = BorderStyleInset;
       }
 
       // Paint full border
       drawBoxSideFromPath(graphicsContext, borderRect, borderPath, thickness,
                           drawThickness, side, color, s1);
 
       // Paint inner only
       GraphicsContextStateSaver stateSaver(graphicsContext);
-      LayoutUnit topWidth(m_edges[BSTop].usedWidth() / 2);
-      LayoutUnit bottomWidth(m_edges[BSBottom].usedWidth() / 2);
-      LayoutUnit leftWidth(m_edges[BSLeft].usedWidth() / 2);
-      LayoutUnit rightWidth(m_edges[BSRight].usedWidth() / 2);
+      int topWidth = m_edges[BSTop].usedWidth() / 2;
+      int bottomWidth = m_edges[BSBottom].usedWidth() / 2;
+      int leftWidth = m_edges[BSLeft].usedWidth() / 2;
+      int rightWidth = m_edges[BSRight].usedWidth() / 2;
 
       FloatRoundedRect clipRect = m_style.getRoundedInnerBorderFor(
           borderRect,
           LayoutRectOutsets(-topWidth, -rightWidth, -bottomWidth, -leftWidth),
           m_includeLogicalLeftEdge, m_includeLogicalRightEdge);
 
       graphicsContext.clipRoundedRect(clipRect);
       drawBoxSideFromPath(graphicsContext, borderRect, borderPath, thickness,
                           drawThickness, side, color, s2);
       return;
@@ skipping 201 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