Fix paint invalidation for SVG with outline-offset

Source/core/layout/svg/SVGLayoutSupport.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 33 matching lines @@
 
 namespace blink {
 
 static inline LayoutRect enclosingIntRectIfNotEmpty(const FloatRect& rect)
 {
     if (rect.isEmpty())
         return LayoutRect();
     return LayoutRect(enclosingIntRect(rect));
 }
 
-LayoutRect SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(const LayoutObject* object, const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
+static void inflateWithOutlineIfNeeded(FloatRect& paintInvalidationRect, const ComputedStyle& style)
+{
+    if (!style.hasOutline())
+        return;
+    int outlineSize = 0;
+    if (style.outlineStyleIsAuto())
+        outlineSize = GraphicsContext::focusRingOutsetExtent(style.outlineOffset(), style.outlineWidth());
+    else
+        outlineSize = style.outlineSize();
+    paintInvalidationRect.inflate(outlineSize);
+}
+
+LayoutRect SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(const LayoutObject& object, const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
     // Return early for any cases where we don't actually paint
-    if (object->style()->visibility() != VISIBLE && !object->enclosingLayer()->hasVisibleContent())
+    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());
+    FloatRect paintInvalidationRect = object.paintInvalidationRectInLocalCoordinates();
+    inflateWithOutlineIfNeeded(paintInvalidationRect, object.styleRef());
 
     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);
+        AffineTransform transform = paintInvalidationState->svgTransform() * object.localToParentTransform();
         // FIXME: These are quirks carried forward from the old paint invalidation infrastructure.
-        LayoutRect rect = enclosingIntRectIfNotEmpty(paintInvalidationRect);
+        LayoutRect rect = enclosingIntRectIfNotEmpty(transform.mapRect(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;
     }
 
     LayoutRect rect;
     const LayoutSVGRoot& svgRoot = mapRectToSVGRootForPaintInvalidation(object, paintInvalidationRect, rect);
     svgRoot.mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
     return rect;
 }
 
-const LayoutSVGRoot& SVGLayoutSupport::mapRectToSVGRootForPaintInvalidation(const LayoutObject* object, const FloatRect& localPaintInvalidationRect, LayoutRect& rect)
+const LayoutSVGRoot& SVGLayoutSupport::mapRectToSVGRootForPaintInvalidation(const LayoutObject& object, const FloatRect& localPaintInvalidationRect, LayoutRect& rect)
 {
-    ASSERT(object && object->isSVG() && !object->isSVGRoot());
+    ASSERT(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 LayoutObject* parent = object;
+    const LayoutObject* parent = &object;
     do {
         paintInvalidationRect = parent->localToParentTransform().mapRect(paintInvalidationRect);
         parent = parent->parent();
     } while (!parent->isSVGRoot());
 
     const LayoutSVGRoot& svgRoot = toLayoutSVGRoot(*parent);
 
     paintInvalidationRect = svgRoot.localToBorderBoxTransform().mapRect(paintInvalidationRect);
     rect = enclosingIntRectIfNotEmpty(paintInvalidationRect);
     return svgRoot;
@@ skipping 353 matching lines @@
 
     // FIXME: trying to compute a device space transform at record time is wrong. All clients
     // should be updated to avoid relying on this information, and the method should be removed.
     AffineTransform ctm = deprecatedCalculateTransformToLayer(layoutObject) * currentContentTransformation();
     ctm.scale(layoutObject->document().frameHost()->deviceScaleFactor());
 
     return narrowPrecisionToFloat(sqrt((pow(ctm.xScale(), 2) + pow(ctm.yScale(), 2)) / 2));
 }
 
 }