Make UseCounters work on aliased properties

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 80 matching lines @@
     , m_context(context)
     , m_inViewport(inViewport)
     , m_parsedProperties(parsedProperties)
     , m_ruleType(ruleType)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
 {
 }
 
-bool CSSPropertyParser::parseValue(CSSPropertyID property, bool important,
+bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,
     CSSParserValueList* valueList, const CSSParserContext& context, bool inViewport,
     WillBeHeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
 {
     int parsedPropertiesSize = parsedProperties.size();
 
     CSSPropertyParser parser(valueList, context, inViewport, parsedProperties, ruleType);
-    bool parseSuccess = parser.parseValue(property, important);
+    bool parseSuccess = parser.parseValue(unresolvedProperty, important);
 
     // This doesn't count UA style sheets
     if (parseSuccess && context.useCounter())
-        context.useCounter()->count(context, property);
+        context.useCounter()->count(context, unresolvedProperty);
 
     if (!parseSuccess)
         parser.rollbackLastProperties(parsedProperties.size() - parsedPropertiesSize);
 
     return parseSuccess;
 }
 
 void CSSPropertyParser::addPropertyWithPrefixingVariant(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> value, bool important, bool implicit)
 {
     RefPtrWillBeRawPtr<CSSValue> val = value.get();
     addProperty(propId, value, important, implicit);
 
     CSSPropertyID prefixingVariant = prefixingVariantForPropertyId(propId);
     if (prefixingVariant == propId)
         return;
 
     if (m_currentShorthand) {
         // We can't use ShorthandScope here as we can already be inside one (e.g we are parsing CSSTransition).
         m_currentShorthand = prefixingVariantForPropertyId(m_currentShorthand);
         addProperty(prefixingVariant, val.release(), important, implicit);
         m_currentShorthand = prefixingVariantForPropertyId(m_currentShorthand);
     } else {
         addProperty(prefixingVariant, val.release(), important, implicit);
     }
 }
 
 void CSSPropertyParser::addProperty(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> value, bool important, bool implicit)
 {
+    ASSERT(!isPropertyAlias(propId));
+
     int shorthandIndex = 0;
     bool setFromShorthand = false;
 
     if (m_currentShorthand) {
         Vector<StylePropertyShorthand, 4> shorthands;
         getMatchingShorthandsForLonghand(propId, &shorthands);
         // Viewport descriptors have width and height as shorthands, but it doesn't
         // make sense for CSSProperties.in to consider them as such. The shorthand
         // index is only used by the inspector and doesn't affect viewport
         // descriptors.
@@ skipping 264 matching lines @@
         return;
     }
 
     RefPtrWillBeRawPtr<CSSValue> value = prpValue;
     ShorthandScope scope(this, propId);
     const CSSPropertyID* longhands = shorthand.properties();
     for (unsigned i = 0; i < shorthandLength; ++i)
         addPropertyWithPrefixingVariant(longhands[i], value, important);
 }
 
-bool CSSPropertyParser::parseValue(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important)
 {
+    CSSPropertyID propId = resolveCSSPropertyID(unresolvedProperty);
+
     if (!m_valueList)
         return false;
 
     CSSParserValue* value = m_valueList->current();
 
     if (!value)
         return false;
 
     if (inViewport()) {
         // Allow @viewport rules from UA stylesheets even if the feature is disabled.
@@ skipping 2574 matching lines @@
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationProperty()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
     // Since all is valid css property keyword, cssPropertyID for all
     // returns non-null value. We need to check "all" before
     // cssPropertyID check.
     if (value->id == CSSValueAll)
         return cssValuePool().createIdentifierValue(CSSValueAll);
-    CSSPropertyID property = cssPropertyID(value->string);
+    CSSPropertyID property = unresolvedCSSPropertyID(value->string);
     if (property) {
         ASSERT(CSSPropertyMetadata::isEnabledProperty(property));
         return cssValuePool().createIdentifierValue(property);
     }
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (value->id == CSSValueInitial || value->id == CSSValueInherit)
         return nullptr;
     return createPrimitiveCustomIdentValue(value);
 }
@@ skipping 4124 matching lines @@
         return values.release();
     }
 
     // Every comma-separated list of CSS_IDENTs is a valid will-change value,
     // unless the list includes an explicitly disallowed CSS_IDENT.
     while (true) {
         CSSParserValue* currentValue = m_valueList->current();
         if (!currentValue || currentValue->unit != CSSPrimitiveValue::CSS_IDENT)
             return nullptr;
 
-        CSSPropertyID property = cssPropertyID(currentValue->string);
-        if (property) {
-            ASSERT(CSSPropertyMetadata::isEnabledProperty(property));
+        CSSPropertyID unresolvedProperty = unresolvedCSSPropertyID(currentValue->string);
+        if (unresolvedProperty) {
+            ASSERT(CSSPropertyMetadata::isEnabledProperty(unresolvedProperty));
             // Now "all" is used by both CSSValue and CSSPropertyValue.
             // Need to return nullptr when currentValue is CSSPropertyAll.
-            if (property == CSSPropertyWillChange || property == CSSPropertyAll)
+            if (unresolvedProperty == CSSPropertyWillChange || unresolvedProperty == CSSPropertyAll)
                 return nullptr;
-            values->append(cssValuePool().createIdentifierValue(property));
+            values->append(cssValuePool().createIdentifierValue(unresolvedProperty));
         } else {
             switch (currentValue->id) {
             case CSSValueNone:
             case CSSValueAll:
             case CSSValueAuto:
             case CSSValueDefault:
             case CSSValueInitial:
             case CSSValueInherit:
                 return nullptr;
             case CSSValueContents:
@@ skipping 618 matching lines @@
 
     // If just one value is supplied, the second value
     // is implicitly initialized with the first value.
     if (numValues == 1)
         m_valueList->previous();
 
     return parseViewportProperty(second, important);
 }
 
 template <typename CharacterType>
-static CSSPropertyID cssPropertyID(const CharacterType* propertyName, unsigned length)
+static CSSPropertyID unresolvedCSSPropertyID(const CharacterType* propertyName, unsigned length)
 {
     char buffer[maxCSSPropertyNameLength + 1]; // 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
         CharacterType c = propertyName[i];
         if (c == 0 || c >= 0x7F)
             return CSSPropertyInvalid; // illegal character
         buffer[i] = toASCIILower(c);
     }
     buffer[length] = '\0';
 
     const char* name = buffer;
     const Property* hashTableEntry = findProperty(name, length);
     if (!hashTableEntry)
         return CSSPropertyInvalid;
     CSSPropertyID property = static_cast<CSSPropertyID>(hashTableEntry->id);
     if (!CSSPropertyMetadata::isEnabledProperty(property))
         return CSSPropertyInvalid;
     return property;
 }
 
-CSSPropertyID cssPropertyID(const String& string)
+CSSPropertyID unresolvedCSSPropertyID(const String& string)
 {
     unsigned length = string.length();
 
     if (!length)
         return CSSPropertyInvalid;
     if (length > maxCSSPropertyNameLength)
         return CSSPropertyInvalid;
 
-    return string.is8Bit() ? cssPropertyID(string.characters8(), length) : cssPropertyID(string.characters16(), length);
+    return string.is8Bit() ? unresolvedCSSPropertyID(string.characters8(), length) : unresolvedCSSPropertyID(string.characters16(), length);
 }
 
-CSSPropertyID cssPropertyID(const CSSParserString& string)
+CSSPropertyID cssPropertyID(const String& string)
+{
+    return resolveCSSPropertyID(unresolvedCSSPropertyID(string));
+}
+
+CSSPropertyID unresolvedCSSPropertyID(const CSSParserString& string)
 {
     unsigned length = string.length();
 
     if (!length)
         return CSSPropertyInvalid;
     if (length > maxCSSPropertyNameLength)
         return CSSPropertyInvalid;
 
-    return string.is8Bit() ? cssPropertyID(string.characters8(), length) : cssPropertyID(string.characters16(), length);
+    return string.is8Bit() ? unresolvedCSSPropertyID(string.characters8(), length) : unresolvedCSSPropertyID(string.characters16(), length);
 }
 
 template <typename CharacterType>
 static CSSValueID cssValueKeywordID(const CharacterType* valueKeyword, unsigned length)
 {
     char buffer[maxCSSValueKeywordLength + 1]; // 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
         CharacterType c = valueKeyword[i];
         if (c == 0 || c >= 0x7F)
@@ skipping 619 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink