[CSS Exclusions] ExclusionShape bounding box methods should return LayoutRects

Source/core/rendering/exclusions/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 329 matching lines @@
         if (x1 > x2)
             std::swap(x1, x2);
 
         if (x2 > x1)
             result.append(ExclusionInterval(x1, x2));
     }
 
     sortExclusionIntervals(result);
 }
 
-void ExclusionPolygon::getExcludedIntervals(float logicalTop, float logicalHeight, SegmentList& result) const
+void ExclusionPolygon::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const
 {
     const FloatPolygon& polygon = shapeMarginBounds();
     if (polygon.isEmpty())
         return;
 
     float y1 = logicalTop;
-    float y2 = y1 + logicalHeight;
+    float y2 = logicalTop + logicalHeight;
 
     Vector<ExclusionInterval> y1XIntervals, y2XIntervals;
     computeXIntersections(polygon, y1, true, y1XIntervals);
     computeXIntersections(polygon, y2, false, y2XIntervals);
 
     Vector<ExclusionInterval> mergedIntervals;
     mergeExclusionIntervals(y1XIntervals, y2XIntervals, mergedIntervals);
 
     Vector<ExclusionInterval> edgeIntervals;
     computeOverlappingEdgeXProjections(polygon, y1, y2, edgeIntervals);
 
     Vector<ExclusionInterval> excludedIntervals;
     mergeExclusionIntervals(mergedIntervals, edgeIntervals, excludedIntervals);
 
     for (unsigned i = 0; i < excludedIntervals.size(); ++i) {
         ExclusionInterval interval = excludedIntervals[i];
         result.append(LineSegment(interval.x1, interval.x2));
     }
 }
 
-void ExclusionPolygon::getIncludedIntervals(float logicalTop, float logicalHeight, SegmentList& result) const
+void ExclusionPolygon::getIncludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const
 {
     const FloatPolygon& polygon = shapePaddingBounds();
     if (polygon.isEmpty())
         return;
 
     float y1 = logicalTop;
-    float y2 = y1 + logicalHeight;
+    float y2 = logicalTop + logicalHeight;
 
     Vector<ExclusionInterval> y1XIntervals, y2XIntervals;
     computeXIntersections(polygon, y1, true, y1XIntervals);
     computeXIntersections(polygon, y2, false, y2XIntervals);
 
     Vector<ExclusionInterval> commonIntervals;
     intersectExclusionIntervals(y1XIntervals, y2XIntervals, commonIntervals);
 
     Vector<ExclusionInterval> edgeIntervals;
     computeOverlappingEdgeXProjections(polygon, y1, y2, edgeIntervals);
@@ skipping 24 matching lines @@
 
 static inline bool aboveOrToTheLeft(const FloatRect& r1, const FloatRect& r2)
 {
     if (r1.y() < r2.y())
         return true;
     if (r1.y() == r2.y())
         return r1.x() < r2.x();
     return false;
 }
 
-bool ExclusionPolygon::firstIncludedIntervalLogicalTop(float minLogicalIntervalTop, const FloatSize& minLogicalIntervalSize, float& result) const
+bool ExclusionPolygon::firstIncludedIntervalLogicalTop(LayoutUnit minLogicalIntervalTop, const LayoutSize& minLogicalIntervalSize, LayoutUnit& result) const
 {
+    float minIntervalTop = minLogicalIntervalTop;
+    float minIntervalHeight = minLogicalIntervalSize.height();
+    float minIntervalWidth = minLogicalIntervalSize.width();
+
     const FloatPolygon& polygon = shapePaddingBounds();
     const FloatRect boundingBox = polygon.boundingBox();
-    if (minLogicalIntervalSize.width() > boundingBox.width())
+    if (minIntervalWidth > boundingBox.width())
         return false;
 
-    float minY = std::max(boundingBox.y(), minLogicalIntervalTop);
-    float maxY = minY + minLogicalIntervalSize.height();
+    float minY = std::max(boundingBox.y(), minIntervalTop);
+    float maxY = minY + minIntervalHeight;
 
     if (maxY > boundingBox.maxY())
         return false;
 
     Vector<const FloatPolygonEdge*> edges;
-    polygon.overlappingEdges(minLogicalIntervalTop, boundingBox.maxY(), edges);
+    polygon.overlappingEdges(minIntervalTop, boundingBox.maxY(), edges);
 
-    float dx = minLogicalIntervalSize.width() / 2;
-    float dy = minLogicalIntervalSize.height() / 2;
+    float dx = minIntervalWidth / 2;
+    float dy = minIntervalHeight / 2;
     Vector<OffsetPolygonEdge> offsetEdges;
 
     for (unsigned i = 0; i < edges.size(); ++i) {
         const FloatPolygonEdge& edge = *(edges[i]);
         const FloatPoint& vertex0 = edge.previousEdge().vertex1();
         const FloatPoint& vertex1 = edge.vertex1();
         const FloatPoint& vertex2 = edge.vertex2();
         Vector<OffsetPolygonEdge> offsetEdgeBuffer;
 
         if (vertex2.y() > vertex1.y() ? vertex2.x() >= vertex1.x() : vertex1.x() >= vertex2.x()) {
@@ skipping 13 matching lines @@
                 offsetEdgeBuffer.append(OffsetPolygonEdge(vertex1, FloatSize(-dx, dy), FloatSize(dx, dy)));
             else if (vertex2.y() >= vertex1.y() && vertex0.y() >= vertex1.y())
                 offsetEdgeBuffer.append(OffsetPolygonEdge(vertex1, FloatSize(-dx, -dy), FloatSize(dx, -dy)));
         }
 
         for (unsigned j = 0; j < offsetEdgeBuffer.size(); ++j)
             if (offsetEdgeBuffer[j].maxY() >= minY)
                 offsetEdges.append(offsetEdgeBuffer[j]);
     }
 
-    offsetEdges.append(OffsetPolygonEdge(polygon, minLogicalIntervalTop, FloatSize(0, dy)));
+    offsetEdges.append(OffsetPolygonEdge(polygon, minIntervalTop, FloatSize(0, dy)));
 
     FloatPoint offsetEdgesIntersection;
     FloatRect firstFitRect;
     bool firstFitFound = false;
 
     for (unsigned i = 0; i < offsetEdges.size() - 1; ++i) {
         for (unsigned j = i + 1; j < offsetEdges.size(); ++j) {
             if (offsetEdges[i].intersection(offsetEdges[j], offsetEdgesIntersection)) {
                 FloatPoint potentialFirstFitLocation(offsetEdgesIntersection.x() - dx, offsetEdgesIntersection.y() - dy);
                 FloatRect potentialFirstFitRect(potentialFirstFitLocation, minLogicalIntervalSize);
                 if ((offsetEdges[i].basis() == OffsetPolygonEdge::LineTop
                     || offsetEdges[j].basis() == OffsetPolygonEdge::LineTop
-                    || potentialFirstFitLocation.y() >= minLogicalIntervalTop)
+                    || potentialFirstFitLocation.y() >= minIntervalTop)
                     && (!firstFitFound || aboveOrToTheLeft(potentialFirstFitRect, firstFitRect))
                     && polygon.contains(offsetEdgesIntersection)
                     && firstFitRectInPolygon(polygon, potentialFirstFitRect, offsetEdges[i].edgeIndex(), offsetEdges[j].edgeIndex())) {
                     firstFitFound = true;
                     firstFitRect = potentialFirstFitRect;
                 }
             }
         }
     }
 
     if (firstFitFound)
-        result = firstFitRect.y();
+        result = LayoutUnit::fromFloatCeil(firstFitRect.y());
     return firstFitFound;
 }
 
 } // namespace WebCore