Unify content transformation calculations for SVG clip paths

Source/core/layout/svg/LayoutSVGResourceClipper.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  * Copyright (C) 2011 Dirk Schulze <krit@webkit.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 48 matching lines @@
     m_clipBoundaries = FloatRect();
     markAllClientsForInvalidation(markForInvalidation ? LayoutAndBoundariesInvalidation : ParentOnlyInvalidation);
 }
 
 void LayoutSVGResourceClipper::removeClientFromCache(LayoutObject* client, bool markForInvalidation)
 {
     ASSERT(client);
     markClientForInvalidation(client, markForInvalidation ? BoundariesInvalidation : ParentOnlyInvalidation);
 }
 
+AffineTransform LayoutSVGResourceClipper::calculateContentTransformation(const LayoutObject* target, const FloatRect& targetBoundingBox)

[fs, 2015/06/16 09:30:15]

const?

+{
+    AffineTransform transform = toSVGClipPathElement(element())->calculateAnimatedLocalTransform();
+
+    // When drawing a clip for non-SVG elements, the CTM does not include the zoom factor.
+    // In this case, we need to apply the zoom scale explicitly - but only for clips with
+    // userSpaceOnUse units (the zoom is accounted for objectBoundingBox-resolved lengths).
+    if (target && !target->isSVG() && clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE)
+        transform.scale(style()->effectiveZoom());

[fs, 2015/06/16 09:30:15]

Shouldn't this apply before 'transform'?

+
+    if (clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
+        transform.translate(targetBoundingBox.x(), targetBoundingBox.y());
+        transform.scaleNonUniform(targetBoundingBox.width(), targetBoundingBox.height());
+    }
+
+    return transform;
+}
+
 bool LayoutSVGResourceClipper::tryPathOnlyClipping(const LayoutObject& layoutObject, GraphicsContext* context,
-    const AffineTransform& animatedLocalTransform, const FloatRect& objectBoundingBox) {
+    const AffineTransform& contentTransformation) {
     // If the current clip-path gets clipped itself, we have to fallback to masking.
     if (!style()->svgStyle().clipperResource().isEmpty())
         return false;
 
     Path clipPath;
 
     for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element()); childElement; childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
         LayoutObject* childLayoutObject = childElement->layoutObject();
         if (!childLayoutObject)
             continue;
@@ skipping 23 matching lines @@
             styled->toClipPath(subPath);
             if (!clipPath.unionPath(subPath))
                 return false;
         } else {
             return false;
         }
     }
 
     // We are able to represent the clip as a path. Continue with direct clipping,
     // and transform the content to userspace if necessary.
-    if (clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
-        AffineTransform transform;
-        transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
-        transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
-        clipPath.transform(transform);
-    }
-
-    // Transform path by animatedLocalTransform.
-    clipPath.transform(animatedLocalTransform);
+    clipPath.transform(contentTransformation);
 
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
         if (!context->displayItemList()->displayItemConstructionIsDisabled())
             context->displayItemList()->add(BeginClipPathDisplayItem::create(layoutObject, clipPath));
     } else {
         BeginClipPathDisplayItem clipPathDisplayItem(layoutObject, clipPath);
         clipPathDisplayItem.replay(*context);
     }
 
     return true;
 }
 
-PassRefPtr<const SkPicture> LayoutSVGResourceClipper::createContentPicture(AffineTransform& contentTransformation, const FloatRect& targetBoundingBox,
-    GraphicsContext* context)
+PassRefPtr<const SkPicture> LayoutSVGResourceClipper::createContentPicture(const AffineTransform& contentTransformation, GraphicsContext* context)
 {
     ASSERT(frame());
 
-    if (clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
-        contentTransformation.translate(targetBoundingBox.x(), targetBoundingBox.y());
-        contentTransformation.scaleNonUniform(targetBoundingBox.width(), targetBoundingBox.height());
-    }
-
     if (m_clipContentPicture)
         return m_clipContentPicture;
 
     SubtreeContentTransformScope contentTransformScope(contentTransformation);
 
     // Using strokeBoundingBox (instead of paintInvalidationRectInLocalCoordinates) to avoid the intersection
     // with local clips/mask, which may yield incorrect results when mixing objectBoundingBox and
     // userSpaceOnUse units (http://crbug.com/294900).
     FloatRect bounds = strokeBoundingBox();
 
@@ skipping 28 matching lines @@
         // - fill is set to the initial fill paint server (solid, black)
         // - stroke is set to the initial stroke paint server (none)
         PaintInfo info(&pictureBuilder.context(), LayoutRect::infiniteIntRect(), PaintPhaseForeground, PaintBehaviorRenderingClipPathAsMask);
         layoutObject->paint(info, IntPoint());
     }
 
     m_clipContentPicture = pictureBuilder.endRecording();
     return m_clipContentPicture;
 }
 
-void LayoutSVGResourceClipper::calculateClipContentPaintInvalidationRect()
+void LayoutSVGResourceClipper::calculateClipContentPaintInvalidationRect(const LayoutObject* object)
 {
     // This is a rough heuristic to appraise the clip size and doesn't consider clip on clip.
     for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element()); childElement; childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
         LayoutObject* layoutObject = childElement->layoutObject();
         if (!layoutObject)
             continue;
         if (!layoutObject->isSVGShape() && !layoutObject->isSVGText() && !isSVGUseElement(*childElement))
             continue;
         const ComputedStyle* style = layoutObject->style();
         if (!style || style->display() == NONE || style->visibility() != VISIBLE)
             continue;
         m_clipBoundaries.unite(layoutObject->localToParentTransform().mapRect(layoutObject->paintInvalidationRectInLocalCoordinates()));
     }
-    m_clipBoundaries = toSVGClipPathElement(element())->calculateAnimatedLocalTransform().mapRect(m_clipBoundaries);
+
+    const AffineTransform& contentTransformation = calculateContentTransformation(object, object->objectBoundingBox());
+    m_clipBoundaries = contentTransformation.mapRect(m_clipBoundaries);

[fs, 2015/06/16 09:30:15]

This makes m_clipBoundaries depend on a certain client - the previous
formulation was only dependent on the clip path itself. Maybe just sink this
part out of the function, and let m_clipBoundaries be in the local coordinate
space of the clipPath instead?

 }
 
 bool LayoutSVGResourceClipper::hitTestClipContent(const FloatRect& objectBoundingBox, const FloatPoint& nodeAtPoint)
 {
     FloatPoint point = nodeAtPoint;
     if (!SVGLayoutSupport::pointInClippingArea(this, point))
         return false;
 
-    if (clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
-        AffineTransform transform;
-        transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
-        transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
-        point = transform.inverse().mapPoint(point);
-    }
-
-    AffineTransform animatedLocalTransform = toSVGClipPathElement(element())->calculateAnimatedLocalTransform();
-    if (!animatedLocalTransform.isInvertible())

[fs, 2015/06/16 09:30:15]

This got dropped.

-        return false;
-
-    point = animatedLocalTransform.inverse().mapPoint(point);
+    AffineTransform contentTransformation = calculateContentTransformation(nullptr, objectBoundingBox);
+    contentTransformation.inverse().mapPoint(point);

[fs, 2015/06/16 09:30:15]

point = ...

 
     for (SVGElement* childElement = Traversal<SVGElement>::firstChild(*element()); childElement; childElement = Traversal<SVGElement>::nextSibling(*childElement)) {
         LayoutObject* layoutObject = childElement->layoutObject();
         if (!layoutObject)
             continue;
         if (!layoutObject->isSVGShape() && !layoutObject->isSVGText() && !isSVGUseElement(*childElement))
             continue;
         IntPoint hitPoint;
         HitTestResult result(HitTestRequest::SVGClipContent, hitPoint);
         if (layoutObject->nodeAtFloatPoint(result, point, HitTestForeground))
             return true;
     }
 
     return false;
 }
 
 FloatRect LayoutSVGResourceClipper::resourceBoundingBox(const LayoutObject* object)
 {
     // Resource was not layouted yet. Give back the boundingBox of the object.
     if (selfNeedsLayout())
         return object->objectBoundingBox();
 
     if (m_clipBoundaries.isEmpty())
-        calculateClipContentPaintInvalidationRect();
-
-    if (clipPathUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
-        FloatRect objectBoundingBox = object->objectBoundingBox();
-        AffineTransform transform;
-        transform.translate(objectBoundingBox.x(), objectBoundingBox.y());
-        transform.scaleNonUniform(objectBoundingBox.width(), objectBoundingBox.height());
-        return transform.mapRect(m_clipBoundaries);
-    }
+        calculateClipContentPaintInvalidationRect(object);
 
     return m_clipBoundaries;
 }
 
 }