[CSS Exclusions] Zoom causes shape-inside to fail when shape-padding is specified

Source/core/rendering/ExclusionPolygon.cpp

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 111 matching lines @@
     float angle5 =  ((padding) ? -angle : twoPI - angle) / arcSegmentCount;
 
     vertices.append(startArcVertex);
     for (unsigned i = 1; i < arcSegmentCount; ++i) {
         float angle = startAngle + angle5 * i;
         vertices.append(arcCenter + FloatPoint(cos(angle) * arcRadius, sin(angle) * arcRadius));
     }
     vertices.append(endArcVertex);
 }
 
+static inline void snapVerticesToLayoutUnitGrid(Vector<FloatPoint>& vertices)

[Julien - ping for review, 2013/04/23 17:09:04]

Wouldn't it make more sense to have your vertices be LayoutUnits instead of
floats? Alternatively have FloatPolygon keep them as LayoutUnits?

As done, any subsequent operation(s) on your floats can yield to more instances
of this bug (not to mention that it is inefficient but that's not really a
problem for now).

[leviw_travelin_and_unemployed, 2013/04/23 18:27:20]

For the record, I agree that since this issue shows that we'll have problems
when Floats don't align to the LayoutUnit grid, it would make more sense to use
them for our vertices.

+{
+    for (unsigned i = 0; i < vertices.size(); ++i)
+        vertices[i].set(LayoutUnit(vertices[i].x()).toFloat(), LayoutUnit(vertices[i].y()).toFloat());

[Julien - ping for review, 2013/04/23 17:09:04]

Note that this could (and will) yield to big roundings as we have saturated
arithmetic enabled and the conversion to LayoutUnit involves a multiplication.

Also it may be nice to just use the existing FloatPoint -> LayoutPoint explicit
conversions (to choose whether you want to ceil / floor / something else)
instead of manually doing this conversion.

+}
+
 static inline FloatPolygon* computeShapePaddingBounds(const FloatPolygon& polygon, float padding, WindRule fillRule)
 {
     Vector<FloatPoint>* paddedVertices = new Vector<FloatPoint>();
     FloatPoint intersection;
 
     for (unsigned i = 0; i < polygon.numberOfEdges(); ++i) {
         const FloatPolygonEdge& thisEdge = polygon.edgeAt(i);
         const FloatPolygonEdge& prevEdge = thisEdge.previousEdge();
         OffsetPolygonEdge thisOffsetEdge(thisEdge, inwardEdgeNormal(thisEdge) * padding);
         OffsetPolygonEdge prevOffsetEdge(prevEdge, inwardEdgeNormal(prevEdge) * padding);
 
         if (prevOffsetEdge.intersection(thisOffsetEdge, intersection))
             paddedVertices->append(intersection);
         else if (isReflexVertex(prevEdge.vertex1(), thisEdge.vertex1(), thisEdge.vertex2()))
             appendArc(*paddedVertices, thisEdge.vertex1(), padding, prevOffsetEdge.vertex2(), thisOffsetEdge.vertex1(), true);
     }
 
+    snapVerticesToLayoutUnitGrid(*paddedVertices);
     return new FloatPolygon(adoptPtr(paddedVertices), fillRule);
 }
 
 static inline FloatPolygon* computeShapeMarginBounds(const FloatPolygon& polygon, float margin, WindRule fillRule)
 {
     Vector<FloatPoint>* marginVertices = new Vector<FloatPoint>();
     FloatPoint intersection;
 
     for (unsigned i = 0; i < polygon.numberOfEdges(); ++i) {
         const FloatPolygonEdge& thisEdge = polygon.edgeAt(i);
         const FloatPolygonEdge& prevEdge = thisEdge.previousEdge();
         OffsetPolygonEdge thisOffsetEdge(thisEdge, outwardEdgeNormal(thisEdge) * margin);
         OffsetPolygonEdge prevOffsetEdge(prevEdge, outwardEdgeNormal(prevEdge) * margin);
 
         if (prevOffsetEdge.intersection(thisOffsetEdge, intersection))
             marginVertices->append(intersection);
         else
             appendArc(*marginVertices, thisEdge.vertex1(), margin, prevOffsetEdge.vertex2(), thisOffsetEdge.vertex1(), false);
     }
 
+    snapVerticesToLayoutUnitGrid(*marginVertices);
     return new FloatPolygon(adoptPtr(marginVertices), fillRule);
 }
 
 const FloatPolygon& ExclusionPolygon::shapePaddingBounds() const
 {
     ASSERT(shapePadding() >= 0);
     if (!shapePadding())
         return m_polygon;
 
     if (!m_paddingBounds)
@@ skipping 310 matching lines @@
             }
         }
     }
 
     if (firstFitFound)
         result = firstFitRect.y();
     return firstFitFound;
 }
 
 } // namespace WebCore