Get rid of computeFloatRectForPaintInvalidation

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 26 matching lines @@
 #include "core/rendering/svg/RenderSVGShape.h"
 #include "core/rendering/svg/RenderSVGText.h"
 #include "core/rendering/svg/RenderSVGViewportContainer.h"
 #include "core/rendering/svg/SVGResources.h"
 #include "core/rendering/svg/SVGResourcesCache.h"
 #include "core/svg/SVGElement.h"
 #include "platform/geometry/TransformState.h"
 
 namespace blink {
 
+static inline LayoutRect enclosingIntRectIfNotEmpty(const FloatRect& rect)
+{
+    if (rect.isEmpty())
+        return LayoutRect();
+    return enclosingIntRect(rect);
+}
+
 LayoutRect SVGRenderSupport::clippedOverflowRectForPaintInvalidation(const RenderObject* object, const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
     // Return early for any cases where we don't actually paint
     if (object->style()->visibility() != VISIBLE && !object->enclosingLayer()->hasVisibleContent())
         return LayoutRect();
 
     // Pass our local paint rect to computeRectForPaintInvalidation() which will
     // map to parent coords and recurse up the parent chain.
     FloatRect paintInvalidationRect = object->paintInvalidationRectInLocalCoordinates();
     paintInvalidationRect.inflate(object->style()->outlineWidth());
 
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
         // Compute accumulated SVG transform and apply to local paint rect.
         AffineTransform transform = paintInvalidationState->svgTransform() * object->localToParentTransform();
         paintInvalidationRect = transform.mapRect(paintInvalidationRect);
         // FIXME: These are quirks carried forward from RenderSVGRoot::computeFloatRectForPaintInvalidation.

[pdr., 2014/11/21 08:32:05]

This comment is no longer valid (similarly
RenderSVGRoot::clippedOverflowRectForPaintInvalidation's comment)

[fs, 2014/11/21 11:23:15]

Right. Updated.

-        LayoutRect rect;
-        if (!paintInvalidationRect.isEmpty())
-            rect = enclosingIntRect(paintInvalidationRect);
+        LayoutRect rect = enclosingIntRectIfNotEmpty(paintInvalidationRect);
         // Offset by SVG root paint offset and apply clipping as needed.
         rect.move(paintInvalidationState->paintOffset());
         if (paintInvalidationState->isClipped())
             rect.intersect(paintInvalidationState->clipRect());
         return rect;
     }
 
-    object->computeFloatRectForPaintInvalidation(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
-    return enclosingLayoutRect(paintInvalidationRect);
+    LayoutRect rect;
+    const RenderSVGRoot* svgRoot = mapRectToSVGRootForPaintInvalidation(object, paintInvalidationRect, rect);
+    svgRoot->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
+    return rect;
 }
 
-void SVGRenderSupport::computeFloatRectForPaintInvalidation(const RenderObject* object, const RenderLayerModelObject* paintInvalidationContainer, FloatRect& paintInvalidationRect, const PaintInvalidationState* paintInvalidationState)
+const RenderSVGRoot* SVGRenderSupport::mapRectToSVGRootForPaintInvalidation(const RenderObject* object, const FloatRect& localPaintInvalidationRect, LayoutRect& rect)
 {
-    // Translate to coords in our parent renderer, and then call computeFloatRectForPaintInvalidation() on our parent.
-    paintInvalidationRect = object->localToParentTransform().mapRect(paintInvalidationRect);
-    object->parent()->computeFloatRectForPaintInvalidation(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
+    ASSERT(object && object->isSVG() && !object->isSVGRoot());
+
+    FloatRect paintInvalidationRect = localPaintInvalidationRect;
+    // FIXME: Building the transform to the SVG root border box and then doing
+    // mapRect() with that would be slightly more efficient, but requires some
+    // additions to AffineTransform (preMultiply, preTranslate) to avoid
+    // excessive copying and to get a similar fast-path for translations.
+    const RenderObject* parent = object;
+    do {
+        paintInvalidationRect = parent->localToParentTransform().mapRect(paintInvalidationRect);
+        parent = parent->parent();
+    } while (!parent->isSVGRoot());
+
+    const RenderSVGRoot* svgRoot = toRenderSVGRoot(parent);
+
+    paintInvalidationRect = svgRoot->localToBorderBoxTransform().mapRect(paintInvalidationRect);
+    rect = enclosingIntRectIfNotEmpty(paintInvalidationRect);
+    return svgRoot;
 }
 
 void SVGRenderSupport::mapLocalToContainer(const RenderObject* object, const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, bool* wasFixed, const PaintInvalidationState* paintInvalidationState)
 {
     transformState.applyTransform(object->localToParentTransform());
 
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
         // |svgTransform| contains localToBorderBoxTransform mentioned below.
         transformState.applyTransform(paintInvalidationState->svgTransform());
         transformState.move(paintInvalidationState->paintOffset());
@@ skipping 330 matching lines @@
 }
 
 bool SVGRenderSupport::isRenderableTextNode(const RenderObject* object)
 {
     ASSERT(object->isText());
     // <br> is marked as text, but is not handled by the SVG rendering code-path.
     return object->isSVGInlineText() && !toRenderSVGInlineText(object)->hasEmptyText();
 }
 
 }