Wrap CSS length conversion arguments in an object

Source/core/css/CSSPrimitiveValue.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@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 16 matching lines @@
 #include "core/css/CSSValue.h"
 #include "platform/graphics/Color.h"
 #include "wtf/Forward.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PassRefPtr.h"
 
 namespace WebCore {
 
 class CSSBasicShape;
 class CSSCalcValue;
+class CSSToLengthConversionData;
 class Counter;
 class ExceptionState;
 class Length;
 class Pair;
 class Quad;
 class RGBColor;
 class Rect;
 class RenderStyle;
 
 // Dimension calculations are imprecise, often resulting in values of e.g.
@@ skipping 191 matching lines @@
             return getValue<T>() / 1000;
         if (timeUnit == Milliseconds && m_primitiveUnitType == CSS_MS)
             return getValue<T>();
         if (timeUnit == Milliseconds && m_primitiveUnitType == CSS_S)
             return getValue<T>() * 1000;
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     /*
-     * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
-     * the fontinfo in case val is defined in em or ex.
+     * Computes a length in pixels out of the given CSSValue
      *
      * The metrics have to be a bit different for screen and printer output.
      * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
      *
      * this is screen/printer dependent, so we probably need a config option for this,
      * and some tool to calibrate.
      */
-    template<typename T> T computeLength(const RenderStyle* currStyle, const RenderStyle* rootStyle, float multiplier = 1.0f, bool computingFontSize = false);
+    template<typename T> T computeLength(const CSSToLengthConversionData&);
 
     // Converts to a Length, mapping various unit types appropriately.
-    template<int> Length convertToLength(const RenderStyle* currStyle, const RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false);
+    template<int> Length convertToLength(const CSSToLengthConversionData&);
 
     // use with care!!!
     void setPrimitiveType(unsigned short type) { m_primitiveUnitType = type; }
 
     double getDoubleValue(unsigned short unitType, ExceptionState&) const;
     double getDoubleValue(unsigned short unitType) const;
     double getDoubleValue() const;
 
     void setFloatValue(unsigned short unitType, double floatValue, ExceptionState&);
     float getFloatValue(unsigned short unitType, ExceptionState& exceptionState) const { return getValue<float>(unitType, exceptionState); }
@@ skipping 88 matching lines @@
 
     void init(const Length&);
     void init(PassRefPtr<Counter>);
     void init(PassRefPtr<Rect>);
     void init(PassRefPtr<Pair>);
     void init(PassRefPtr<Quad>);
     void init(PassRefPtr<CSSBasicShape>);
     void init(PassRefPtr<CSSCalcValue>);
     bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;
 
-    double computeLengthDouble(const RenderStyle* currentStyle, const RenderStyle* rootStyle, float multiplier, bool computingFontSize);
+    double computeLengthDouble(const CSSToLengthConversionData&);
 
     union {
         CSSPropertyID propertyID;
         CSSValueID valueID;
         int parserOperator;
         double num;
         StringImpl* string;
         Counter* counter;
         Rect* rect;
         Quad* quad;
         unsigned rgbcolor;
         Pair* pair;
         CSSBasicShape* shape;
         CSSCalcValue* calc;
     } m_value;
 };
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSPrimitiveValue, isPrimitiveValue());
 
 } // namespace WebCore
 
 #endif // CSSPrimitiveValue_h