[CSS Exclusions] ExclusionShape bounding box methods should return LayoutRects

Source/core/rendering/exclusions/ExclusionShape.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 72 matching lines @@
     return point.transposedPoint();
 }
 
 static inline FloatSize physicalSizeToLogical(const FloatSize& size, WritingMode writingMode)
 {
     if (isHorizontalWritingMode(writingMode))
         return size;
     return size.transposedSize();
 }
 
-PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, float logicalBoxWidth, float logicalBoxHeight, WritingMode writingMode, Length margin, Length padding)
+PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, const LayoutSize& logicalBoxSize, WritingMode writingMode, Length margin, Length padding)
 {
     ASSERT(basicShape);
 
     bool horizontalWritingMode = isHorizontalWritingMode(writingMode);
-    float boxWidth = horizontalWritingMode ? logicalBoxWidth : logicalBoxHeight;
-    float boxHeight = horizontalWritingMode ? logicalBoxHeight : logicalBoxWidth;
+    float boxWidth = horizontalWritingMode ? logicalBoxSize.width() : logicalBoxSize.height();
+    float boxHeight = horizontalWritingMode ? logicalBoxSize.height() : logicalBoxSize.width();
     OwnPtr<ExclusionShape> exclusionShape;
 
     switch (basicShape->type()) {
 
     case BasicShape::BASIC_SHAPE_RECTANGLE: {
         const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
         FloatRect bounds(
             floatValueForLength(rectangle->x(), boxWidth),
             floatValueForLength(rectangle->y(), boxHeight),
             floatValueForLength(rectangle->width(), boxWidth),
             floatValueForLength(rectangle->height(), boxHeight));
         Length radiusXLength = rectangle->cornerRadiusX();
         Length radiusYLength = rectangle->cornerRadiusY();
         FloatSize cornerRadii(
             radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth),
             radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight));
-        FloatRect logicalBounds = physicalRectToLogical(bounds, logicalBoxHeight, writingMode);
+        FloatRect logicalBounds = physicalRectToLogical(bounds, logicalBoxSize.height(), writingMode);
 
         exclusionShape = createExclusionRectangle(logicalBounds, physicalSizeToLogical(cornerRadii, writingMode));
         break;
     }
 
     case BasicShape::BASIC_SHAPE_CIRCLE: {
         const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
         float centerX = floatValueForLength(circle->centerX(), boxWidth);
         float centerY = floatValueForLength(circle->centerY(), boxHeight);
         float radius = floatValueForLength(circle->radius(), std::min(boxHeight, boxWidth));
-        FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxHeight, writingMode);
+        FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxSize.height(), writingMode);
 
         exclusionShape = createExclusionCircle(logicalCenter, radius);
         break;
     }
 
     case BasicShape::BASIC_SHAPE_ELLIPSE: {
         const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
         float centerX = floatValueForLength(ellipse->centerX(), boxWidth);
         float centerY = floatValueForLength(ellipse->centerY(), boxHeight);
         float radiusX = floatValueForLength(ellipse->radiusX(), boxWidth);
         float radiusY = floatValueForLength(ellipse->radiusY(), boxHeight);
-        FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxHeight, writingMode);
+        FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxSize.height(), writingMode);
         FloatSize logicalRadii = physicalSizeToLogical(FloatSize(radiusX, radiusY), writingMode);
 
         exclusionShape = createExclusionEllipse(logicalCenter, logicalRadii);
         break;
     }
 
     case BasicShape::BASIC_SHAPE_POLYGON: {
         const BasicShapePolygon* polygon = static_cast<const BasicShapePolygon*>(basicShape);
         const Vector<Length>& values = polygon->values();
         size_t valuesSize = values.size();
         ASSERT(!(valuesSize % 2));
         OwnPtr<Vector<FloatPoint> > vertices = adoptPtr(new Vector<FloatPoint>(valuesSize / 2));
         for (unsigned i = 0; i < valuesSize; i += 2) {
             FloatPoint vertex(
                 floatValueForLength(values.at(i), boxWidth),
                 floatValueForLength(values.at(i + 1), boxHeight));
-            (*vertices)[i / 2] = physicalPointToLogical(vertex, logicalBoxHeight, writingMode);
+            (*vertices)[i / 2] = physicalPointToLogical(vertex, logicalBoxSize.height(), writingMode);
         }
         exclusionShape = createExclusionPolygon(vertices.release(), polygon->windRule());
         break;
     }
 
     default:
         ASSERT_NOT_REACHED();
     }
 
-    exclusionShape->m_logicalBoxWidth = logicalBoxWidth;
-    exclusionShape->m_logicalBoxHeight = logicalBoxHeight;
     exclusionShape->m_writingMode = writingMode;
     exclusionShape->m_margin = floatValueForLength(margin, 0);
     exclusionShape->m_padding = floatValueForLength(padding, 0);
 
     return exclusionShape.release();
 }
 
 } // namespace WebCore