Remove the SVG paint culling optimization

Source/core/rendering/svg/SVGRenderSupport.cpp

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 127 matching lines @@
     if (parent->isSVGRoot()) {
         TransformationMatrix matrix(object->localToParentTransform());
         matrix.multiply(toRenderSVGRoot(parent)->localToBorderBoxTransform());
         geometryMap.push(object, matrix);
     } else
         geometryMap.push(object, object->localToParentTransform());
 
     return parent;
 }
 
+const AffineTransform SVGRenderSupport::transformToRootBorderBox(const RenderObject& renderer, const AffineTransform& localTransform)
+{
+    AffineTransform transform = localTransform;
+    RenderObject* next = renderer.parent();
+    while (next && !next->isSVGRoot()) {

[pdr., 2014/12/15 05:02:21]

linear algebra 101: instead of inverting each matrix, we can post-multiply them
in reverse and invert the result.

[fs, 2014/12/15 10:28:16]

If next is/ends up as null, you'll be toast anyway.

[pdr., 2014/12/18 22:22:40]

Replaced with an assert.

+        transform = next->localToParentTransform() * transform;

[fs, 2014/12/15 10:28:16]

(Last I checked a sequence like this generated horrible code... lots of copies.
Wanted (DoA - preferably A): multiply-from-the-left method on AffineTransform.)

[pdr., 2014/12/16 06:29:56]

It does indeed, we should add this to AffineTransform next time we need it.

[pdr., 2014/12/18 22:22:40]

I looked into this and premultiply doesn't seem as expensive as I remembered. We
do create a copy for each walk up the parent chain but AffineTransform is cheap
to copy. I did file http://crbug.com/443775 for some other AffineTransform
optimization ideas though.

[fs, 2014/12/19 11:46:00]

Moves are cheap execution-wise, but cost in terms of decoder resources (and
code-size).

+        next = next->parent();
+    }
+    transform = toRenderSVGRoot(next)->localToBorderBoxTransform() * transform;
+
+    if (!transform.isInvertible())

[fs, 2014/12/15 10:28:16]

Maybe just return |transform| instead of its inverse? The name doesn't really
help imply one or the other; see also issue at callsite. Also, IIRC inverse()
gives you this behavior by default (det == 0 => identify else ...)

+        return AffineTransform();
+
+    return transform.inverse();
+}
+
 // Update a bounding box taking into account the validity of the other bounding box.
 inline void SVGRenderSupport::updateObjectBoundingBox(FloatRect& objectBoundingBox, bool& objectBoundingBoxValid, RenderObject* other, FloatRect otherBoundingBox)
 {
     bool otherValid = other->isSVGContainer() ? toRenderSVGContainer(other)->isObjectBoundingBoxValid() : true;
     if (!otherValid)
         return;
 
     if (!objectBoundingBoxValid) {
         objectBoundingBox = otherBoundingBox;
         objectBoundingBoxValid = true;
@@ skipping 22 matching lines @@
 
         const AffineTransform& transform = current->localToParentTransform();
         updateObjectBoundingBox(objectBoundingBox, objectBoundingBoxValid, current,
             transform.mapRect(current->objectBoundingBox()));
         strokeBoundingBox.unite(transform.mapRect(current->paintInvalidationRectInLocalCoordinates()));
     }
 
     paintInvalidationBoundingBox = strokeBoundingBox;
 }
 
-bool SVGRenderSupport::paintInfoIntersectsPaintInvalidationRect(const FloatRect& localPaintInvalidationRect, const AffineTransform& localTransform, const PaintInfo& paintInfo)
-{
-    return localTransform.mapRect(localPaintInvalidationRect).intersects(paintInfo.rect);
-}
-
 const RenderSVGRoot* SVGRenderSupport::findTreeRootObject(const RenderObject* start)
 {
     while (start && !start->isSVGRoot())
         start = start->parent();
 
     ASSERT(start);
     ASSERT(start->isSVGRoot());
     return toRenderSVGRoot(start);
 }
 
@@ skipping 262 matching lines @@
         return false;
     return willIsolateBlendingDescendantsForStyle(object->style());
 }
 
 bool SVGRenderSupport::isIsolationRequired(const RenderObject* object)
 {
     return willIsolateBlendingDescendantsForObject(object) && object->hasNonIsolatedBlendingDescendants();
 }
 
 }