Reduce how often LayoutSVGShape::updateShapeFromElement is called

Source/core/layout/svg/LayoutSVGShape.cpp

 /*
  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2005, 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
  * Copyright (C) 2011 Renata Hodovan <reni@webkit.org>
  * Copyright (C) 2011 University of Szeged
@@ skipping 38 matching lines @@
     , m_needsBoundariesUpdate(false) // Default is false, the cached rects are empty from the beginning.
     , m_needsShapeUpdate(true) // Default is true, so we grab a Path object once from SVGGeometryElement.
     , m_needsTransformUpdate(true) // Default is true, so we grab a AffineTransform object once from SVGGeometryElement.
 {
 }
 
 LayoutSVGShape::~LayoutSVGShape()
 {
 }
 
-void LayoutSVGShape::createPath()
+void LayoutSVGShape::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
+{
+    if (diff.needsFullLayout()) {
+        if (oldStyle && (oldStyle->svgStyle().vectorEffect() != style()->svgStyle().vectorEffect()))
+            setNeedsShapeUpdate();
+    }
+
+    // LayoutSVGModelObject will take care of calling clientStyleChanged.
+    LayoutSVGModelObject::styleDidChange(diff, oldStyle);
+}
+
+void LayoutSVGShape::updateShapeFromElement()
 {
     if (!m_path)
         m_path = adoptPtr(new Path());
     *m_path = toSVGGeometryElement(element())->asPath();
 }
 
-void LayoutSVGShape::updateShapeFromElement()
+void LayoutSVGShape::updateStrokeAndFillBoundingBoxes()
 {
-    createPath();
+    m_fillBoundingBox = path().boundingRect();
 
-    m_fillBoundingBox = calculateObjectBoundingBox();
-    m_strokeBoundingBox = calculateStrokeBoundingBox();
+    m_strokeBoundingBox = m_fillBoundingBox;
+    if (style()->svgStyle().hasStroke()) {
+        StrokeData strokeData;
+        SVGLayoutSupport::applyStrokeStyleToStrokeData(strokeData, styleRef(), *this);
+        if (hasNonScalingStroke()) {
+            AffineTransform nonScalingTransform = nonScalingStrokeTransform();
+            if (nonScalingTransform.isInvertible()) {
+                Path* usePath = nonScalingStrokePath(m_path.get(), nonScalingTransform);
+                FloatRect strokeBoundingRect = usePath->strokeBoundingRect(strokeData);
+                strokeBoundingRect = nonScalingTransform.inverse().mapRect(strokeBoundingRect);
+                m_strokeBoundingBox.unite(strokeBoundingRect);
+            }
+        } else {
+            m_strokeBoundingBox.unite(path().strokeBoundingRect(strokeData));
+        }
+    }
 }
 
 FloatRect LayoutSVGShape::hitTestStrokeBoundingBox() const
 {
     if (style()->svgStyle().hasStroke())
         return m_strokeBoundingBox;
 
     // Implementation of http://dev.w3.org/fxtf/css-masking-1/#compute-stroke-bounding-box
     // for the <rect> / <ellipse> / <circle> case except that we ignore whether
     // the stroke is none.
@@ skipping 63 matching lines @@
     } else {
         m_localTransform = 0;
     }
 }
 
 void LayoutSVGShape::layout()
 {
     bool updateCachedBoundariesInParents = false;
     LayoutAnalyzer::Scope analyzer(*this);
 
-    if (m_needsShapeUpdate || m_needsBoundariesUpdate) {
+    if (m_needsBoundariesUpdate && toSVGGeometryElement(element())->selfHasRelativeLengths())

[fs, 2015/06/16 10:54:02]

I think this needs to consider the "new" geometric properties ('x', 'y, etc) -
maybe just blanket-compare SVGComputedStyle::layout in
LayoutSVGShape::styleDidChange? (The we'd almost be to drop this bit too -
right?)

[pdr., 2015/06/17 03:50:49]

I think we can just check for the exact property changes we need deeper in
LayoutSVG{Rect,Ellipse}::styleDidChange. I've done this in the latest patchset
and removed this if statement.

+        m_needsShapeUpdate = true;
+
+    if (m_needsShapeUpdate)
         updateShapeFromElement();
-        m_needsShapeUpdate = false;
+
+    if (m_needsBoundariesUpdate || m_needsShapeUpdate) {
+        updateStrokeAndFillBoundingBoxes();
         updatePaintInvalidationBoundingBox();
         m_needsBoundariesUpdate = false;
+        m_needsShapeUpdate = false;
         updateCachedBoundariesInParents = true;
     }
 
     if (m_needsTransformUpdate) {
         updateLocalTransform();
         m_needsTransformUpdate = false;
         updateCachedBoundariesInParents = true;
     }
 
     // Invalidate all resources of this client if our layout changed.
@@ skipping 64 matching lines @@
         if (request.svgClipContent())
             fillRule = svgStyle.clipRule();
         if ((hitRules.canHitBoundingBox && objectBoundingBox().contains(localPoint))
             || (hitRules.canHitStroke && (svgStyle.hasStroke() || !hitRules.requireStroke) && strokeContains(localPoint, hitRules.requireStroke))
             || (hitRules.canHitFill && (svgStyle.hasFill() || !hitRules.requireFill) && fillContains(localPoint, hitRules.requireFill, fillRule)))
             return true;
     }
     return false;
 }
 
-FloatRect LayoutSVGShape::calculateObjectBoundingBox() const
-{
-    return path().boundingRect();
-}
-
-FloatRect LayoutSVGShape::calculateStrokeBoundingBox() const
-{
-    ASSERT(m_path);
-    FloatRect strokeBoundingBox = m_fillBoundingBox;
-
-    if (style()->svgStyle().hasStroke()) {
-        StrokeData strokeData;
-        SVGLayoutSupport::applyStrokeStyleToStrokeData(strokeData, styleRef(), *this);
-        if (hasNonScalingStroke()) {
-            AffineTransform nonScalingTransform = nonScalingStrokeTransform();
-            if (nonScalingTransform.isInvertible()) {
-                Path* usePath = nonScalingStrokePath(m_path.get(), nonScalingTransform);
-                FloatRect strokeBoundingRect = usePath->strokeBoundingRect(strokeData);
-                strokeBoundingRect = nonScalingTransform.inverse().mapRect(strokeBoundingRect);
-                strokeBoundingBox.unite(strokeBoundingRect);
-            }
-        } else {
-            strokeBoundingBox.unite(path().strokeBoundingRect(strokeData));
-        }
-    }
-
-    return strokeBoundingBox;
-}
-
 void LayoutSVGShape::updatePaintInvalidationBoundingBox()
 {
     m_paintInvalidationBoundingBox = strokeBoundingBox();
     if (strokeWidth() < 1.0f && !m_paintInvalidationBoundingBox.isEmpty())
         m_paintInvalidationBoundingBox.inflate(1);
     SVGLayoutSupport::intersectPaintInvalidationRectWithResources(this, m_paintInvalidationBoundingBox);
 }
 
 float LayoutSVGShape::strokeWidth() const
 {
     SVGLengthContext lengthContext(element());
     return lengthContext.valueForLength(style()->svgStyle().strokeWidth());
 }
 
 }