CSS Length calculation with MediaValues

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple Inc. 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 540 matching lines @@
     case CSS_GRAD:
         return grad2deg(getDoubleValue());
     case CSS_TURN:
         return turn2deg(getDoubleValue());
     default:
         ASSERT_NOT_REACHED();
         return 0;
     }
 }
 
-template<> int CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> int CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return roundForImpreciseConversion<int>(computeLengthDouble(conversionData));
+    return roundForImpreciseConversion<int>(computeLengthDouble(&lengthData));
 }
 
-template<> unsigned CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> unsigned CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return roundForImpreciseConversion<unsigned>(computeLengthDouble(conversionData));
+    return roundForImpreciseConversion<unsigned>(computeLengthDouble(&lengthData));
 }
 
-template<> Length CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> Length CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return Length(clampTo<float>(computeLengthDouble(conversionData), minValueForCssLength, maxValueForCssLength), Fixed);
+    return Length(clampTo<float>(computeLengthDouble(&lengthData), minValueForCssLength, maxValueForCssLength), Fixed);
 }
 
-template<> short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> short CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return roundForImpreciseConversion<short>(computeLengthDouble(conversionData));
+    return roundForImpreciseConversion<short>(computeLengthDouble(&lengthData));
 }
 
-template<> unsigned short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> unsigned short CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return roundForImpreciseConversion<unsigned short>(computeLengthDouble(conversionData));
+    return roundForImpreciseConversion<unsigned short>(computeLengthDouble(&lengthData));
 }
 
-template<> float CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> float CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return static_cast<float>(computeLengthDouble(conversionData));
+    return static_cast<float>(computeLengthDouble(&lengthData));
 }
 
-template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> double CSSPrimitiveValue::computeLength(const CSSLengthData& lengthData)
 {
-    return computeLengthDouble(conversionData);
+    return computeLengthDouble(&lengthData);
 }
 
-double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData)
+double CSSPrimitiveValue::computeLengthDouble(const CSSLengthData* lengthData)
 {
+    ASSERT(lengthData);
     if (m_primitiveUnitType == CSS_CALC)
-        return m_value.calc->computeLengthPx(conversionData);
+        return m_value.calc->computeLengthPx(lengthData);
 
-    const RenderStyle& style = conversionData.style();
-    const RenderStyle* rootStyle = conversionData.rootStyle();
-    bool computingFontSize = conversionData.computingFontSize();
+    bool computingFontSize = lengthData->computingFontSize();
 
     double factor;
 
     switch (primitiveType()) {
         case CSS_EMS:
-            factor = computingFontSize ? style.fontDescription().specifiedSize() : style.fontDescription().computedSize();
+            factor = computingFontSize ? lengthData->fontSpecifiedSize() : lengthData->fontComputedSize();
             break;
         case CSS_EXS:
             // FIXME: We have a bug right now where the zoom will be applied twice to EX units.
             // We really need to compute EX using fontMetrics for the original specifiedSize and not use
             // our actual constructed rendering font.
-            if (style.fontMetrics().hasXHeight())
-                factor = style.fontMetrics().xHeight();
+            if (lengthData->hasXHeight())
+                factor = lengthData->xHeight();
             else
-                factor = (computingFontSize ? style.fontDescription().specifiedSize() : style.fontDescription().computedSize()) / 2.0;
+                factor = (computingFontSize ? lengthData->fontSpecifiedSize() : lengthData->fontComputedSize()) / 2.0;
             break;
         case CSS_REMS:
-            if (rootStyle)
-                factor = computingFontSize ? rootStyle->fontDescription().specifiedSize() : rootStyle->fontDescription().computedSize();
+            if (lengthData->hasRoot())
+                factor = computingFontSize ? lengthData->rootFontSpecifiedSize() : lengthData->rootFontComputedSize();
             else
                 factor = 1.0;
             break;
         case CSS_CHS:
-            factor = style.fontMetrics().zeroWidth();
+            factor = lengthData->zeroWidth();
             break;
         case CSS_PX:
             factor = 1.0;
             break;
         case CSS_CM:
             factor = cssPixelsPerCentimeter;
             break;
         case CSS_MM:
             factor = cssPixelsPerMillimeter;
             break;
         case CSS_IN:
             factor = cssPixelsPerInch;
             break;
         case CSS_PT:
             factor = cssPixelsPerPoint;
             break;
         case CSS_PC:
             factor = cssPixelsPerPica;
             break;
         case CSS_VW:
-            factor = conversionData.viewportWidthPercent();
+            factor = lengthData->viewportWidthPercent();
             break;
         case CSS_VH:
-            factor = conversionData.viewportHeightPercent();
+            factor = lengthData->viewportHeightPercent();
             break;
         case CSS_VMIN:
-            factor = conversionData.viewportMinPercent();
+            factor = lengthData->viewportMinPercent();
             break;
         case CSS_VMAX:
-            factor = conversionData.viewportMaxPercent();
+            factor = lengthData->viewportMaxPercent();
             break;
         case CSS_CALC_PERCENTAGE_WITH_LENGTH:
         case CSS_CALC_PERCENTAGE_WITH_NUMBER:
             ASSERT_NOT_REACHED();
             return -1.0;
         default:
             ASSERT_NOT_REACHED();
             return -1.0;
     }
 
     // We do not apply the zoom factor when we are computing the value of the font-size property. The zooming
     // for font sizes is much more complicated, since we have to worry about enforcing the minimum font size preference
     // as well as enforcing the implicit "smart minimum."
     double result = getDoubleValue() * factor;
     if (computingFontSize || isFontRelativeLength())
         return result;
 
-    return result * conversionData.zoom();
+    return result * lengthData->zoom();
 }
 
 void CSSPrimitiveValue::setFloatValue(unsigned short, double, ExceptionState& exceptionState)
 {
     // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects.
     // No other engine supports mutating style through this API. Computed style is always read-only anyway.
     // Supporting setter would require making primitive value copy-on-write and taking care of style invalidation.
     exceptionState.throwDOMException(NoModificationAllowedError, "CSSPrimitiveValue objects are read-only.");
 }
 
@@ skipping 631 matching lines @@
     case CSS_SHAPE:
         visitor->trace(m_value.shape);
         break;
     default:
         break;
     }
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace WebCore