Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / rendering / svg / RenderSVGRect.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 120c132..abc9fd3
  */
 
 #include "config.h"
-
-#if ENABLE(SVG)
 #include "RenderSVGRect.h"
 
 #include "SVGNames.h"
-#include "SVGRectElement.h"
-#include <wtf/Platform.h>
 
 namespace WebCore {
 
-RenderSVGRect::RenderSVGRect(SVGRectElement* node)
-    : RenderSVGShape(node)
+RenderSVGRect::RenderSVGRect(SVGRectElement& element, Ref<RenderStyle>&& style)
+    : RenderSVGShape(element, WTFMove(style))
     , m_usePathFallback(false)
 {
 }
@@ -46,66 +42,62 @@ RenderSVGRect::~RenderSVGRect()
 {
 }
 
-void RenderSVGRect::createShape()
+SVGRectElement& RenderSVGRect::rectElement() const
+{
+    return downcast<SVGRectElement>(RenderSVGShape::graphicsElement());
+}
+
+void RenderSVGRect::updateShapeFromElement()
 {
     // Before creating a new object we need to clear the cached bounding box
     // to avoid using garbage.
-    m_boundingBox = FloatRect();
+    m_fillBoundingBox = FloatRect();
     m_innerStrokeRect = FloatRect();
     m_outerStrokeRect = FloatRect();
-    SVGRectElement* rect = static_cast<SVGRectElement*>(node());
-    ASSERT(rect);
 
-    // Fallback to RenderSVGShape if rect has rounded corners or a non-scaling stroke.
-    if (rect->hasAttribute(SVGNames::rxAttr) || rect->hasAttribute(SVGNames::ryAttr) || hasNonScalingStroke()) {
-        RenderSVGShape::createShape();
-        m_usePathFallback = true;
-        return;
-    } else
-        m_usePathFallback = false;
+    SVGLengthContext lengthContext(&rectElement());
+    FloatSize boundingBoxSize(lengthContext.valueForLength(style().width(), LengthModeWidth), lengthContext.valueForLength(style().height(), LengthModeHeight));
 
-    SVGLengthContext lengthContext(rect);
-    FloatSize boundingBoxSize(rect->width().value(lengthContext), rect->height().value(lengthContext));
-    if (boundingBoxSize.isEmpty())
+    // Element is invalid if either dimension is negative.
+    if (boundingBoxSize.width() < 0 || boundingBoxSize.height() < 0)
         return;
 
-    m_boundingBox = FloatRect(FloatPoint(rect->x().value(lengthContext), rect->y().value(lengthContext)), boundingBoxSize);
+    // Rendering enabled? Spec: "A value of zero disables rendering of the element."
+    if (!boundingBoxSize.isEmpty()) {
+        if (rectElement().rx().value(lengthContext) > 0 || rectElement().ry().value(lengthContext) > 0 || hasNonScalingStroke()) {
+            // Fall back to RenderSVGShape
+            RenderSVGShape::updateShapeFromElement();
+            m_usePathFallback = true;
+            return;
+        }
+        m_usePathFallback = false;
+    }
+
+    m_fillBoundingBox = FloatRect(FloatPoint(lengthContext.valueForLength(style().svgStyle().x(), LengthModeWidth),
+        lengthContext.valueForLength(style().svgStyle().y(), LengthModeHeight)),
+        boundingBoxSize);
 
     // To decide if the stroke contains a point we create two rects which represent the inner and
     // the outer stroke borders. A stroke contains the point, if the point is between them.
-    m_innerStrokeRect = m_boundingBox;
-    m_outerStrokeRect = m_boundingBox;
+    m_innerStrokeRect = m_fillBoundingBox;
+    m_outerStrokeRect = m_fillBoundingBox;
 
-    if (style()->svgStyle()->hasStroke()) {
+    if (style().svgStyle().hasStroke()) {
         float strokeWidth = this->strokeWidth();
         m_innerStrokeRect.inflate(-strokeWidth / 2);
         m_outerStrokeRect.inflate(strokeWidth / 2);
     }
 
-    m_strokeBoundingRect = m_outerStrokeRect;
+    m_strokeBoundingBox = m_outerStrokeRect;
 
 #if USE(CG)
     // CoreGraphics can inflate the stroke by 1px when drawing a rectangle with antialiasing disabled at non-integer coordinates, we need to compensate.
-    if (style()->svgStyle()->shapeRendering() == SR_CRISPEDGES)
-        m_strokeBoundingRect.inflate(1);
+    if (style().svgStyle().shapeRendering() == SR_CRISPEDGES)
+        m_strokeBoundingBox.inflate(1);
 #endif
 }
 
-FloatRect RenderSVGRect::objectBoundingBox() const
-{
-    if (m_usePathFallback)
-        return RenderSVGShape::objectBoundingBox();
-    return m_boundingBox;
-}
-
-FloatRect RenderSVGRect::strokeBoundingBox() const
-{
-    if (m_usePathFallback)
-        return RenderSVGShape::strokeBoundingBox();
-    return m_strokeBoundingRect;
-}
-
-void RenderSVGRect::fillShape(GraphicsContext* context) const
+void RenderSVGRect::fillShape(GraphicsContext& context) const
 {
     if (m_usePathFallback) {
         RenderSVGShape::fillShape(context);
@@ -117,20 +109,20 @@ void RenderSVGRect::fillShape(GraphicsContext* context) const
     // shadow drawing method, which draws an extra shadow.
     // This is a workaround for switching off the extra shadow.
     // https://bugs.webkit.org/show_bug.cgi?id=68899
-    if (context->hasShadow()) {
-        GraphicsContextStateSaver stateSaver(*context);
-        context->clearShadow();
-        context->fillRect(m_boundingBox);
+    if (context.hasShadow()) {
+        GraphicsContextStateSaver stateSaver(context);
+        context.clearShadow();
+        context.fillRect(m_fillBoundingBox);
         return;
     }
 #endif
 
-    context->fillRect(m_boundingBox);
+    context.fillRect(m_fillBoundingBox);
 }
 
-void RenderSVGRect::strokeShape(GraphicsContext* context) const
+void RenderSVGRect::strokeShape(GraphicsContext& context) const
 {
-    if (!style()->svgStyle()->hasVisibleStroke())
+    if (!style().svgStyle().hasVisibleStroke())
         return;
 
     if (m_usePathFallback) {
@@ -138,7 +130,7 @@ void RenderSVGRect::strokeShape(GraphicsContext* context) const
         return;
     }
 
-    context->strokeRect(m_boundingBox, strokeWidth());
+    context.strokeRect(m_fillBoundingBox, strokeWidth());
 }
 
 bool RenderSVGRect::shapeDependentStrokeContains(const FloatPoint& point)
@@ -147,7 +139,7 @@ bool RenderSVGRect::shapeDependentStrokeContains(const FloatPoint& point)
     // to fall back to RenderSVGShape::shapeDependentStrokeContains in these cases.
     if (m_usePathFallback || !hasSmoothStroke()) {
         if (!hasPath())
-            RenderSVGShape::createShape();
+            RenderSVGShape::updateShapeFromElement();
         return RenderSVGShape::shapeDependentStrokeContains(point);
     }
 
@@ -158,9 +150,13 @@ bool RenderSVGRect::shapeDependentFillContains(const FloatPoint& point, const Wi
 {
     if (m_usePathFallback)
         return RenderSVGShape::shapeDependentFillContains(point, fillRule);
-    return m_boundingBox.contains(point.x(), point.y());
+    return m_fillBoundingBox.contains(point.x(), point.y());
 }
 
+bool RenderSVGRect::isRenderingDisabled() const
+{
+    // A width or height of zero disables rendering for the element, and results in an empty bounding box.
+    return m_fillBoundingBox.isEmpty();
 }
 
-#endif // ENABLE(SVG)
+}