Hoist paint-server transform adaption out of preparePaintServer

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 21 matching lines @@
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/SubtreeLayoutScope.h"
 #include "core/rendering/svg/RenderSVGInlineText.h"
 #include "core/rendering/svg/RenderSVGResourceClipper.h"
 #include "core/rendering/svg/RenderSVGResourceFilter.h"
 #include "core/rendering/svg/RenderSVGResourceMasker.h"
 #include "core/rendering/svg/RenderSVGRoot.h"
 #include "core/rendering/svg/RenderSVGShape.h"
 #include "core/rendering/svg/RenderSVGText.h"
 #include "core/rendering/svg/RenderSVGViewportContainer.h"
+#include "core/rendering/svg/SVGRenderingContext.h"
 #include "core/rendering/svg/SVGResources.h"
 #include "core/rendering/svg/SVGResourcesCache.h"
 #include "core/svg/SVGElement.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/Path.h"
 
 namespace blink {
 
 LayoutRect SVGRenderSupport::clippedOverflowRectForPaintInvalidation(const RenderObject* object, const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
@@ skipping 335 matching lines @@
         return;
 
     DashArray dashArray;
     size_t length = dashes->length();
     for (size_t i = 0; i < length; ++i)
         dashArray.append(dashes->at(i)->value(lengthContext));
 
     strokeData->setLineDash(dashArray, svgStyle.strokeDashOffset()->value(lengthContext));
 }
 
+static bool shouldTransformOnTextPainting(RenderObject& renderer, AffineTransform& resourceTransform)

[fs, 2014/10/14 13:49:17]

Will remove these three functions in the next CL. Split it this way in order to
increase CL-parallelism. If https://codereview.chromium.org/654873002/ lands
smoothly I could merge the follow-up with this CL - I don't think the
combination increases the cognitive load that much. Let me know if you prefer
one way or the other.

[pdr., 2014/10/14 23:38:48]

SGTM.

Nit: The crazy comment below (... "Cmp. RenderObject.h's is*() methods.") can
probably just be removed.

+{
+    // This method should only be called for RenderObjects that deal with text rendering. Cmp. RenderObject.h's is*() methods.
+    ASSERT(renderer.isSVGText() || renderer.isSVGTextPath() || renderer.isSVGInline());
+
+    // In text drawing, the scaling part of the graphics context CTM is removed, compare SVGInlineTextBox::paintTextWithShadows.
+    // So, we use that scaling factor here, too, and then push it down to pattern or gradient space
+    // in order to keep the pattern or gradient correctly scaled.
+    float scalingFactor = SVGRenderingContext::calculateScreenFontSizeScalingFactor(&renderer);
+    if (scalingFactor == 1)
+        return false;
+    resourceTransform.scale(scalingFactor);
+    return true;
+}
+
+static AffineTransform transformOnNonScalingStroke(RenderObject& renderer, const AffineTransform& resourceTransform)
+{
+    ASSERT(renderer.isSVGShape());
+    SVGGraphicsElement* element = toSVGGraphicsElement(renderer.node());
+    AffineTransform transform = element->getScreenCTM(SVGGraphicsElement::DisallowStyleUpdate);
+    transform *= resourceTransform;
+    return transform;
+}
+
+static AffineTransform computeResourceSpaceTransform(RenderObject& renderer, const SVGRenderStyle& svgStyle, RenderSVGResourceModeFlags resourceModeFlags)
+{
+    AffineTransform computedSpaceTransform;
+    if (resourceModeFlags & ApplyToTextMode) {
+        // Depending on the font scaling factor, we may need to apply an
+        // additional transform (scale-factor) to the paintserver, since text
+        // painting removes the scale factor from the context. (See
+        // SVGInlineTextBoxPainter::paintTextWithShadows.)
+        AffineTransform additionalTextTransformation;
+        if (shouldTransformOnTextPainting(renderer, additionalTextTransformation))
+            computedSpaceTransform = additionalTextTransformation;
+    }
+    if (resourceModeFlags & ApplyToStrokeMode) {
+        // Non-scaling stroke needs to reset the transform back to the host transform.
+        if (renderer.isSVGShape() && svgStyle.vectorEffect() == VE_NON_SCALING_STROKE)
+            computedSpaceTransform = transformOnNonScalingStroke(renderer, computedSpaceTransform);
+    }
+    return computedSpaceTransform;
+}
+
 bool SVGRenderSupport::updateGraphicsContext(GraphicsContextStateSaver& stateSaver, RenderStyle* style, RenderObject& renderer, unsigned resourceModeFlags)
 {
     ASSERT(style);
 
     RenderSVGResourceMode resourceMode = static_cast<RenderSVGResourceMode>(resourceModeFlags & (ApplyToFillMode | ApplyToStrokeMode));
     ASSERT(resourceMode == ApplyToFillMode || resourceMode == ApplyToStrokeMode);
 
     GraphicsContext* context = stateSaver.context();
     if (isRenderingClipPathAsMaskImage(renderer)) {
         if (resourceMode == ApplyToStrokeMode)
             return false;
         context->setAlphaAsFloat(1);
         context->setFillColor(SVGRenderStyle::initialFillPaintColor());
         return true;
     }
 
-    SVGPaintServer paintServer = SVGPaintServer::requestForRenderer(renderer, style, resourceModeFlags);
+    SVGPaintServer paintServer = SVGPaintServer::requestForRenderer(renderer, style, resourceMode);
     if (!paintServer.isValid())
         return false;
-    paintServer.apply(*context, resourceMode, &stateSaver);
 
     const SVGRenderStyle& svgStyle = style->svgStyle();
 
+    if (paintServer.isTransformDependent())
+        paintServer.prependTransform(computeResourceSpaceTransform(renderer, svgStyle, resourceModeFlags));
+
+    paintServer.apply(*context, resourceMode, &stateSaver);
+
     if (resourceMode == ApplyToFillMode) {
         context->setAlphaAsFloat(svgStyle.fillOpacity());
         context->setFillRule(svgStyle.fillRule());
     } else {
         context->setAlphaAsFloat(svgStyle.strokeOpacity());
         applyStrokeStyleToContext(context, style, &renderer);
     }
     return true;
 }
 
 void SVGRenderSupport::fillOrStrokePath(GraphicsContext* context, unsigned short resourceMode, const Path& path)
 {
     if (resourceMode & ApplyToFillMode)
         context->fillPath(path);
     if (resourceMode & ApplyToStrokeMode)
         context->strokePath(path);
 }
 
 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();
 }
 
 }