Cleanup resolving of 'em' units in SVGLengthContext

Source/core/svg/SVGLengthContext.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 35 matching lines @@
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static float convertValueFromPercentageToUserUnits(const SVGLength& value, const FloatSize& viewportSize)
 {
     return CSSPrimitiveValue::clampToCSSLengthRange(value.scaleByPercentage(dimensionForLengthMode(value.unitMode(), viewportSize)));
 }
 
+static const ComputedStyle* computedStyleForLengthResolving(const SVGElement* context)
+{
+    if (!context)
+        return 0;
+
+    const ContainerNode* currentContext = context;
+    do {
+        if (currentContext->layoutObject())
+            return currentContext->layoutObject()->style();
+        currentContext = currentContext->parentNode();
+    } while (currentContext);
+
+    // There must be at least a LayoutSVGRoot renderer, carrying a style.
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
+static const ComputedStyle* rootElementStyle(const Node* context)
+{
+    if (!context)
+        return 0;
+
+    const Document& document = context->document();
+    Node* documentElement = document.documentElement();
+    const ComputedStyle* documentStyle = document.computedStyle();
+    const ComputedStyle* style = documentElement && context != documentElement ? documentElement->computedStyle() : documentStyle;
+    if (!style)
+        style = documentStyle;
+    return style;
+}
+
+static float convertValueFromUserUnitsToEMS(const ComputedStyle* style, float value)
+{
+    if (!style)
+        return 0;
+    float fontSize = style->specifiedFontSize();
+    if (!fontSize)
+        return 0;
+    return value / fontSize;
+}
+
+static float convertValueFromEMSToUserUnits(const ComputedStyle* style, float value)
+{
+    if (!style)
+        return 0;
+    return value * style->specifiedFontSize();
+}
+
 SVGLengthContext::SVGLengthContext(const SVGElement* context)
     : m_context(context)
 {
 }
 
 FloatRect SVGLengthContext::resolveRectangle(const SVGElement* context, SVGUnitTypes::SVGUnitType type, const FloatRect& viewport, const SVGLength& x, const SVGLength& y, const SVGLength& width, const SVGLength& height)
 {
     ASSERT(type != SVGUnitTypes::SVG_UNIT_TYPE_UNKNOWN);
     if (type != SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE && !viewport.isEmpty()) {
         const FloatSize& viewportSize = viewport.size();
@@ skipping 76 matching lines @@
         userUnits = value;
         break;
     case LengthTypePercentage: {
         FloatSize viewportSize;
         if (!determineViewport(viewportSize))
             return 0;
         userUnits = value * dimensionForLengthMode(mode, viewportSize) / 100;
         break;
     }
     case LengthTypeEMS:
-        userUnits = convertValueFromEMSToUserUnits(value);
+        userUnits = convertValueFromEMSToUserUnits(computedStyleForLengthResolving(m_context), value);
         break;
     case LengthTypeEXS:
         userUnits = convertValueFromEXSToUserUnits(value);
         break;
     case LengthTypeCM:
         userUnits = value * cssPixelsPerCentimeter;
         break;
     case LengthTypeMM:
         userUnits = value * cssPixelsPerMillimeter;
         break;
     case LengthTypeIN:
         userUnits = value * cssPixelsPerInch;
         break;
     case LengthTypePT:
         userUnits = value * cssPixelsPerPoint;
         break;
     case LengthTypePC:
         userUnits = value * cssPixelsPerPica;
         break;
     case LengthTypeREMS:
-        userUnits = convertValueFromREMSToUserUnits(value);
+        userUnits = convertValueFromEMSToUserUnits(rootElementStyle(m_context), value);
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 
     // Since we mix css <length> values with svg's length values we need to
     // clamp values to the narrowest range, otherwise it can result in
     // rendering issues.
     return CSSPrimitiveValue::clampToCSSLengthRange(userUnits);
 }
 
 float SVGLengthContext::convertValueFromUserUnits(float value, SVGLengthMode mode, SVGLengthType toUnit) const
 {
     switch (toUnit) {
     case LengthTypeUnknown:
         return 0;
     case LengthTypeNumber:
         return value;
     case LengthTypePercentage: {
         FloatSize viewportSize;
         if (!determineViewport(viewportSize))
             return 0;
         // LengthTypePercentage is represented with 100% = 100.0.
         // Good for accuracy but could eventually be changed.
         return value * 100 / dimensionForLengthMode(mode, viewportSize);
     }
     case LengthTypeEMS:
-        return convertValueFromUserUnitsToEMS(value);
+        return convertValueFromUserUnitsToEMS(computedStyleForLengthResolving(m_context), value);
     case LengthTypeEXS:
         return convertValueFromUserUnitsToEXS(value);
     case LengthTypeREMS:
-        return convertValueFromUserUnitsToREMS(value);
+        return convertValueFromUserUnitsToEMS(rootElementStyle(m_context), value);
     case LengthTypePX:
         return value;
     case LengthTypeCM:
         return value / cssPixelsPerCentimeter;
     case LengthTypeMM:
         return value / cssPixelsPerMillimeter;
     case LengthTypeIN:
         return value / cssPixelsPerInch;
     case LengthTypePT:
         return value / cssPixelsPerPoint;
     case LengthTypePC:
         return value / cssPixelsPerPica;
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-static inline const ComputedStyle* computedStyleForLengthResolving(const SVGElement* context)
-{
-    if (!context)
-        return 0;
-
-    const ContainerNode* currentContext = context;
-    do {
-        if (currentContext->layoutObject())
-            return currentContext->layoutObject()->style();
-        currentContext = currentContext->parentNode();
-    } while (currentContext);
-
-    // There must be at least a LayoutSVGRoot renderer, carrying a style.
-    ASSERT_NOT_REACHED();
-    return 0;
-}
-
-float SVGLengthContext::convertValueFromUserUnitsToEMS(float value) const
-{
-    const ComputedStyle* style = computedStyleForLengthResolving(m_context);
-    if (!style)
-        return 0;
-
-    float fontSize = style->specifiedFontSize();
-    if (!fontSize)
-        return 0;
-
-    return value / fontSize;
-}
-
-float SVGLengthContext::convertValueFromEMSToUserUnits(float value) const
-{
-    const ComputedStyle* style = computedStyleForLengthResolving(m_context);
-    if (!style)
-        return 0;
-    return value * style->specifiedFontSize();
-}
-
-float SVGLengthContext::convertValueFromUserUnitsToREMS(float value) const
-{
-    if (!m_context)
-        return 0;
-
-    const ComputedStyle* style = 0;
-    const Document& document = m_context->document();
-    Node* documentElement = document.documentElement();
-    const ComputedStyle* documentStyle = document.computedStyle();
-    style = documentElement && (static_cast<const Node*>(m_context.get()) != documentElement) ? documentElement->computedStyle() : documentStyle;
-    if (!style)
-        style = documentStyle;
-
-    if (!style)
-        return 0;
-
-    float fontSize = style->specifiedFontSize();
-    if (!fontSize)
-        return 0;
-
-    return value / fontSize;
-}
-
-float SVGLengthContext::convertValueFromREMSToUserUnits(float value) const
-{
-    if (!m_context)
-        return 0;
-
-    const ComputedStyle* style = 0;
-    const Document& document = m_context->document();
-    Node* documentElement = document.documentElement();
-    const ComputedStyle* documentStyle = document.computedStyle();
-    style = documentElement && (static_cast<const Node*>(m_context.get()) != documentElement) ? documentElement->computedStyle() : documentStyle;
-    if (!style)
-        style = documentStyle;
-
-    if (!style)
-        return 0;
-
-    return value * style->specifiedFontSize();
-}
-
 float SVGLengthContext::convertValueFromUserUnitsToEXS(float value) const
 {
     const ComputedStyle* style = computedStyleForLengthResolving(m_context);
     if (!style)
         return 0;
 
     // Use of ceil allows a pixel match to the W3Cs expected output of coords-units-03-b.svg
     // if this causes problems in real world cases maybe it would be best to remove this
     float xHeight = ceilf(style->fontMetrics().xHeight());
     if (!xHeight)
@@ skipping 31 matching lines @@
 
     const SVGSVGElement& svg = toSVGSVGElement(*viewportElement);
     viewportSize = svg.currentViewBoxRect().size();
     if (viewportSize.isEmpty())
         viewportSize = svg.currentViewportSize();
 
     return true;
 }
 
 }