Changeset 209758 in webkit


Ignore:
Timestamp:
Dec 13, 2016, 9:39:27 AM (9 years ago)
Author:
hyatt@apple.com
Message:

[CSS Parser] Rename CSSPrimitiveValue::UnitTypes to CSSPrimitiveValue::UnitType
​https://bugs.webkit.org/show_bug.cgi?id=165776

Reviewed by Zalan Bujtas.

  • css/CSSCalculationValue.cpp:

(WebCore::unitCategory):
(WebCore::hasDoubleValue):
(WebCore::determineCategory):
(WebCore::CSSCalcExpressionNodeParser::parseValue):

  • css/CSSCalculationValue.h:
  • css/CSSPrimitiveValue.cpp:

(WebCore::isValidCSSUnitTypeForDoubleConversion):
(WebCore::isStringType):
(WebCore::CSSPrimitiveValue::unitCategory):
(WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
(WebCore::CSSPrimitiveValue::cleanup):
(WebCore::CSSPrimitiveValue::computeLengthDouble):
(WebCore::CSSPrimitiveValue::computeNonCalcLengthDouble):
(WebCore::CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor):
(WebCore::CSSPrimitiveValue::getFloatValue):
(WebCore::CSSPrimitiveValue::doubleValue):
(WebCore::CSSPrimitiveValue::canonicalUnitTypeForCategory):
(WebCore::CSSPrimitiveValue::doubleValueInternal):
(WebCore::CSSPrimitiveValue::cloneForCSSOM):

  • css/CSSPrimitiveValue.h:

(WebCore::CSSPrimitiveValue::isFontRelativeLength):
(WebCore::CSSPrimitiveValue::isLength):
(WebCore::CSSPrimitiveValue::isResolution):
(WebCore::CSSPrimitiveValue::createAllowingMarginQuirk):

  • css/CSSValue.h:
  • css/CSSValuePool.cpp:

(WebCore::CSSValuePool::createValue):

  • css/CSSValuePool.h:

(WebCore::CSSValuePool::createValue):

  • css/MediaQueryExp.cpp:

(WebCore::featureWithValidDensity):
(WebCore::MediaQueryExpression::MediaQueryExpression):

  • css/parser/CSSParserFastPaths.cpp:

(WebCore::parseSimpleLength):
(WebCore::parseSimpleLengthValue):
(WebCore::parseColorIntOrPercentage):
(WebCore::fastParseColorInternal):
(WebCore::parseTransformTranslateArguments):
(WebCore::parseTransformNumberArguments):

  • css/parser/CSSParserToken.cpp:

(WebCore::cssPrimitiveValueUnitFromTrie):
(WebCore::stringToUnitType):
(WebCore::CSSParserToken::CSSParserToken):
(WebCore::CSSParserToken::convertToPercentage):

  • css/parser/CSSParserToken.h:

(WebCore::CSSParserToken::unitType):

  • css/parser/CSSPropertyParser.cpp:

(WebCore::CSSPropertyParser::consumeTransformOrigin):
(WebCore::consumeCounter):
(WebCore::consumeAnimationName):
(WebCore::consumePerspective):
(WebCore::consumePositionLonghand):
(WebCore::consumeCounterContent):
(WebCore::consumeReflect):
(WebCore::consumeGridBreadth):
(WebCore::CSSPropertyParser::consumeFlex):

  • css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::CalcParser::consumeNumber):
(WebCore::CSSPropertyParserHelpers::consumeInteger):
(WebCore::CSSPropertyParserHelpers::consumeLength):
(WebCore::CSSPropertyParserHelpers::consumePercent):
(WebCore::CSSPropertyParserHelpers::consumeAngle):
(WebCore::CSSPropertyParserHelpers::consumeTime):
(WebCore::CSSPropertyParserHelpers::consumeCustomIdent):
(WebCore::CSSPropertyParserHelpers::consumeString):
(WebCore::CSSPropertyParserHelpers::consumeUrl):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientPoint):
(WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientColorStop):
(WebCore::CSSPropertyParserHelpers::consumeCrossFade):
(WebCore::CSSPropertyParserHelpers::consumeImageSet):
(WebCore::CSSPropertyParserHelpers::consumeFilterFunction):

  • css/parser/MediaQueryParser.cpp:

(WebCore::MediaQueryParser::readFeatureValue):

  • css/parser/SizesAttributeParser.cpp:

(WebCore::SizesAttributeParser::computeLength):

  • css/parser/SizesAttributeParser.h:
  • dom/StyledElement.cpp:

(WebCore::StyledElement::setInlineStyleProperty):
(WebCore::StyledElement::addPropertyToPresentationAttributeStyle):

  • dom/StyledElement.h:
  • svg/SVGLengthValue.cpp:

(WebCore::SVGLengthValue::toCSSPrimitiveValue):

Location:
trunk/Source/WebCore
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r209757 r209758  
     12016-12-13  Dave Hyatt  <hyatt@apple.com>
     2
     3        [CSS Parser] Rename CSSPrimitiveValue::UnitTypes to CSSPrimitiveValue::UnitType
     4        https://bugs.webkit.org/show_bug.cgi?id=165776
     5
     6        Reviewed by Zalan Bujtas.
     7
     8        * css/CSSCalculationValue.cpp:
     9        (WebCore::unitCategory):
     10        (WebCore::hasDoubleValue):
     11        (WebCore::determineCategory):
     12        (WebCore::CSSCalcExpressionNodeParser::parseValue):
     13        * css/CSSCalculationValue.h:
     14        * css/CSSPrimitiveValue.cpp:
     15        (WebCore::isValidCSSUnitTypeForDoubleConversion):
     16        (WebCore::isStringType):
     17        (WebCore::CSSPrimitiveValue::unitCategory):
     18        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
     19        (WebCore::CSSPrimitiveValue::cleanup):
     20        (WebCore::CSSPrimitiveValue::computeLengthDouble):
     21        (WebCore::CSSPrimitiveValue::computeNonCalcLengthDouble):
     22        (WebCore::CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor):
     23        (WebCore::CSSPrimitiveValue::getFloatValue):
     24        (WebCore::CSSPrimitiveValue::doubleValue):
     25        (WebCore::CSSPrimitiveValue::canonicalUnitTypeForCategory):
     26        (WebCore::CSSPrimitiveValue::doubleValueInternal):
     27        (WebCore::CSSPrimitiveValue::cloneForCSSOM):
     28        * css/CSSPrimitiveValue.h:
     29        (WebCore::CSSPrimitiveValue::isFontRelativeLength):
     30        (WebCore::CSSPrimitiveValue::isLength):
     31        (WebCore::CSSPrimitiveValue::isResolution):
     32        (WebCore::CSSPrimitiveValue::createAllowingMarginQuirk):
     33        * css/CSSValue.h:
     34        * css/CSSValuePool.cpp:
     35        (WebCore::CSSValuePool::createValue):
     36        * css/CSSValuePool.h:
     37        (WebCore::CSSValuePool::createValue):
     38        * css/MediaQueryExp.cpp:
     39        (WebCore::featureWithValidDensity):
     40        (WebCore::MediaQueryExpression::MediaQueryExpression):
     41        * css/parser/CSSParserFastPaths.cpp:
     42        (WebCore::parseSimpleLength):
     43        (WebCore::parseSimpleLengthValue):
     44        (WebCore::parseColorIntOrPercentage):
     45        (WebCore::fastParseColorInternal):
     46        (WebCore::parseTransformTranslateArguments):
     47        (WebCore::parseTransformNumberArguments):
     48        * css/parser/CSSParserToken.cpp:
     49        (WebCore::cssPrimitiveValueUnitFromTrie):
     50        (WebCore::stringToUnitType):
     51        (WebCore::CSSParserToken::CSSParserToken):
     52        (WebCore::CSSParserToken::convertToPercentage):
     53        * css/parser/CSSParserToken.h:
     54        (WebCore::CSSParserToken::unitType):
     55        * css/parser/CSSPropertyParser.cpp:
     56        (WebCore::CSSPropertyParser::consumeTransformOrigin):
     57        (WebCore::consumeCounter):
     58        (WebCore::consumeAnimationName):
     59        (WebCore::consumePerspective):
     60        (WebCore::consumePositionLonghand):
     61        (WebCore::consumeCounterContent):
     62        (WebCore::consumeReflect):
     63        (WebCore::consumeGridBreadth):
     64        (WebCore::CSSPropertyParser::consumeFlex):
     65        * css/parser/CSSPropertyParserHelpers.cpp:
     66        (WebCore::CSSPropertyParserHelpers::CalcParser::consumeNumber):
     67        (WebCore::CSSPropertyParserHelpers::consumeInteger):
     68        (WebCore::CSSPropertyParserHelpers::consumeLength):
     69        (WebCore::CSSPropertyParserHelpers::consumePercent):
     70        (WebCore::CSSPropertyParserHelpers::consumeAngle):
     71        (WebCore::CSSPropertyParserHelpers::consumeTime):
     72        (WebCore::CSSPropertyParserHelpers::consumeCustomIdent):
     73        (WebCore::CSSPropertyParserHelpers::consumeString):
     74        (WebCore::CSSPropertyParserHelpers::consumeUrl):
     75        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientPoint):
     76        (WebCore::CSSPropertyParserHelpers::consumeDeprecatedGradientColorStop):
     77        (WebCore::CSSPropertyParserHelpers::consumeCrossFade):
     78        (WebCore::CSSPropertyParserHelpers::consumeImageSet):
     79        (WebCore::CSSPropertyParserHelpers::consumeFilterFunction):
     80        * css/parser/MediaQueryParser.cpp:
     81        (WebCore::MediaQueryParser::readFeatureValue):
     82        * css/parser/SizesAttributeParser.cpp:
     83        (WebCore::SizesAttributeParser::computeLength):
     84        * css/parser/SizesAttributeParser.h:
     85        * dom/StyledElement.cpp:
     86        (WebCore::StyledElement::setInlineStyleProperty):
     87        (WebCore::StyledElement::addPropertyToPresentationAttributeStyle):
     88        * dom/StyledElement.h:
     89        * svg/SVGLengthValue.cpp:
     90        (WebCore::SVGLengthValue::toCSSPrimitiveValue):
     91
    1922016-12-13  Eric Carlson  <eric.carlson@apple.com>
    293

  • trunk/Source/WebCore/css/CSSCalculationValue.cpp

    r209666 r209758  
    5353static RefPtr<CSSCalcExpressionNode> createCSS(const Length&, const RenderStyle&);
    5454
    55 static CalculationCategory unitCategory(CSSPrimitiveValue::UnitTypes type)
     55static CalculationCategory unitCategory(CSSPrimitiveValue::UnitType type)
    5656{
    5757    switch (type) {
    … …  
    9191}
    9292
    93 static bool hasDoubleValue(CSSPrimitiveValue::UnitTypes type)
     93static bool hasDoubleValue(CSSPrimitiveValue::UnitType type)
    9494{
    9595    switch (type) {
    … …  
    202202    }
    203203
    204     static RefPtr<CSSCalcPrimitiveValue> create(double value, CSSPrimitiveValue::UnitTypes type, bool isInteger)
     204    static RefPtr<CSSCalcPrimitiveValue> create(double value, CSSPrimitiveValue::UnitType type, bool isInteger)
    205205    {
    206206        if (std::isnan(value) || std::isinf(value))
    … …  
    282282
    283283    Type type() const final { return CssCalcPrimitiveValue; }
    284     CSSPrimitiveValue::UnitTypes primitiveType() const final
    285     {
    286         return CSSPrimitiveValue::UnitTypes(m_value->primitiveType());
     284    CSSPrimitiveValue::UnitType primitiveType() const final
     285    {
     286        return CSSPrimitiveValue::UnitType(m_value->primitiveType());
    287287    }
    288288
    289289private:
    290290    explicit CSSCalcPrimitiveValue(Ref<CSSPrimitiveValue>&& value, bool isInteger)
    291         : CSSCalcExpressionNode(unitCategory((CSSPrimitiveValue::UnitTypes)value->primitiveType()), isInteger)
     291        : CSSCalcExpressionNode(unitCategory((CSSPrimitiveValue::UnitType)value->primitiveType()), isInteger)
    292292        , m_value(WTFMove(value))
    293293    {
    … …  
    369369        // Simplify numbers.
    370370        if (leftCategory == CalcNumber && rightCategory == CalcNumber) {
    371             CSSPrimitiveValue::UnitTypes evaluationType = CSSPrimitiveValue::CSS_NUMBER;
     371            CSSPrimitiveValue::UnitType evaluationType = CSSPrimitiveValue::CSS_NUMBER;
    372372            return CSSCalcPrimitiveValue::create(evaluateOperator(op, leftSide->doubleValue(), rightSide->doubleValue()), evaluationType, isInteger);
    373373        }
    … …  
    376376        if (op == CalcAdd || op == CalcSubtract) {
    377377            if (leftCategory == rightSide->category()) {
    378                 CSSPrimitiveValue::UnitTypes leftType = leftSide->primitiveType();
     378                CSSPrimitiveValue::UnitType leftType = leftSide->primitiveType();
    379379                if (hasDoubleValue(leftType)) {
    380                     CSSPrimitiveValue::UnitTypes rightType = rightSide->primitiveType();
     380                    CSSPrimitiveValue::UnitType rightType = rightSide->primitiveType();
    381381                    if (leftType == rightType)
    382382                        return CSSCalcPrimitiveValue::create(evaluateOperator(op, leftSide->doubleValue(), rightSide->doubleValue()), leftType, isInteger);
    383383                    CSSPrimitiveValue::UnitCategory leftUnitCategory = CSSPrimitiveValue::unitCategory(leftType);
    384384                    if (leftUnitCategory != CSSPrimitiveValue::UOther && leftUnitCategory == CSSPrimitiveValue::unitCategory(rightType)) {
    385                         CSSPrimitiveValue::UnitTypes canonicalType = CSSPrimitiveValue::canonicalUnitTypeForCategory(leftUnitCategory);
     385                        CSSPrimitiveValue::UnitType canonicalType = CSSPrimitiveValue::canonicalUnitTypeForCategory(leftUnitCategory);
    386386                        if (canonicalType != CSSPrimitiveValue::CSS_UNKNOWN) {
    387387                            double leftValue = leftSide->doubleValue() * CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(leftType);
    … …  
    408408                return nullptr;
    409409
    410             CSSPrimitiveValue::UnitTypes otherType = otherSide->primitiveType();
     410            CSSPrimitiveValue::UnitType otherType = otherSide->primitiveType();
    411411            if (hasDoubleValue(otherType))
    412412                return CSSCalcPrimitiveValue::create(evaluateOperator(op, otherSide->doubleValue(), number), otherType, isInteger);
    … …  
    477477    Type type() const final { return CssCalcBinaryOperation; }
    478478
    479     CSSPrimitiveValue::UnitTypes primitiveType() const final
     479    CSSPrimitiveValue::UnitType primitiveType() const final
    480480    {
    481481        switch (category()) {
    … …  
    489489            if (m_rightSide->category() == CalcNumber)
    490490                return m_leftSide->primitiveType();
    491             CSSPrimitiveValue::UnitTypes leftType = m_leftSide->primitiveType();
     491            CSSPrimitiveValue::UnitType leftType = m_leftSide->primitiveType();
    492492            if (leftType == m_rightSide->primitiveType())
    493493                return leftType;
    … …  
    594594            return false;
    595595       
    596         CSSPrimitiveValue::UnitTypes type = token.unitType();
     596        CSSPrimitiveValue::UnitType type = token.unitType();
    597597        if (unitCategory(type) == CalcOther)
    598598            return false;

  • trunk/Source/WebCore/css/CSSCalculationValue.h

    r209666 r209758  
    6767    virtual bool equals(const CSSCalcExpressionNode& other) const { return m_category == other.m_category && m_isInteger == other.m_isInteger; }
    6868    virtual Type type() const = 0;
    69     virtual CSSPrimitiveValue::UnitTypes primitiveType() const = 0;
     69    virtual CSSPrimitiveValue::UnitType primitiveType() const = 0;
    7070
    7171    CalculationCategory category() const { return m_category; }

  • trunk/Source/WebCore/css/CSSPrimitiveValue.cpp

    r209671 r209758  
    6262namespace WebCore {
    6363
    64 static inline bool isValidCSSUnitTypeForDoubleConversion(CSSPrimitiveValue::UnitTypes unitType)
     64static inline bool isValidCSSUnitTypeForDoubleConversion(CSSPrimitiveValue::UnitType unitType)
    6565{
    6666    switch (unitType) {
    … …  
    135135#if !ASSERT_DISABLED
    136136
    137 static inline bool isStringType(CSSPrimitiveValue::UnitTypes type)
     137static inline bool isStringType(CSSPrimitiveValue::UnitType type)
    138138{
    139139    switch (type) {
    … …  
    203203#endif // !ASSERT_DISABLED
    204204
    205 CSSPrimitiveValue::UnitCategory CSSPrimitiveValue::unitCategory(CSSPrimitiveValue::UnitTypes type)
     205CSSPrimitiveValue::UnitCategory CSSPrimitiveValue::unitCategory(CSSPrimitiveValue::UnitType type)
    206206{
    207207    // Here we violate the spec (http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSPrimitiveValue) and allow conversions
    … …  
    318318}
    319319
    320 CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitTypes type)
     320CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitType type)
    321321    : CSSValue(PrimitiveClass)
    322322{
    … …  
    326326}
    327327
    328 CSSPrimitiveValue::CSSPrimitiveValue(const String& string, UnitTypes type)
     328CSSPrimitiveValue::CSSPrimitiveValue(const String& string, UnitType type)
    329329    : CSSValue(PrimitiveClass)
    330330{
    … …  
    507507void CSSPrimitiveValue::cleanup()
    508508{
    509     auto type = static_cast<UnitTypes>(m_primitiveUnitType);
     509    auto type = static_cast<UnitType>(m_primitiveUnitType);
    510510    switch (type) {
    511511    case CSS_STRING:
    … …  
    662662        return m_value.calc->computeLengthPx(conversionData);
    663663
    664     return computeNonCalcLengthDouble(conversionData, static_cast<UnitTypes>(primitiveType()), m_value.num);
    665 }
    666 
    667 double CSSPrimitiveValue::computeNonCalcLengthDouble(const CSSToLengthConversionData& conversionData, UnitTypes primitiveType, double value)
     664    return computeNonCalcLengthDouble(conversionData, static_cast<UnitType>(primitiveType()), m_value.num);
     665}
     666
     667double CSSPrimitiveValue::computeNonCalcLengthDouble(const CSSToLengthConversionData& conversionData, UnitType primitiveType, double value)
    668668{
    669669    double factor;
    … …  
    753753}
    754754
    755 double CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(UnitTypes unitType)
     755double CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(UnitType unitType)
    756756{
    757757    double factor = 1.0;
    … …  
    807807ExceptionOr<float> CSSPrimitiveValue::getFloatValue(unsigned short unitType) const
    808808{
    809     auto result = doubleValueInternal(static_cast<UnitTypes>(unitType));
     809    auto result = doubleValueInternal(static_cast<UnitType>(unitType));
    810810    if (!result)
    811811        return Exception { INVALID_ACCESS_ERR };
    … …  
    813813}
    814814
    815 double CSSPrimitiveValue::doubleValue(UnitTypes unitType) const
     815double CSSPrimitiveValue::doubleValue(UnitType unitType) const
    816816{
    817817    return doubleValueInternal(unitType).value_or(0);
    … …  
    824824
    825825
    826 CSSPrimitiveValue::UnitTypes CSSPrimitiveValue::canonicalUnitTypeForCategory(UnitCategory category)
     826CSSPrimitiveValue::UnitType CSSPrimitiveValue::canonicalUnitTypeForCategory(UnitCategory category)
    827827{
    828828    // The canonical unit type is chosen according to the way CSSParser::validUnit() chooses the default unit
    … …  
    850850}
    851851
    852 std::optional<double> CSSPrimitiveValue::doubleValueInternal(UnitTypes requestedUnitType) const
    853 {
    854     if (!isValidCSSUnitTypeForDoubleConversion(static_cast<UnitTypes>(m_primitiveUnitType)) || !isValidCSSUnitTypeForDoubleConversion(requestedUnitType))
     852std::optional<double> CSSPrimitiveValue::doubleValueInternal(UnitType requestedUnitType) const
     853{
     854    if (!isValidCSSUnitTypeForDoubleConversion(static_cast<UnitType>(m_primitiveUnitType)) || !isValidCSSUnitTypeForDoubleConversion(requestedUnitType))
    855855        return std::nullopt;
    856856
    857     UnitTypes sourceUnitType = static_cast<UnitTypes>(primitiveType());
     857    UnitType sourceUnitType = static_cast<UnitType>(primitiveType());
    858858    if (requestedUnitType == sourceUnitType || requestedUnitType == CSS_DIMENSION)
    859859        return doubleValue();
    … …  
    862862    ASSERT(sourceCategory != UOther);
    863863
    864     UnitTypes targetUnitType = requestedUnitType;
     864    UnitType targetUnitType = requestedUnitType;
    865865    UnitCategory targetCategory = unitCategory(targetUnitType);
    866866    ASSERT(targetCategory != UOther);
    … …  
    11841184    case CSS_ATTR:
    11851185    case CSS_COUNTER_NAME:
    1186         result = CSSPrimitiveValue::create(m_value.string, static_cast<UnitTypes>(m_primitiveUnitType));
     1186        result = CSSPrimitiveValue::create(m_value.string, static_cast<UnitType>(m_primitiveUnitType));
    11871187        break;
    11881188    case CSS_FONT_FAMILY:
    … …  
    12521252#endif
    12531253    case CSS_FR:
    1254         result = CSSPrimitiveValue::create(m_value.num, static_cast<UnitTypes>(m_primitiveUnitType));
     1254        result = CSSPrimitiveValue::create(m_value.num, static_cast<UnitType>(m_primitiveUnitType));
    12551255        break;
    12561256    case CSS_PROPERTY_ID:

  • trunk/Source/WebCore/css/CSSPrimitiveValue.h

    r209666 r209758  
    7676class CSSPrimitiveValue final : public CSSValue {
    7777public:
    78     enum UnitTypes {
     78    enum UnitType {
    7979        CSS_UNKNOWN = 0,
    8080        CSS_NUMBER = 1,
    … …  
    165165        UOther
    166166    };
    167     static UnitCategory unitCategory(UnitTypes);
     167    static UnitCategory unitCategory(UnitType);
    168168
    169169    bool isAngle() const;
    … …  
    171171    bool isCounter() const { return m_primitiveUnitType == CSS_COUNTER; }
    172172    bool isFontIndependentLength() const { return m_primitiveUnitType >= CSS_PX && m_primitiveUnitType <= CSS_PC; }
    173     static bool isFontRelativeLength(UnitTypes);
    174     bool isFontRelativeLength() const { return isFontRelativeLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
     173    static bool isFontRelativeLength(UnitType);
     174    bool isFontRelativeLength() const { return isFontRelativeLength(static_cast<UnitType>(m_primitiveUnitType)); }
    175175   
    176     bool isQuirkyEms() const { return primitiveType() == UnitTypes::CSS_QUIRKY_EMS; }
    177 
    178     static bool isViewportPercentageLength(UnitTypes type) { return type >= CSS_VW && type <= CSS_VMAX; }
    179     bool isViewportPercentageLength() const { return isViewportPercentageLength(static_cast<UnitTypes>(m_primitiveUnitType)); }
    180 
    181     static bool isLength(UnitTypes);
    182     bool isLength() const { return isLength(static_cast<UnitTypes>(primitiveType())); }
     176    bool isQuirkyEms() const { return primitiveType() == UnitType::CSS_QUIRKY_EMS; }
     177
     178    static bool isViewportPercentageLength(UnitType type) { return type >= CSS_VW && type <= CSS_VMAX; }
     179    bool isViewportPercentageLength() const { return isViewportPercentageLength(static_cast<UnitType>(m_primitiveUnitType)); }
     180
     181    static bool isLength(UnitType);
     182    bool isLength() const { return isLength(static_cast<UnitType>(primitiveType())); }
    183183    bool isNumber() const { return primitiveType() == CSS_NUMBER; }
    184184    bool isPercentage() const { return primitiveType() == CSS_PERCENTAGE; }
    … …  
    203203    bool isDotsPerCentimeter() const { return primitiveType() == CSS_DPCM; }
    204204
    205     static bool isResolution(UnitTypes);
    206     bool isResolution() const { return isResolution(static_cast<UnitTypes>(primitiveType())); }
     205    static bool isResolution(UnitType);
     206    bool isResolution() const { return isResolution(static_cast<UnitType>(primitiveType())); }
    207207    bool isViewportPercentageWidth() const { return m_primitiveUnitType == CSS_VW; }
    208208    bool isViewportPercentageHeight() const { return m_primitiveUnitType == CSS_VH; }
    … …  
    215215    static Ref<CSSPrimitiveValue> createIdentifier(CSSPropertyID propertyID) { return adoptRef(*new CSSPrimitiveValue(propertyID)); }
    216216
    217     static Ref<CSSPrimitiveValue> create(double value, UnitTypes type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
    218     static Ref<CSSPrimitiveValue> create(const String& value, UnitTypes type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
     217    static Ref<CSSPrimitiveValue> create(double value, UnitType type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
     218    static Ref<CSSPrimitiveValue> create(const String& value, UnitType type) { return adoptRef(*new CSSPrimitiveValue(value, type)); }
    219219    static Ref<CSSPrimitiveValue> create(const Length& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
    220220    static Ref<CSSPrimitiveValue> create(const LengthSize& value, const RenderStyle& style) { return adoptRef(*new CSSPrimitiveValue(value, style)); }
    … …  
    226226    // When the quirky value is used, if you're in quirks mode, the margin will collapse away
    227227    // inside a table cell.
    228     static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitTypes);
     228    static Ref<CSSPrimitiveValue> createAllowingMarginQuirk(double value, UnitType);
    229229
    230230    ~CSSPrimitiveValue();
    … …  
    251251    bool convertingToLengthRequiresNonNullStyle(int lengthConversion) const;
    252252
    253     double doubleValue(UnitTypes) const;
     253    double doubleValue(UnitType) const;
    254254    double doubleValue() const;
    255255
    256     template<typename T> inline T value(UnitTypes type) const { return clampTo<T>(doubleValue(type)); }
     256    template<typename T> inline T value(UnitType type) const { return clampTo<T>(doubleValue(type)); }
    257257    template<typename T> inline T value() const { return clampTo<T>(doubleValue()); }
    258258
    259     float floatValue(UnitTypes type) const { return value<float>(type); }
     259    float floatValue(UnitType type) const { return value<float>(type); }
    260260    float floatValue() const { return value<float>(); }
    261261
    262     int intValue(UnitTypes type) const { return value<int>(type); }
     262    int intValue(UnitType type) const { return value<int>(type); }
    263263    int intValue() const { return value<int>(); }
    264264
    … …  
    295295    bool equals(const CSSPrimitiveValue&) const;
    296296
    297     static UnitTypes canonicalUnitTypeForCategory(UnitCategory);
    298     static double conversionToCanonicalUnitsScaleFactor(UnitTypes);
    299 
    300     static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, UnitTypes, double value);
     297    static UnitType canonicalUnitTypeForCategory(UnitCategory);
     298    static double conversionToCanonicalUnitsScaleFactor(UnitType);
     299
     300    static double computeNonCalcLengthDouble(const CSSToLengthConversionData&, UnitType, double value);
    301301
    302302#if COMPILER(MSVC)
    … …  
    315315    CSSPrimitiveValue(const Length&, const RenderStyle&);
    316316    CSSPrimitiveValue(const LengthSize&, const RenderStyle&);
    317     CSSPrimitiveValue(const String&, UnitTypes);
    318     CSSPrimitiveValue(double, UnitTypes);
     317    CSSPrimitiveValue(const String&, UnitType);
     318    CSSPrimitiveValue(double, UnitType);
    319319
    320320    template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
    … …  
    342342#endif
    343343
    344     std::optional<double> doubleValueInternal(UnitTypes targetUnitType) const;
     344    std::optional<double> doubleValueInternal(UnitType targetUnitType) const;
    345345
    346346    double computeLengthDouble(const CSSToLengthConversionData&) const;
    … …  
    378378}
    379379
    380 inline bool CSSPrimitiveValue::isFontRelativeLength(UnitTypes type)
     380inline bool CSSPrimitiveValue::isFontRelativeLength(UnitType type)
    381381{
    382382    return type == CSS_EMS
    … …  
    387387}
    388388
    389 inline bool CSSPrimitiveValue::isLength(UnitTypes type)
     389inline bool CSSPrimitiveValue::isLength(UnitType type)
    390390{
    391391    return (type >= CSS_EMS && type <= CSS_PC)
    … …  
    396396}
    397397
    398 inline bool CSSPrimitiveValue::isResolution(UnitTypes type)
     398inline bool CSSPrimitiveValue::isResolution(UnitType type)
    399399{
    400400    return type >= CSS_DPPX && type <= CSS_DPCM;
    … …  
    406406}
    407407
    408 inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::createAllowingMarginQuirk(double value, UnitTypes type)
     408inline Ref<CSSPrimitiveValue> CSSPrimitiveValue::createAllowingMarginQuirk(double value, UnitType type)
    409409{
    410410    auto result = adoptRef(*new CSSPrimitiveValue(value, type));

  • trunk/Source/WebCore/css/CSSValue.h

    r209666 r209758  
    253253
    254254    // CSSPrimitiveValue bits:
    255     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitTypes
     255    unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
    256256    mutable unsigned m_hasCachedCSSText : 1;
    257257    unsigned m_isQuirkValue : 1;

  • trunk/Source/WebCore/css/CSSValuePool.cpp

    r209666 r209758  
    9696}
    9797
    98 Ref<CSSPrimitiveValue> CSSValuePool::createValue(double value, CSSPrimitiveValue::UnitTypes type)
     98Ref<CSSPrimitiveValue> CSSValuePool::createValue(double value, CSSPrimitiveValue::UnitType type)
    9999{
    100100    ASSERT(std::isfinite(value));

  • trunk/Source/WebCore/css/CSSValuePool.h

    r208668 r209758  
    6262    Ref<CSSPrimitiveValue> createIdentifierValue(CSSPropertyID identifier);
    6363    Ref<CSSPrimitiveValue> createColorValue(const Color&);
    64     Ref<CSSPrimitiveValue> createValue(double value, CSSPrimitiveValue::UnitTypes);
    65     Ref<CSSPrimitiveValue> createValue(const String& value, CSSPrimitiveValue::UnitTypes type) { return CSSPrimitiveValue::create(value, type); }
     64    Ref<CSSPrimitiveValue> createValue(double value, CSSPrimitiveValue::UnitType);
     65    Ref<CSSPrimitiveValue> createValue(const String& value, CSSPrimitiveValue::UnitType type) { return CSSPrimitiveValue::create(value, type); }
    6666    Ref<CSSPrimitiveValue> createValue(const Length& value, const RenderStyle& style) { return CSSPrimitiveValue::create(value, style); }
    6767    Ref<CSSPrimitiveValue> createValue(const LengthSize& value, const RenderStyle& style) { return CSSPrimitiveValue::create(value, style); }

  • trunk/Source/WebCore/css/MediaQueryExp.cpp

    r209666 r209758  
    5757static inline bool featureWithValidDensity(const String& mediaFeature, const CSSParserToken& token)
    5858{
    59     if (!CSSPrimitiveValue::isResolution(static_cast<CSSPrimitiveValue::UnitTypes>(token.unitType())) || token.numericValue() <= 0)
     59    if (!CSSPrimitiveValue::isResolution(static_cast<CSSPrimitiveValue::UnitType>(token.unitType())) || token.numericValue() <= 0)
    6060        return false;
    6161   
    … …  
    187187                // Media features that must have non-negative <density>, ie. dppx, dpi or dpcm,
    188188                // or Media features that must have non-negative <length> or number value.
    189                 m_value = CSSPrimitiveValue::create(token.numericValue(), (CSSPrimitiveValue::UnitTypes) token.unitType());
     189                m_value = CSSPrimitiveValue::create(token.numericValue(), (CSSPrimitiveValue::UnitType) token.unitType());
    190190                m_isValid = true;
    191191            } else if (featureWithPositiveInteger(m_mediaFeature, token)
    … …  
    195195                // or media features that must have non-negative number value,
    196196                // or media features that must have (0|1) value.
    197                 m_value = CSSPrimitiveValue::create(token.numericValue(), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     197                m_value = CSSPrimitiveValue::create(token.numericValue(), CSSPrimitiveValue::UnitType::CSS_NUMBER);
    198198                m_isValid = true;
    199199            }

  • trunk/Source/WebCore/css/parser/CSSParserFastPaths.cpp

    r209718 r209758  
    102102
    103103template <typename CharacterType>
    104 static inline bool parseSimpleLength(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitTypes& unit, double& number)
     104static inline bool parseSimpleLength(const CharacterType* characters, unsigned length, CSSPrimitiveValue::UnitType& unit, double& number)
    105105{
    106106    if (length > 2 && (characters[length - 2] | 0x20) == 'p' && (characters[length - 1] | 0x20) == 'x') {
    107107        length -= 2;
    108         unit = CSSPrimitiveValue::UnitTypes::CSS_PX;
     108        unit = CSSPrimitiveValue::UnitType::CSS_PX;
    109109    } else if (length > 1 && characters[length - 1] == '%') {
    110110        length -= 1;
    111         unit = CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE;
     111        unit = CSSPrimitiveValue::UnitType::CSS_PERCENTAGE;
    112112    }
    113113
    … …  
    133133    unsigned length = string.length();
    134134    double number;
    135     CSSPrimitiveValue::UnitTypes unit = CSSPrimitiveValue::UnitTypes::CSS_NUMBER;
     135    CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
    136136
    137137    if (string.is8Bit()) {
    … …  
    143143    }
    144144
    145     if (unit == CSSPrimitiveValue::UnitTypes::CSS_NUMBER) {
     145    if (unit == CSSPrimitiveValue::UnitType::CSS_NUMBER) {
    146146        if (number && cssParserMode != SVGAttributeMode)
    147147            return nullptr;
    148         unit = CSSPrimitiveValue::UnitTypes::CSS_PX;
     148        unit = CSSPrimitiveValue::UnitType::CSS_PX;
    149149    }
    150150
    … …  
    257257
    258258template <typename CharacterType>
    259 static bool parseColorIntOrPercentage(const CharacterType*& string, const CharacterType* end, const char terminator, CSSPrimitiveValue::UnitTypes& expect, int& value)
     259static bool parseColorIntOrPercentage(const CharacterType*& string, const CharacterType* end, const char terminator, CSSPrimitiveValue::UnitType& expect, int& value)
    260260{
    261261    const CharacterType* current = string;
    … …  
    285285        return false;
    286286
    287     if (expect == CSSPrimitiveValue::UnitTypes::CSS_NUMBER && (*current == '.' || *current == '%'))
     287    if (expect == CSSPrimitiveValue::UnitType::CSS_NUMBER && (*current == '.' || *current == '%'))
    288288        return false;
    289289
    … …  
    301301    }
    302302
    303     if (expect == CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE && *current != '%')
     303    if (expect == CSSPrimitiveValue::UnitType::CSS_PERCENTAGE && *current != '%')
    304304        return false;
    305305
    306306    if (*current == '%') {
    307         expect = CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE;
     307        expect = CSSPrimitiveValue::UnitType::CSS_PERCENTAGE;
    308308        localValue = localValue / 100.0 * 256.0;
    309309        // Clamp values at 255 for percentages over 100%
    … …  
    312312        current++;
    313313    } else {
    314         expect = CSSPrimitiveValue::UnitTypes::CSS_NUMBER;
     314        expect = CSSPrimitiveValue::UnitType::CSS_NUMBER;
    315315    }
    316316
    … …  
    417417static Color fastParseColorInternal(const CharacterType* characters, unsigned length, bool quirksMode)
    418418{
    419     CSSPrimitiveValue::UnitTypes expect = CSSPrimitiveValue::UnitTypes::CSS_UNKNOWN;
     419    CSSPrimitiveValue::UnitType expect = CSSPrimitiveValue::UnitType::CSS_UNKNOWN;
    420420
    421421    if (length >= 4 && characters[0] == '#') {
    … …  
    10601060            return false;
    10611061        unsigned argumentLength = static_cast<unsigned>(delimiter);
    1062         CSSPrimitiveValue::UnitTypes unit = CSSPrimitiveValue::UnitTypes::CSS_NUMBER;
     1062        CSSPrimitiveValue::UnitType unit = CSSPrimitiveValue::UnitType::CSS_NUMBER;
    10631063        double number;
    10641064        if (!parseSimpleLength(pos, argumentLength, unit, number))
    10651065            return false;
    1066         if (unit != CSSPrimitiveValue::UnitTypes::CSS_PX && (number || unit != CSSPrimitiveValue::UnitTypes::CSS_NUMBER))
     1066        if (unit != CSSPrimitiveValue::UnitType::CSS_PX && (number || unit != CSSPrimitiveValue::UnitType::CSS_NUMBER))
    10671067            return false;
    1068         transformValue->append(CSSPrimitiveValue::create(number, CSSPrimitiveValue::UnitTypes::CSS_PX));
     1068        transformValue->append(CSSPrimitiveValue::create(number, CSSPrimitiveValue::UnitType::CSS_PX));
    10691069        pos += argumentLength + 1;
    10701070        --expectedCount;
    … …  
    10851085        if (!ok)
    10861086            return false;
    1087         transformValue->append(CSSPrimitiveValue::create(number, CSSPrimitiveValue::UnitTypes::CSS_NUMBER));
     1087        transformValue->append(CSSPrimitiveValue::create(number, CSSPrimitiveValue::UnitType::CSS_NUMBER));
    10881088        pos += argumentLength + 1;
    10891089        --expectedCount;

  • trunk/Source/WebCore/css/parser/CSSParserToken.cpp

    r209383 r209758  
    4141
    4242template<typename CharacterType>
    43 CSSPrimitiveValue::UnitTypes cssPrimitiveValueUnitFromTrie(const CharacterType* data, unsigned length)
     43CSSPrimitiveValue::UnitType cssPrimitiveValueUnitFromTrie(const CharacterType* data, unsigned length)
    4444{
    4545    ASSERT(data);
    … …  
    4949        switch (toASCIILower(data[0])) {
    5050        case 's':
    51             return CSSPrimitiveValue::UnitTypes::CSS_S;
     51            return CSSPrimitiveValue::UnitType::CSS_S;
    5252        }
    5353        break;
    … …  
    5757            switch (toASCIILower(data[1])) {
    5858            case 'h':
    59                 return CSSPrimitiveValue::UnitTypes::CSS_CHS;
     59                return CSSPrimitiveValue::UnitType::CSS_CHS;
    6060            case 'm':
    61                 return CSSPrimitiveValue::UnitTypes::CSS_CM;
     61                return CSSPrimitiveValue::UnitType::CSS_CM;
    6262            }
    6363            break;
    … …  
    6565            switch (toASCIILower(data[1])) {
    6666            case 'm':
    67                 return CSSPrimitiveValue::UnitTypes::CSS_EMS;
     67                return CSSPrimitiveValue::UnitType::CSS_EMS;
    6868            case 'x':
    69                 return CSSPrimitiveValue::UnitTypes::CSS_EXS;
     69                return CSSPrimitiveValue::UnitType::CSS_EXS;
    7070            }
    7171            break;
    7272        case 'f':
    7373            if (toASCIILower(data[1]) == 'r')
    74                 return CSSPrimitiveValue::UnitTypes::CSS_FR;
     74                return CSSPrimitiveValue::UnitType::CSS_FR;
    7575            break;
    7676        case 'h':
    7777            if (toASCIILower(data[1]) == 'z')
    78                 return CSSPrimitiveValue::UnitTypes::CSS_HZ;
     78                return CSSPrimitiveValue::UnitType::CSS_HZ;
    7979            break;
    8080        case 'i':
    8181            if (toASCIILower(data[1]) == 'n')
    82                 return CSSPrimitiveValue::UnitTypes::CSS_IN;
     82                return CSSPrimitiveValue::UnitType::CSS_IN;
    8383            break;
    8484        case 'm':
    8585            switch (toASCIILower(data[1])) {
    8686            case 'm':
    87                 return CSSPrimitiveValue::UnitTypes::CSS_MM;
     87                return CSSPrimitiveValue::UnitType::CSS_MM;
    8888            case 's':
    89                 return CSSPrimitiveValue::UnitTypes::CSS_MS;
     89                return CSSPrimitiveValue::UnitType::CSS_MS;
    9090            }
    9191            break;
    … …  
    9393            switch (toASCIILower(data[1])) {
    9494            case 'c':
    95                 return CSSPrimitiveValue::UnitTypes::CSS_PC;
     95                return CSSPrimitiveValue::UnitType::CSS_PC;
    9696            case 't':
    97                 return CSSPrimitiveValue::UnitTypes::CSS_PT;
     97                return CSSPrimitiveValue::UnitType::CSS_PT;
    9898            case 'x':
    99                 return CSSPrimitiveValue::UnitTypes::CSS_PX;
     99                return CSSPrimitiveValue::UnitType::CSS_PX;
    100100            }
    101101            break;
    … …  
    103103            switch (toASCIILower(data[1])) {
    104104            case 'h':
    105                 return CSSPrimitiveValue::UnitTypes::CSS_VH;
     105                return CSSPrimitiveValue::UnitType::CSS_VH;
    106106            case 'w':
    107                 return CSSPrimitiveValue::UnitTypes::CSS_VW;
     107                return CSSPrimitiveValue::UnitType::CSS_VW;
    108108            }
    109109            break;
    … …  
    116116            case 'e':
    117117                if (toASCIILower(data[2]) == 'g')
    118                     return CSSPrimitiveValue::UnitTypes::CSS_DEG;
     118                    return CSSPrimitiveValue::UnitType::CSS_DEG;
    119119                break;
    120120            case 'p':
    121121                if (toASCIILower(data[2]) == 'i')
    122                     return CSSPrimitiveValue::UnitTypes::CSS_DPI;
     122                    return CSSPrimitiveValue::UnitType::CSS_DPI;
    123123                break;
    124124            }
    … …  
    126126        case 'k':
    127127            if (toASCIILower(data[1]) == 'h' && toASCIILower(data[2]) == 'z')
    128                 return CSSPrimitiveValue::UnitTypes::CSS_KHZ;
     128                return CSSPrimitiveValue::UnitType::CSS_KHZ;
    129129            break;
    130130        case 'r':
    … …  
    132132            case 'a':
    133133                if (toASCIILower(data[2]) == 'd')
    134                     return CSSPrimitiveValue::UnitTypes::CSS_RAD;
     134                    return CSSPrimitiveValue::UnitType::CSS_RAD;
    135135                break;
    136136            case 'e':
    137137                if (toASCIILower(data[2]) == 'm')
    138                     return CSSPrimitiveValue::UnitTypes::CSS_REMS;
     138                    return CSSPrimitiveValue::UnitType::CSS_REMS;
    139139                break;
    140140            }
    … …  
    150150                case 'c':
    151151                    if (toASCIILower(data[3]) == 'm')
    152                         return CSSPrimitiveValue::UnitTypes::CSS_DPCM;
     152                        return CSSPrimitiveValue::UnitType::CSS_DPCM;
    153153                    break;
    154154                case 'p':
    155155                    if (toASCIILower(data[3]) == 'x')
    156                         return CSSPrimitiveValue::UnitTypes::CSS_DPPX;
     156                        return CSSPrimitiveValue::UnitType::CSS_DPPX;
    157157                    break;
    158158                }
    … …  
    162162        case 'g':
    163163            if (toASCIILower(data[1]) == 'r' && toASCIILower(data[2]) == 'a' && toASCIILower(data[3]) == 'd')
    164                 return CSSPrimitiveValue::UnitTypes::CSS_GRAD;
     164                return CSSPrimitiveValue::UnitType::CSS_GRAD;
    165165            break;
    166166        case 't':
    167167            if (toASCIILower(data[1]) == 'u' && toASCIILower(data[2]) == 'r' && toASCIILower(data[3]) == 'n')
    168                 return CSSPrimitiveValue::UnitTypes::CSS_TURN;
     168                return CSSPrimitiveValue::UnitType::CSS_TURN;
    169169            break;
    170170        case 'v':
    … …  
    174174                case 'a':
    175175                    if (toASCIILower(data[3]) == 'x')
    176                         return CSSPrimitiveValue::UnitTypes::CSS_VMAX;
     176                        return CSSPrimitiveValue::UnitType::CSS_VMAX;
    177177                    break;
    178178                case 'i':
    179179                    if (toASCIILower(data[3]) == 'n')
    180                         return CSSPrimitiveValue::UnitTypes::CSS_VMIN;
     180                        return CSSPrimitiveValue::UnitType::CSS_VMIN;
    181181                    break;
    182182                }
    … …  
    190190        case '_':
    191191            if (toASCIILower(data[1]) == '_' && toASCIILower(data[2]) == 'q' && toASCIILower(data[3]) == 'e' && toASCIILower(data[4]) == 'm')
    192                 return CSSPrimitiveValue::UnitTypes::CSS_QUIRKY_EMS;
     192                return CSSPrimitiveValue::UnitType::CSS_QUIRKY_EMS;
    193193            break;
    194194        }
    195195        break;
    196196    }
    197     return CSSPrimitiveValue::UnitTypes::CSS_UNKNOWN;
    198 }
    199 
    200 static CSSPrimitiveValue::UnitTypes stringToUnitType(StringView stringView)
     197    return CSSPrimitiveValue::UnitType::CSS_UNKNOWN;
     198}
     199
     200static CSSPrimitiveValue::UnitType stringToUnitType(StringView stringView)
    201201{
    202202    if (stringView.is8Bit())
    … …  
    233233    , m_numericValueType(numericValueType)
    234234    , m_numericSign(sign)
    235     , m_unit(static_cast<unsigned>(CSSPrimitiveValue::UnitTypes::CSS_NUMBER))
     235    , m_unit(static_cast<unsigned>(CSSPrimitiveValue::UnitType::CSS_NUMBER))
    236236{
    237237    ASSERT(type == NumberToken);
    … …  
    268268    ASSERT(m_type == NumberToken);
    269269    m_type = PercentageToken;
    270     m_unit = static_cast<unsigned>(CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     270    m_unit = static_cast<unsigned>(CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
    271271}
    272272

  • trunk/Source/WebCore/css/parser/CSSParserToken.h

    r209314 r209758  
    128128    HashTokenType getHashTokenType() const { ASSERT(m_type == HashToken); return m_hashTokenType; }
    129129    BlockType getBlockType() const { return static_cast<BlockType>(m_blockType); }
    130     CSSPrimitiveValue::UnitTypes unitType() const { return static_cast<CSSPrimitiveValue::UnitTypes>(m_unit); }
     130    CSSPrimitiveValue::UnitType unitType() const { return static_cast<CSSPrimitiveValue::UnitType>(m_unit); }
    131131    UChar32 unicodeRangeStart() const { ASSERT(m_type == UnicodeRangeToken); return m_unicodeRange.start; }
    132132    UChar32 unicodeRangeEnd() const { ASSERT(m_type == UnicodeRangeToken); return m_unicodeRange.end; }
    … …  
    153153    unsigned m_numericValueType : 1; // NumericValueType
    154154    unsigned m_numericSign : 2; // NumericSign
    155     unsigned m_unit : 7; // CSSPrimitiveValue::UnitTypes
     155    unsigned m_unit : 7; // CSSPrimitiveValue::UnitType
    156156
    157157    bool valueDataCharRawEqual(const CSSParserToken& other) const;

  • trunk/Source/WebCore/css/parser/CSSPropertyParser.cpp

    r209718 r209758  
    387387        addProperty(CSSPropertyTransformOriginX, CSSPropertyTransformOrigin, resultX.releaseNonNull(), important);
    388388        addProperty(CSSPropertyTransformOriginY, CSSPropertyTransformOrigin, resultY.releaseNonNull(), important);
    389         addProperty(CSSPropertyTransformOriginZ, CSSPropertyTransformOrigin, resultZ ? resultZ.releaseNonNull() : CSSValuePool::singleton().createValue(0, CSSPrimitiveValue::UnitTypes::CSS_PX), important, !hasZ);
     389        addProperty(CSSPropertyTransformOriginZ, CSSPropertyTransformOrigin, resultZ ? resultZ.releaseNonNull() : CSSValuePool::singleton().createValue(0, CSSPrimitiveValue::UnitType::CSS_PX), important, !hasZ);
    390390       
    391391        return true;
    … …  
    10421042        if (RefPtr<CSSPrimitiveValue> counterValue = consumeInteger(range))
    10431043            i = counterValue->intValue();
    1044         list->append(createPrimitiveValuePair(counterName.releaseNonNull(), CSSPrimitiveValue::create(i, CSSPrimitiveValue::UnitTypes::CSS_NUMBER), Pair::IdenticalValueEncoding::Coalesce));
     1044        list->append(createPrimitiveValuePair(counterName.releaseNonNull(), CSSPrimitiveValue::create(i, CSSPrimitiveValue::UnitType::CSS_NUMBER), Pair::IdenticalValueEncoding::Coalesce));
    10451045    } while (!range.atEnd());
    10461046    return list;
    … …  
    12941294            return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);
    12951295        // FIXME-NEWPARSER: Want to use a CSSCustomIdentValue here eventually.
    1296         return CSSValuePool::singleton().createValue(token.value().toString(), CSSPrimitiveValue::UnitTypes::CSS_STRING);
     1296        return CSSValuePool::singleton().createValue(token.value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
    12971297    }
    12981298
    … …  
    17521752        if (!consumeNumberRaw(args, perspective) || perspective < 0)
    17531753            return false;
    1754         parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitTypes::CSS_PX);
     1754        parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitType::CSS_PX);
    17551755    }
    17561756    if (!parsedValue)
    … …  
    19381938            return nullptr;
    19391939        range.consumeIncludingWhitespace();
    1940         return CSSPrimitiveValue::create(percent, CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     1940        return CSSPrimitiveValue::create(percent, CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
    19411941    }
    19421942    return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll);
    … …  
    21612161    RefPtr<CSSPrimitiveValue> separator;
    21622162    if (!counters)
    2163         separator = CSSPrimitiveValue::create(String(), CSSPrimitiveValue::UnitTypes::CSS_STRING);
     2163        separator = CSSPrimitiveValue::create(String(), CSSPrimitiveValue::UnitType::CSS_STRING);
    21642164    else {
    21652165        if (!consumeCommaIncludingWhitespace(args) || args.peek().type() != StringToken)
    21662166            return nullptr;
    2167         separator = CSSPrimitiveValue::create(args.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitTypes::CSS_STRING);
     2167        separator = CSSPrimitiveValue::create(args.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
    21682168    }
    21692169
    … …  
    22232223        if (!consumeNumberRaw(range, perspective))
    22242224            return nullptr;
    2225         parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitTypes::CSS_PX);
     2225        parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitType::CSS_PX);
    22262226    }
    22272227    if (parsedValue && (parsedValue->isCalculated() || parsedValue->doubleValue() > 0))
    … …  
    27832783    RefPtr<CSSPrimitiveValue> offset;
    27842784    if (range.atEnd())
    2785         offset = CSSValuePool::singleton().createValue(0, CSSPrimitiveValue::UnitTypes::CSS_PX);
     2785        offset = CSSValuePool::singleton().createValue(0, CSSPrimitiveValue::UnitType::CSS_PX);
    27862786    else {
    27872787        offset = consumeLengthOrPercent(range, context.mode, ValueRangeAll, UnitlessQuirk::Forbid);
    … …  
    32043204    if (identMatches<CSSValueWebkitMinContent, CSSValueWebkitMaxContent, CSSValueAuto>(token.id()))
    32053205        return consumeIdent(range);
    3206     if (token.type() == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitTypes::CSS_FR) {
     3206    if (token.type() == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitType::CSS_FR) {
    32073207        if (range.peek().numericValue() < 0)
    32083208            return nullptr;
    3209         return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitTypes::CSS_FR);
     3209        return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_FR);
    32103210    }
    32113211    return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
    … …  
    46774677                    flexShrink = num;
    46784678                else if (!num) // flex only allows a basis of 0 (sans units) if flex-grow and flex-shrink values have already been set.
    4679                     flexBasis = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitTypes::CSS_PX);
     4679                    flexBasis = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::CSS_PX);
    46804680                else
    46814681                    return false;
    … …  
    46964696            flexShrink = 1;
    46974697        if (!flexBasis)
    4698             flexBasis = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitTypes::CSS_PX);
     4698            flexBasis = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::CSS_PX);
    46994699    }
    47004700
    47014701    if (!m_range.atEnd())
    47024702        return false;
    4703     addProperty(CSSPropertyFlexGrow, CSSPropertyFlex, CSSPrimitiveValue::create(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitTypes::CSS_NUMBER), important);
    4704     addProperty(CSSPropertyFlexShrink, CSSPropertyFlex, CSSPrimitiveValue::create(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitTypes::CSS_NUMBER), important);
     4703    addProperty(CSSPropertyFlexGrow, CSSPropertyFlex, CSSPrimitiveValue::create(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitType::CSS_NUMBER), important);
     4704    addProperty(CSSPropertyFlexShrink, CSSPropertyFlex, CSSPrimitiveValue::create(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitType::CSS_NUMBER), important);
    47054705    addProperty(CSSPropertyFlexBasis, CSSPropertyFlex, flexBasis.releaseNonNull(), important);
    47064706    return true;

  • trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp

    r209531 r209758  
    101101            return nullptr;
    102102        m_sourceRange = m_range;
    103         return CSSValuePool::singleton().createValue(m_calcValue->doubleValue(), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     103        return CSSValuePool::singleton().createValue(m_calcValue->doubleValue(), CSSPrimitiveValue::UnitType::CSS_NUMBER);
    104104    }
    105105
    … …  
    136136        if (token.numericValueType() == NumberValueType || token.numericValue() < minimumValue)
    137137            return nullptr;
    138         return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     138        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_NUMBER);
    139139    }
    140140    CalcParser calcParser(range);
    … …  
    211211    if (token.type() == DimensionToken) {
    212212        switch (token.unitType()) {
    213         case CSSPrimitiveValue::UnitTypes::CSS_QUIRKY_EMS:
     213        case CSSPrimitiveValue::UnitType::CSS_QUIRKY_EMS:
    214214            if (cssParserMode != UASheetMode)
    215215                return nullptr;
    216216            FALLTHROUGH;
    217         case CSSPrimitiveValue::UnitTypes::CSS_EMS:
    218         case CSSPrimitiveValue::UnitTypes::CSS_REMS:
    219         case CSSPrimitiveValue::UnitTypes::CSS_CHS:
    220         case CSSPrimitiveValue::UnitTypes::CSS_EXS:
    221         case CSSPrimitiveValue::UnitTypes::CSS_PX:
    222         case CSSPrimitiveValue::UnitTypes::CSS_CM:
    223         case CSSPrimitiveValue::UnitTypes::CSS_MM:
    224         case CSSPrimitiveValue::UnitTypes::CSS_IN:
    225         case CSSPrimitiveValue::UnitTypes::CSS_PT:
    226         case CSSPrimitiveValue::UnitTypes::CSS_PC:
    227         case CSSPrimitiveValue::UnitTypes::CSS_VW:
    228         case CSSPrimitiveValue::UnitTypes::CSS_VH:
    229         case CSSPrimitiveValue::UnitTypes::CSS_VMIN:
    230         case CSSPrimitiveValue::UnitTypes::CSS_VMAX:
     217        case CSSPrimitiveValue::UnitType::CSS_EMS:
     218        case CSSPrimitiveValue::UnitType::CSS_REMS:
     219        case CSSPrimitiveValue::UnitType::CSS_CHS:
     220        case CSSPrimitiveValue::UnitType::CSS_EXS:
     221        case CSSPrimitiveValue::UnitType::CSS_PX:
     222        case CSSPrimitiveValue::UnitType::CSS_CM:
     223        case CSSPrimitiveValue::UnitType::CSS_MM:
     224        case CSSPrimitiveValue::UnitType::CSS_IN:
     225        case CSSPrimitiveValue::UnitType::CSS_PT:
     226        case CSSPrimitiveValue::UnitType::CSS_PC:
     227        case CSSPrimitiveValue::UnitType::CSS_VW:
     228        case CSSPrimitiveValue::UnitType::CSS_VH:
     229        case CSSPrimitiveValue::UnitType::CSS_VMIN:
     230        case CSSPrimitiveValue::UnitType::CSS_VMAX:
    231231            break;
    232232        default:
    … …  
    243243        if (std::isinf(token.numericValue()))
    244244            return nullptr;
    245         CSSPrimitiveValue::UnitTypes unitType = CSSPrimitiveValue::UnitTypes::CSS_PX;
     245        CSSPrimitiveValue::UnitType unitType = CSSPrimitiveValue::UnitType::CSS_PX;
    246246        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), unitType);
    247247    }
    … …  
    258258        if ((valueRange == ValueRangeNonNegative && token.numericValue() < 0) || std::isinf(token.numericValue()))
    259259            return nullptr;
    260         return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     260        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
    261261    }
    262262    CalcParser calcParser(range, valueRange);
    … …  
    302302    if (token.type() == DimensionToken) {
    303303        switch (token.unitType()) {
    304         case CSSPrimitiveValue::UnitTypes::CSS_DEG:
    305         case CSSPrimitiveValue::UnitTypes::CSS_RAD:
    306         case CSSPrimitiveValue::UnitTypes::CSS_GRAD:
    307         case CSSPrimitiveValue::UnitTypes::CSS_TURN:
     304        case CSSPrimitiveValue::UnitType::CSS_DEG:
     305        case CSSPrimitiveValue::UnitType::CSS_RAD:
     306        case CSSPrimitiveValue::UnitType::CSS_GRAD:
     307        case CSSPrimitiveValue::UnitType::CSS_TURN:
    308308            return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), token.unitType());
    309309        default:
    … …  
    312312    }
    313313    if (token.type() == NumberToken && shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless)) {
    314         return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitTypes::CSS_DEG);
     314        return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::CSS_DEG);
    315315    }
    316316
    … …  
    326326{
    327327    const CSSParserToken& token = range.peek();
    328     CSSPrimitiveValue::UnitTypes unit = token.unitType();
     328    CSSPrimitiveValue::UnitType unit = token.unitType();
    329329    bool acceptUnitless = token.type() == NumberToken && shouldAcceptUnitlessValue(token.numericValue(), cssParserMode, unitless);
    330330    if (acceptUnitless)
    331         unit = CSSPrimitiveValue::UnitTypes::CSS_MS;
     331        unit = CSSPrimitiveValue::UnitType::CSS_MS;
    332332    if (token.type() == DimensionToken || acceptUnitless) {
    333333        if (valueRange == ValueRangeNonNegative && token.numericValue() < 0)
    334334            return nullptr;
    335         if (unit == CSSPrimitiveValue::UnitTypes::CSS_MS || unit == CSSPrimitiveValue::UnitTypes::CSS_S)
     335        if (unit == CSSPrimitiveValue::UnitType::CSS_MS || unit == CSSPrimitiveValue::UnitType::CSS_S)
    336336            return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().numericValue(), unit);
    337337        return nullptr;
    … …  
    366366    if (range.peek().type() != IdentToken || isCSSWideKeyword(range.peek().id()))
    367367        return nullptr;
    368     return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitTypes::CSS_STRING);
     368    return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
    369369}
    370370
    … …  
    373373    if (range.peek().type() != StringToken)
    374374        return nullptr;
    375     return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitTypes::CSS_STRING);
     375    return CSSValuePool::singleton().createValue(range.consumeIncludingWhitespace().value().toString(), CSSPrimitiveValue::UnitType::CSS_STRING);
    376376}
    377377
    … …  
    403403    if (url.isNull())
    404404        return nullptr;
    405     return CSSValuePool::singleton().createValue(url.toString(), CSSPrimitiveValue::UnitTypes::CSS_URI);
     405    return CSSValuePool::singleton().createValue(url.toString(), CSSPrimitiveValue::UnitType::CSS_URI);
    406406}
    407407
    … …  
    759759    if (args.peek().type() == IdentToken) {
    760760        if ((horizontal && consumeIdent<CSSValueLeft>(args)) || (!horizontal && consumeIdent<CSSValueTop>(args)))
    761             return CSSValuePool::singleton().createValue(0., CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     761            return CSSValuePool::singleton().createValue(0., CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
    762762        if ((horizontal && consumeIdent<CSSValueRight>(args)) || (!horizontal && consumeIdent<CSSValueBottom>(args)))
    763             return CSSValuePool::singleton().createValue(100., CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     763            return CSSValuePool::singleton().createValue(100., CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
    764764        if (consumeIdent<CSSValueCenter>(args))
    765             return CSSValuePool::singleton().createValue(50., CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE);
     765            return CSSValuePool::singleton().createValue(50., CSSPrimitiveValue::UnitType::CSS_PERCENTAGE);
    766766        return nullptr;
    767767    }
    … …  
    804804    }
    805805
    806     stop.m_position = CSSValuePool::singleton().createValue(position, CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     806    stop.m_position = CSSValuePool::singleton().createValue(position, CSSPrimitiveValue::UnitType::CSS_NUMBER);
    807807    stop.m_color = consumeDeprecatedGradientStopColor(args, cssParserMode);
    808808    return stop.m_color && args.atEnd();
    … …  
    10821082    const CSSParserToken& percentageArg = args.consumeIncludingWhitespace();
    10831083    if (percentageArg.type() == PercentageToken)
    1084         percentage = CSSValuePool::singleton().createValue(clampTo<double>(percentageArg.numericValue() / 100, 0, 1), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     1084        percentage = CSSValuePool::singleton().createValue(clampTo<double>(percentageArg.numericValue() / 100, 0, 1), CSSPrimitiveValue::UnitType::CSS_NUMBER);
    10851085    else if (percentageArg.type() == NumberToken)
    1086         percentage = CSSValuePool::singleton().createValue(clampTo<double>(percentageArg.numericValue(), 0, 1), CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     1086        percentage = CSSValuePool::singleton().createValue(clampTo<double>(percentageArg.numericValue(), 0, 1), CSSPrimitiveValue::UnitType::CSS_NUMBER);
    10871087
    10881088    if (!percentage)
    … …  
    11841184        if (token.value() != "x")
    11851185            return nullptr;
    1186         ASSERT(token.unitType() == CSSPrimitiveValue::UnitTypes::CSS_UNKNOWN);
     1186        ASSERT(token.unitType() == CSSPrimitiveValue::UnitType::CSS_UNKNOWN);
    11871187        double imageScaleFactor = token.numericValue();
    11881188        if (imageScaleFactor <= 0)
    11891189            return nullptr;
    1190         imageSet->append(CSSValuePool::singleton().createValue(imageScaleFactor, CSSPrimitiveValue::UnitTypes::CSS_NUMBER));
     1190        imageSet->append(CSSValuePool::singleton().createValue(imageScaleFactor, CSSPrimitiveValue::UnitType::CSS_NUMBER));
    11911191    } while (consumeCommaIncludingWhitespace(args));
    11921192    if (!args.atEnd())
    … …  
    12551255                double maxAllowed = isPercentage ? 100.0 : 1.0;
    12561256                if (downcast<CSSPrimitiveValue>(*parsedValue).doubleValue() > maxAllowed)
    1257                     parsedValue = CSSPrimitiveValue::create(maxAllowed, isPercentage ? CSSPrimitiveValue::UnitTypes::CSS_PERCENTAGE : CSSPrimitiveValue::UnitTypes::CSS_NUMBER);
     1257                    parsedValue = CSSPrimitiveValue::create(maxAllowed, isPercentage ? CSSPrimitiveValue::UnitType::CSS_PERCENTAGE : CSSPrimitiveValue::UnitType::CSS_NUMBER);
    12581258            }
    12591259        }

  • trunk/Source/WebCore/css/parser/MediaQueryParser.cpp

    r209726 r209758  
    185185void MediaQueryParser::readFeatureValue(CSSParserTokenType type, const CSSParserToken& token)
    186186{
    187     if (type == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitTypes::CSS_UNKNOWN)
     187    if (type == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitType::CSS_UNKNOWN)
    188188        m_state = SkipUntilComma;
    189189    else {

  • trunk/Source/WebCore/css/parser/SizesAttributeParser.cpp

    r209466 r209758  
    4141namespace WebCore {
    4242
    43 float SizesAttributeParser::computeLength(double value, CSSPrimitiveValue::UnitTypes type, const Document& document)
     43float SizesAttributeParser::computeLength(double value, CSSPrimitiveValue::UnitType type, const Document& document)
    4444{
    4545    auto* renderer = document.renderView();

  • trunk/Source/WebCore/css/parser/SizesAttributeParser.h

    r205905 r209758  
    4646
    4747    static float defaultLength(const Document&);
    48     static float computeLength(double value, CSSPrimitiveValue::UnitTypes, const Document&);
     48    static float computeLength(double value, CSSPrimitiveValue::UnitType, const Document&);
    4949
    5050private:

  • trunk/Source/WebCore/dom/StyledElement.cpp

    r208485 r209758  
    252252}
    253253
    254 bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitTypes unit, bool important)
     254bool StyledElement::setInlineStyleProperty(CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitType unit, bool important)
    255255{
    256256    ensureMutableInlineStyle().setProperty(propertyID, CSSValuePool::singleton().createValue(value, unit), important);
    … …  
    389389}
    390390
    391 void StyledElement::addPropertyToPresentationAttributeStyle(MutableStyleProperties& style, CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitTypes unit)
     391void StyledElement::addPropertyToPresentationAttributeStyle(MutableStyleProperties& style, CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitType unit)
    392392{
    393393    style.setProperty(propertyID, CSSValuePool::singleton().createValue(value, unit));

  • trunk/Source/WebCore/dom/StyledElement.h

    r208179 r209758  
    5050    bool setInlineStyleProperty(CSSPropertyID, CSSValueID identifier, bool important = false);
    5151    bool setInlineStyleProperty(CSSPropertyID, CSSPropertyID identifier, bool important = false);
    52     WEBCORE_EXPORT bool setInlineStyleProperty(CSSPropertyID, double value, CSSPrimitiveValue::UnitTypes, bool important = false);
     52    WEBCORE_EXPORT bool setInlineStyleProperty(CSSPropertyID, double value, CSSPrimitiveValue::UnitType, bool important = false);
    5353    WEBCORE_EXPORT bool setInlineStyleProperty(CSSPropertyID, const String& value, bool important = false);
    5454    bool removeInlineStyleProperty(CSSPropertyID);
    … …  
    7676
    7777    void addPropertyToPresentationAttributeStyle(MutableStyleProperties&, CSSPropertyID, CSSValueID identifier);
    78     void addPropertyToPresentationAttributeStyle(MutableStyleProperties&, CSSPropertyID, double value, CSSPrimitiveValue::UnitTypes);
     78    void addPropertyToPresentationAttributeStyle(MutableStyleProperties&, CSSPropertyID, double value, CSSPrimitiveValue::UnitType);
    7979    void addPropertyToPresentationAttributeStyle(MutableStyleProperties&, CSSPropertyID, const String& value);
    8080

  • trunk/Source/WebCore/svg/SVGLengthValue.cpp

    r208705 r209758  
    313313Ref<CSSPrimitiveValue> SVGLengthValue::toCSSPrimitiveValue(const SVGLengthValue& length)
    314314{
    315     CSSPrimitiveValue::UnitTypes cssType = CSSPrimitiveValue::CSS_UNKNOWN;
     315    CSSPrimitiveValue::UnitType cssType = CSSPrimitiveValue::CSS_UNKNOWN;
    316316    switch (length.unitType()) {
    317317    case LengthTypeUnknown:
Note: See TracChangeset for help on using the changeset viewer.