[CSS Exclusions] ExclusionShape bounding box methods should return LayoutRects

Source/core/rendering/exclusions/ExclusionRectangle.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 83 matching lines @@
 
 FloatRoundedRect ExclusionRectangle::shapeMarginBounds() const
 {
     if (!m_haveInitializedMarginBounds) {
         m_haveInitializedMarginBounds = true;
         m_marginBounds = m_bounds.marginBounds(shapeMargin());
     }
     return m_marginBounds;
 }
 
-void ExclusionRectangle::getExcludedIntervals(float logicalTop, float logicalHeight, SegmentList& result) const
+void ExclusionRectangle::getExcludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const
 {
     const FloatRoundedRect& bounds = shapeMarginBounds();
     if (bounds.isEmpty())
         return;
 
     float y1 = logicalTop;
-    float y2 = y1 + logicalHeight;
+    float y2 = logicalTop + logicalHeight;
 
     if (y2 < bounds.y() || y1 >= bounds.maxY())
         return;
 
     float x1 = bounds.x();
     float x2 = bounds.maxX();
 
     if (bounds.ry() > 0) {
         if (y2 < bounds.y() + bounds.ry()) {
             float yi = y2 - bounds.y() - bounds.ry();
             float xi = ellipseXIntercept(yi, bounds.rx(), bounds.ry());
             x1 = bounds.x() + bounds.rx() - xi;
             x2 = bounds.maxX() - bounds.rx() + xi;
         } else if (y1 > bounds.maxY() - bounds.ry()) {
             float yi =  y1 - (bounds.maxY() - bounds.ry());
             float xi = ellipseXIntercept(yi, bounds.rx(), bounds.ry());
             x1 = bounds.x() + bounds.rx() - xi;
             x2 = bounds.maxX() - bounds.rx() + xi;
         }
     }
 
     result.append(LineSegment(x1, x2));
 }
 
-void ExclusionRectangle::getIncludedIntervals(float logicalTop, float logicalHeight, SegmentList& result) const
+void ExclusionRectangle::getIncludedIntervals(LayoutUnit logicalTop, LayoutUnit logicalHeight, SegmentList& result) const
 {
     const FloatRoundedRect& bounds = shapePaddingBounds();
     if (bounds.isEmpty())
         return;
 
     float y1 = logicalTop;
-    float y2 = y1 + logicalHeight;
+    float y2 = logicalTop + logicalHeight;
 
     if (y1 < bounds.y() || y2 > bounds.maxY())
         return;
 
     float x1 = bounds.x();
     float x2 = bounds.maxX();
 
     if (bounds.ry() > 0) {
         bool y1InterceptsCorner = y1 < bounds.y() + bounds.ry();
         bool y2InterceptsCorner = y2 > bounds.maxY() - bounds.ry();
@@ skipping 17 matching lines @@
 
         if (y1InterceptsCorner || y2InterceptsCorner) {
             x1 = bounds.x() + bounds.rx() - xi;
             x2 = bounds.maxX() - bounds.rx() + xi;
         }
     }
 
     result.append(LineSegment(x1, x2));
 }
 
-bool ExclusionRectangle::firstIncludedIntervalLogicalTop(float minLogicalIntervalTop, const FloatSize& minLogicalIntervalSize, float& result) const
+bool ExclusionRectangle::firstIncludedIntervalLogicalTop(LayoutUnit minLogicalIntervalTop, const LayoutSize& minLogicalIntervalSize, LayoutUnit& result) const
 {
+    float minIntervalTop = minLogicalIntervalTop;
+    float minIntervalHeight = minLogicalIntervalSize.height();
+    float minIntervalWidth = minLogicalIntervalSize.width();
+
     const FloatRoundedRect& bounds = shapePaddingBounds();
-    if (bounds.isEmpty() || minLogicalIntervalSize.width() > bounds.width())
+    if (bounds.isEmpty() || minIntervalWidth > bounds.width())
         return false;
 
-    float minY = std::max(bounds.y(), minLogicalIntervalTop);
-    float maxY = minY + minLogicalIntervalSize.height();
+    float minY = std::max(bounds.y(), minIntervalTop);
+    float maxY = minY + minIntervalHeight;
 
     if (maxY > bounds.maxY())
         return false;
 
     bool intervalOverlapsMinCorner = minY < bounds.y() + bounds.ry();
     bool intervalOverlapsMaxCorner = maxY > bounds.maxY() - bounds.ry();
 
     if (!intervalOverlapsMinCorner && !intervalOverlapsMaxCorner) {
         result = minY;
         return true;
     }
 
     float centerY = bounds.y() + bounds.height() / 2;
     bool minCornerDefinesX = fabs(centerY - minY) > fabs(centerY - maxY);
-    bool intervalFitsWithinCorners = minLogicalIntervalSize.width() + 2 * bounds.rx() <= bounds.width();
-    FloatPoint cornerIntercept = bounds.cornerInterceptForWidth(minLogicalIntervalSize.width());
+    bool intervalFitsWithinCorners = minIntervalWidth + 2 * bounds.rx() <= bounds.width();
+    FloatPoint cornerIntercept = bounds.cornerInterceptForWidth(minIntervalWidth);
 
     if (intervalOverlapsMinCorner && (!intervalOverlapsMaxCorner || minCornerDefinesX)) {
         if (intervalFitsWithinCorners || bounds.y() + cornerIntercept.y() < minY) {
             result = minY;
             return true;
         }
-        if (minLogicalIntervalSize.height() < bounds.height() - (2 * cornerIntercept.y())) {
-            result = bounds.y() + cornerIntercept.y();
+        if (minIntervalHeight < bounds.height() - (2 * cornerIntercept.y())) {
+            result = LayoutUnit::fromFloatCeil(bounds.y() + cornerIntercept.y());
             return true;
         }
     }
 
     if (intervalOverlapsMaxCorner && (!intervalOverlapsMinCorner || !minCornerDefinesX)) {
-        if (intervalFitsWithinCorners || minY <=  bounds.maxY() - cornerIntercept.y() - minLogicalIntervalSize.height()) {
+        if (intervalFitsWithinCorners || minY <=  bounds.maxY() - cornerIntercept.y() - minIntervalHeight) {
             result = minY;
             return true;
         }
     }
 
     return false;
 }
 
 } // namespace WebCore