Pass around shorthand info instead of storing it

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
@@ skipping 36 matching lines @@
 
 namespace blink {
 
 using namespace CSSPropertyParserHelpers;
 
 CSSPropertyParser::CSSPropertyParser(const CSSParserTokenRange& range,
     const CSSParserContext& context, HeapVector<CSSProperty, 256>* parsedProperties)
     : m_range(range)
     , m_context(context)
     , m_parsedProperties(parsedProperties)
-    , m_inParseShorthand(0)
-    , m_currentShorthand(CSSPropertyInvalid)
 {
     m_range.consumeWhitespace();
 }
 
-void CSSPropertyParser::addProperty(CSSPropertyID property, CSSValue* value, bool important, bool implicit)
+void CSSPropertyParser::addProperty(CSSPropertyID property, CSSPropertyID currentShorthand, CSSValue* value, bool important, bool implicit)
 {
     ASSERT(!isPropertyAlias(property));
 
     int shorthandIndex = 0;
     bool setFromShorthand = false;
 
-    if (m_currentShorthand) {
+    if (currentShorthand) {
         Vector<StylePropertyShorthand, 4> shorthands;
         getMatchingShorthandsForLonghand(property, &shorthands);
         setFromShorthand = true;
         if (shorthands.size() > 1)
-            shorthandIndex = indexOfShorthandForLonghand(m_currentShorthand, shorthands);
+            shorthandIndex = indexOfShorthandForLonghand(currentShorthand, shorthands);
     }
 
     m_parsedProperties->append(CSSProperty(property, value, important, setFromShorthand, shorthandIndex, implicit));
 }
 
 void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID property, CSSValue* value, bool important)
 {
     const StylePropertyShorthand& shorthand = shorthandForProperty(property);
     unsigned shorthandLength = shorthand.length();
-    if (!shorthandLength) {
-        addProperty(property, value, important);
-        return;
-    }
-
-    ShorthandScope scope(this, property);
+    ASSERT(shorthandLength);
     const CSSPropertyID* longhands = shorthand.properties();
     for (unsigned i = 0; i < shorthandLength; ++i)
-        addProperty(longhands[i], value, important);
+        addProperty(longhands[i], property, value, important);
 }
 
 static bool hasInvalidNumericValues(const CSSParserTokenRange& range)
 {
     for (const CSSParserToken& token : range) {
         CSSParserTokenType type = token.type();
         if ((type == NumberToken || type == DimensionToken || type == PercentageToken)
             && !CSSPropertyParser::isValidNumericValue(token.numericValue()))
             return true;
     }
@@ skipping 57 matching lines @@
 
     CSSParserTokenRange originalRange = m_range;
     CSSPropertyID propertyId = resolveCSSPropertyID(unresolvedProperty);
 
     if (isShorthandProperty(propertyId)) {
         if (parseShorthand(unresolvedProperty, important))
             return true;
     } else {
         if (CSSValue* parsedValue = parseSingleValue(unresolvedProperty)) {
             if (m_range.atEnd()) {
-                addProperty(propertyId, parsedValue, important);
+                addProperty(propertyId, CSSPropertyInvalid, parsedValue, important);
                 return true;
             }
         }
     }
 
     if (RuntimeEnabledFeatures::cssVariablesEnabled() && CSSVariableParser::containsValidVariableReferences(originalRange)) {
         // We don't expand the shorthand here because crazypants.
         CSSVariableReferenceValue* variable = CSSVariableReferenceValue::create(CSSVariableData::create(originalRange));
-        addProperty(propertyId, variable, important);
+        addProperty(propertyId, CSSPropertyInvalid, variable, important);
         return true;
     }
 
     return false;
 }
 
 bool CSSPropertyParser::isColorKeyword(CSSValueID id)
 {
     // Named colors and color keywords:
     //
@@ skipping 112 matching lines @@
     CSSValue* value = nullptr;
     if (id == CSSValueInitial)
         value = cssValuePool().createExplicitInitialValue();
     else if (id == CSSValueInherit)
         value = cssValuePool().createInheritedValue();
     else if (id == CSSValueUnset)
         value = cssValuePool().createUnsetValue();
     else
         return false;
 
-    addExpandedPropertyForValue(resolveCSSPropertyID(unresolvedProperty), value, important);
+    CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
+    const StylePropertyShorthand& shorthand = shorthandForProperty(property);
+    if (!shorthand.length())
+        addProperty(property, CSSPropertyInvalid, value, important);
+    else
+        addExpandedPropertyForValue(property, value, important);
     m_range = rangeCopy;
     return true;
 }
 
 static CSSValueList* consumeTransformOrigin(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     CSSValue* resultX = nullptr;
     CSSValue* resultY = nullptr;
     if (consumeOneOrTwoValuedPosition(range, cssParserMode, unitless, resultX, resultY)) {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
@@ skipping 888 matching lines @@
             parsedLonghand[i] = false;
         }
     } while (consumeCommaIncludingWhitespace(m_range));
 
     for (size_t i = 0; i < longhandCount; ++i) {
         if (!isValidAnimationPropertyList(shorthand.properties()[i], *longhands[i]))
             return false;
     }
 
     for (size_t i = 0; i < longhandCount; ++i)
-        addProperty(shorthand.properties()[i], longhands[i], important);
+        addProperty(shorthand.properties()[i], shorthand.id(), longhands[i], important);
 
     return m_range.atEnd();
 }
 
 static CSSValue* consumeZIndex(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
     return consumeInteger(range);
 }
@@ skipping 2185 matching lines @@
             return nullptr;
         ++rowCount;
     }
 
     if (rowCount == 0)
         return nullptr;
     ASSERT(columnCount);
     return CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount);
 }
 
-CSSValue* CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
+CSSValue* CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty, CSSPropertyID currentShorthand)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
     if (CSSParserFastPaths::isKeywordPropertyID(property)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(property, m_range.peek().id(), m_context.mode()))
             return nullptr;
         return consumeIdent(m_range);
     }
     switch (property) {
     case CSSPropertyWillChange:
         return consumeWillChange(m_range);
@@ skipping 155 matching lines @@
     case CSSPropertyWebkitBorderStartWidth:
     case CSSPropertyWebkitBorderEndWidth:
     case CSSPropertyWebkitBorderBeforeWidth:
     case CSSPropertyWebkitBorderAfterWidth:
         return consumeBorderWidth(m_range, m_context.mode(), UnitlessQuirk::Forbid);
     case CSSPropertyBorderBottomColor:
     case CSSPropertyBorderLeftColor:
     case CSSPropertyBorderRightColor:
     case CSSPropertyBorderTopColor: {
         bool allowQuirkyColors = inQuirksMode()
-            && (m_currentShorthand == CSSPropertyInvalid || m_currentShorthand == CSSPropertyBorderColor);
+            && (currentShorthand == CSSPropertyInvalid || currentShorthand == CSSPropertyBorderColor);
         return consumeColor(m_range, m_context.mode(), allowQuirkyColors);
     }
     case CSSPropertyBorderBottomWidth:
     case CSSPropertyBorderLeftWidth:
     case CSSPropertyBorderRightWidth:
     case CSSPropertyBorderTopWidth: {
         bool allowQuirkyLengths = inQuirksMode()
-            && (m_currentShorthand == CSSPropertyInvalid || m_currentShorthand == CSSPropertyBorderWidth);
+            && (currentShorthand == CSSPropertyInvalid || currentShorthand == CSSPropertyBorderWidth);
         UnitlessQuirk unitless = allowQuirkyLengths ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid;
         return consumeBorderWidth(m_range, m_context.mode(), unitless);
     }
     case CSSPropertyZIndex:
         return consumeZIndex(m_range);
     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
     case CSSPropertyBoxShadow:
         return consumeShadow(m_range, m_context.mode(), property == CSSPropertyBoxShadow);
     case CSSPropertyWebkitFilter:
     case CSSPropertyBackdropFilter:
@@ skipping 301 matching lines @@
     case CSSPropertyFontFeatureSettings:
         parsedValue = consumeFontFeatureSettings(m_range);
         break;
     default:
         break;
     }
 
     if (!parsedValue || !m_range.atEnd())
         return false;
 
-    addProperty(propId, parsedValue, false);
+    addProperty(propId, CSSPropertyInvalid, parsedValue, false);
     return true;
 }
 
 bool CSSPropertyParser::consumeSystemFont(bool important)
 {
     CSSValueID systemFontID = m_range.consumeIncludingWhitespace().id();
     ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
     if (!m_range.atEnd())
         return false;
 
     FontStyle fontStyle = FontStyleNormal;
     FontWeight fontWeight = FontWeightNormal;
     float fontSize = 0;
     AtomicString fontFamily;
     LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize, fontFamily);
 
-    addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
-    addProperty(CSSPropertyFontWeight, cssValuePool().createValue(fontWeight), important);
-    addProperty(CSSPropertyFontSize, cssValuePool().createValue(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
+    addProperty(CSSPropertyFontStyle, CSSPropertyFont, cssValuePool().createIdentifierValue(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, CSSPropertyFont, cssValuePool().createValue(fontWeight), important);
+    addProperty(CSSPropertyFontSize, CSSPropertyFont, cssValuePool().createValue(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
     CSSValueList* fontFamilyList = CSSValueList::createCommaSeparated();
     fontFamilyList->append(cssValuePool().createFontFamilyValue(fontFamily));
-    addProperty(CSSPropertyFontFamily, fontFamilyList, important);
+    addProperty(CSSPropertyFontFamily, CSSPropertyFont, fontFamilyList, important);
 
-    addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(CSSValueNormal), important);
-    addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStretch, CSSPropertyFont, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariant, CSSPropertyFont, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyLineHeight, CSSPropertyFont, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     return true;
 }
 
 bool CSSPropertyParser::consumeFont(bool important)
 {
     // Let's check if there is an inherit or initial somewhere in the shorthand.
     CSSParserTokenRange range = m_range;
     while (!range.atEnd()) {
         CSSValueID id = range.consumeIncludingWhitespace().id();
         if (id == CSSValueInherit || id == CSSValueInitial)
@@ skipping 24 matching lines @@
         }
         if (!fontStretch && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStretch, id, m_context.mode()))
             fontStretch = consumeIdent(m_range);
         else
             break;
     }
 
     if (m_range.atEnd())
         return false;
 
-    addProperty(CSSPropertyFontStyle, fontStyle ? fontStyle : cssValuePool().createIdentifierValue(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariant, fontVariant ? fontVariant : cssValuePool().createIdentifierValue(CSSValueNormal), important);
-    addProperty(CSSPropertyFontWeight, fontWeight ? fontWeight : cssValuePool().createIdentifierValue(CSSValueNormal), important);
-    addProperty(CSSPropertyFontStretch, fontStretch ? fontStretch : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStyle, CSSPropertyFont, fontStyle ? fontStyle : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariant, CSSPropertyFont, fontVariant ? fontVariant : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, CSSPropertyFont, fontWeight ? fontWeight : cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStretch, CSSPropertyFont, fontStretch ? fontStretch : cssValuePool().createIdentifierValue(CSSValueNormal), important);
 
     // Now a font size _must_ come.
     CSSValue* fontSize = consumeFontSize(m_range, m_context.mode());
     if (!fontSize || m_range.atEnd())
         return false;
 
-    addProperty(CSSPropertyFontSize, fontSize, important);
+    addProperty(CSSPropertyFontSize, CSSPropertyFont, fontSize, important);
 
     if (consumeSlashIncludingWhitespace(m_range)) {
         CSSPrimitiveValue* lineHeight = consumeLineHeight(m_range, m_context.mode());
         if (!lineHeight)
             return false;
-        addProperty(CSSPropertyLineHeight, lineHeight, important);
+        addProperty(CSSPropertyLineHeight, CSSPropertyFont, lineHeight, important);
     } else {
-        addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+        addProperty(CSSPropertyLineHeight, CSSPropertyFont, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     }
 
     // Font family must come now.
     CSSValue* parsedFamilyValue = consumeFontFamily(m_range);
     if (!parsedFamilyValue)
         return false;
 
-    addProperty(CSSPropertyFontFamily, parsedFamilyValue, important);
+    addProperty(CSSPropertyFontFamily, CSSPropertyFont, parsedFamilyValue, important);
 
     // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires that
     // "font-stretch", "font-size-adjust", and "font-kerning" be reset to their initial values
     // but we don't seem to support them at the moment. They should also be added here once implemented.
     return m_range.atEnd();
 }
 
 bool CSSPropertyParser::consumeBorderSpacing(bool important)
 {
     CSSValue* horizontalSpacing = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow);
     if (!horizontalSpacing)
         return false;
     CSSValue* verticalSpacing = horizontalSpacing;
     if (!m_range.atEnd())
         verticalSpacing = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow);
     if (!verticalSpacing || !m_range.atEnd())
         return false;
-    addProperty(CSSPropertyWebkitBorderHorizontalSpacing, horizontalSpacing, important);
-    addProperty(CSSPropertyWebkitBorderVerticalSpacing, verticalSpacing, important);
+    addProperty(CSSPropertyWebkitBorderHorizontalSpacing, CSSPropertyBorderSpacing, horizontalSpacing, important);
+    addProperty(CSSPropertyWebkitBorderVerticalSpacing, CSSPropertyBorderSpacing, verticalSpacing, important);
     return true;
 }
 
 static CSSValue* consumeSingleViewportDescriptor(CSSParserTokenRange& range, CSSPropertyID propId, CSSParserMode cssParserMode)
 {
     CSSValueID id = range.peek().id();
     switch (propId) {
     case CSSPropertyMinWidth:
     case CSSPropertyMaxWidth:
     case CSSPropertyMinHeight:
@@ skipping 31 matching lines @@
     switch (propId) {
     case CSSPropertyWidth: {
         CSSValue* minWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMinWidth, m_context.mode());
         if (!minWidth)
             return false;
         CSSValue* maxWidth = minWidth;
         if (!m_range.atEnd())
             maxWidth = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxWidth, m_context.mode());
         if (!maxWidth || !m_range.atEnd())
             return false;
-        addProperty(CSSPropertyMinWidth, minWidth, important);
-        addProperty(CSSPropertyMaxWidth, maxWidth, important);
+        addProperty(CSSPropertyMinWidth, CSSPropertyInvalid, minWidth, important);
+        addProperty(CSSPropertyMaxWidth, CSSPropertyInvalid, maxWidth, important);
         return true;
     }
     case CSSPropertyHeight: {
         CSSValue* minHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMinHeight, m_context.mode());
         if (!minHeight)
             return false;
         CSSValue* maxHeight = minHeight;
         if (!m_range.atEnd())
             maxHeight = consumeSingleViewportDescriptor(m_range, CSSPropertyMaxHeight, m_context.mode());
         if (!maxHeight || !m_range.atEnd())
             return false;
-        addProperty(CSSPropertyMinHeight, minHeight, important);
-        addProperty(CSSPropertyMaxHeight, maxHeight, important);
+        addProperty(CSSPropertyMinHeight, CSSPropertyInvalid, minHeight, important);
+        addProperty(CSSPropertyMaxHeight, CSSPropertyInvalid, maxHeight, important);
         return true;
     }
     case CSSPropertyMinWidth:
     case CSSPropertyMaxWidth:
     case CSSPropertyMinHeight:
     case CSSPropertyMaxHeight:
     case CSSPropertyMinZoom:
     case CSSPropertyMaxZoom:
     case CSSPropertyZoom:
     case CSSPropertyUserZoom:
     case CSSPropertyOrientation: {
         CSSValue* parsedValue = consumeSingleViewportDescriptor(m_range, propId, m_context.mode());
         if (!parsedValue || !m_range.atEnd())
             return false;
-        addProperty(propId, parsedValue, important);
+        addProperty(propId, CSSPropertyInvalid, parsedValue, important);
         return true;
     }
     default:
         return false;
     }
 }
 
 static bool consumeColumnWidthOrCount(CSSParserTokenRange& range, CSSValue*& columnWidth, CSSValue*& columnCount)
 {
     if (range.peek().id() == CSSValueAuto) {
@@ skipping 16 matching lines @@
     CSSValue* columnCount = nullptr;
     if (!consumeColumnWidthOrCount(m_range, columnWidth, columnCount))
         return false;
     consumeColumnWidthOrCount(m_range, columnWidth, columnCount);
     if (!m_range.atEnd())
         return false;
     if (!columnWidth)
         columnWidth = cssValuePool().createIdentifierValue(CSSValueAuto);
     if (!columnCount)
         columnCount = cssValuePool().createIdentifierValue(CSSValueAuto);
-    addProperty(CSSPropertyColumnWidth, columnWidth, important);
-    addProperty(CSSPropertyColumnCount, columnCount, important);
+    addProperty(CSSPropertyColumnWidth, CSSPropertyInvalid, columnWidth, important);
+    addProperty(CSSPropertyColumnCount, CSSPropertyInvalid, columnCount, important);
     return true;
 }
 
 bool CSSPropertyParser::consumeShorthandGreedily(const StylePropertyShorthand& shorthand, bool important)
 {
     ASSERT(shorthand.length() <= 6); // Existing shorthands have at most 6 longhands.
     CSSValue* longhands[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
     const CSSPropertyID* shorthandProperties = shorthand.properties();
     do {
         bool foundLonghand = false;
         for (size_t i = 0; !foundLonghand && i < shorthand.length(); ++i) {
             if (longhands[i])
                 continue;
-            longhands[i] = parseSingleValue(shorthandProperties[i]);
+            longhands[i] = parseSingleValue(shorthandProperties[i], shorthand.id());
             if (longhands[i])
                 foundLonghand = true;
         }
         if (!foundLonghand)
             return false;
     } while (!m_range.atEnd());
 
     for (size_t i = 0; i < shorthand.length(); ++i) {
         if (longhands[i])
-            addProperty(shorthandProperties[i], longhands[i], important);
+            addProperty(shorthandProperties[i], shorthand.id(), longhands[i], important);
         else
-            addProperty(shorthandProperties[i], cssValuePool().createImplicitInitialValue(), important);
+            addProperty(shorthandProperties[i], shorthand.id(), cssValuePool().createImplicitInitialValue(), important);
     }
     return true;
 }
 
 bool CSSPropertyParser::consumeFlex(bool important)
 {
     static const double unsetValue = -1;
     double flexGrow = unsetValue;
     double flexShrink = unsetValue;
     CSSPrimitiveValue* flexBasis = nullptr;
@@ skipping 32 matching lines @@
         if (flexGrow == unsetValue)
             flexGrow = 1;
         if (flexShrink == unsetValue)
             flexShrink = 1;
         if (!flexBasis)
             flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Percentage);
     }
 
     if (!m_range.atEnd())
         return false;
-    addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitType::Number), important);
-    addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitType::Number), important);
-    addProperty(CSSPropertyFlexBasis, flexBasis, important);
+    addProperty(CSSPropertyFlexGrow, CSSPropertyFlex, cssValuePool().createValue(clampTo<float>(flexGrow), CSSPrimitiveValue::UnitType::Number), important);
+    addProperty(CSSPropertyFlexShrink, CSSPropertyFlex, cssValuePool().createValue(clampTo<float>(flexShrink), CSSPrimitiveValue::UnitType::Number), important);
+    addProperty(CSSPropertyFlexBasis, CSSPropertyFlex, flexBasis, important);
     return true;
 }
 
 bool CSSPropertyParser::consumeBorder(bool important)
 {
     CSSValue* width = nullptr;
     CSSValue* style = nullptr;
     CSSValue* color = nullptr;
 
     while (!width || !style || !color) {
         if (!width) {
             width = consumeLineWidth(m_range, m_context.mode(), UnitlessQuirk::Forbid);
             if (width)
                 continue;
         }
         if (!style) {
-            style = parseSingleValue(CSSPropertyBorderLeftStyle);
+            style = parseSingleValue(CSSPropertyBorderLeftStyle, CSSPropertyBorder);
             if (style)
                 continue;
         }
         if (!color) {
             color = consumeColor(m_range, m_context.mode());
             if (color)
                 continue;
         }
         break;
     }
@@ skipping 13 matching lines @@
     addExpandedPropertyForValue(CSSPropertyBorderColor, color, important);
     addExpandedPropertyForValue(CSSPropertyBorderImage, cssValuePool().createImplicitInitialValue(), important);
 
     return m_range.atEnd();
 }
 
 bool CSSPropertyParser::consume4Values(const StylePropertyShorthand& shorthand, bool important)
 {
     ASSERT(shorthand.length() == 4);
     const CSSPropertyID* longhands = shorthand.properties();
-    CSSValue* top = parseSingleValue(longhands[0]);
+    CSSValue* top = parseSingleValue(longhands[0], shorthand.id());
     if (!top)
         return false;
 
-    CSSValue* right = parseSingleValue(longhands[1]);
+    CSSValue* right = parseSingleValue(longhands[1], shorthand.id());
     CSSValue* bottom = nullptr;
     CSSValue* left = nullptr;
     if (right) {
-        bottom = parseSingleValue(longhands[2]);
+        bottom = parseSingleValue(longhands[2], shorthand.id());
         if (bottom)
-            left = parseSingleValue(longhands[3]);
+            left = parseSingleValue(longhands[3], shorthand.id());
     }
 
     if (!right)
         right = top;
     if (!bottom)
         bottom = top;
     if (!left)
         left = right;
 
-    addProperty(longhands[0], top, important);
-    addProperty(longhands[1], right, important);
-    addProperty(longhands[2], bottom, important);
-    addProperty(longhands[3], left, important);
+    addProperty(longhands[0], shorthand.id(), top, important);
+    addProperty(longhands[1], shorthand.id(), right, important);
+    addProperty(longhands[2], shorthand.id(), bottom, important);
+    addProperty(longhands[3], shorthand.id(), left, important);
 
     return m_range.atEnd();
 }
 
 bool CSSPropertyParser::consumeBorderImage(CSSPropertyID property, bool important)
 {
     CSSValue* source = nullptr;
     CSSValue* slice = nullptr;
     CSSValue* width = nullptr;
     CSSValue* outset = nullptr;
     CSSValue* repeat = nullptr;
     if (consumeBorderImageComponents(property, m_range, m_context, source, slice, width, outset, repeat)) {
         switch (property) {
         case CSSPropertyWebkitMaskBoxImage:
-            addProperty(CSSPropertyWebkitMaskBoxImageSource, source ? source : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageSlice, slice ? slice : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageWidth, width ? width : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageOutset, outset ? outset : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyWebkitMaskBoxImageRepeat, repeat ? repeat : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageSource, CSSPropertyWebkitMaskBoxImage, source ? source : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageSlice, CSSPropertyWebkitMaskBoxImage, slice ? slice : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageWidth, CSSPropertyWebkitMaskBoxImage, width ? width : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageOutset, CSSPropertyWebkitMaskBoxImage, outset ? outset : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyWebkitMaskBoxImageRepeat, CSSPropertyWebkitMaskBoxImage, repeat ? repeat : cssValuePool().createImplicitInitialValue(), important);
             return true;
         case CSSPropertyBorderImage:
-            addProperty(CSSPropertyBorderImageSource, source ? source : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyBorderImageSlice, slice ? slice : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyBorderImageWidth, width ? width : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyBorderImageOutset, outset ? outset : cssValuePool().createImplicitInitialValue(), important);
-            addProperty(CSSPropertyBorderImageRepeat, repeat ? repeat : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyBorderImageSource, CSSPropertyBorderImage, source ? source : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyBorderImageSlice, CSSPropertyBorderImage, slice ? slice : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyBorderImageWidth, CSSPropertyBorderImage, width ? width : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyBorderImageOutset, CSSPropertyBorderImage, outset ? outset : cssValuePool().createImplicitInitialValue(), important);
+            addProperty(CSSPropertyBorderImageRepeat, CSSPropertyBorderImage, repeat ? repeat : cssValuePool().createImplicitInitialValue(), important);
             return true;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     return false;
 }
 
 static inline CSSValueID mapFromPageBreakBetween(CSSValueID value)
@@ skipping 55 matching lines @@
     case CSSPropertyWebkitColumnBreakInside:
         value = mapFromColumnOrPageBreakInside(value);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
     if (value == CSSValueInvalid)
         return false;
 
     CSSPropertyID genericBreakProperty = mapFromLegacyBreakProperty(property);
-    addProperty(genericBreakProperty, cssValuePool().createIdentifierValue(value), important);
+    addProperty(genericBreakProperty, property, cssValuePool().createIdentifierValue(value), important);
     return true;
 }
 
 static bool consumeBackgroundPosition(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless, CSSValue*& resultX, CSSValue*& resultY)
 {
     do {
         CSSValue* positionX = nullptr;
         CSSValue* positionY = nullptr;
         if (!consumePosition(range, context.mode(), unitless, positionX, positionY))
             return false;
@@ skipping 114 matching lines @@
                 addBackgroundValue(longhands[i], cssValuePool().createImplicitInitialValue());
         }
     } while (consumeCommaIncludingWhitespace(m_range));
     if (!m_range.atEnd())
         return false;
 
     for (size_t i = 0; i < longhandCount; ++i) {
         CSSPropertyID property = shorthand.properties()[i];
         if (property == CSSPropertyBackgroundSize && longhands[i] && m_context.useLegacyBackgroundSizeShorthandBehavior())
             continue;
-        addProperty(property, longhands[i], important, implicit);
+        addProperty(property, shorthand.id(), longhands[i], important, implicit);
     }
     return true;
 }
 
 bool CSSPropertyParser::consumeGridItemPositionShorthand(CSSPropertyID shorthandId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
     const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId);
     ASSERT(shorthand.length() == 2);
     CSSValue* startValue = consumeGridLine(m_range);
     if (!startValue)
         return false;
 
     CSSValue* endValue = nullptr;
     if (consumeSlashIncludingWhitespace(m_range)) {
         endValue = consumeGridLine(m_range);
         if (!endValue)
             return false;
     } else {
         endValue = startValue->isCustomIdentValue() ? startValue : cssValuePool().createIdentifierValue(CSSValueAuto);
     }
     if (!m_range.atEnd())
         return false;
-    addProperty(shorthand.properties()[0], startValue, important);
-    addProperty(shorthand.properties()[1], endValue, important);
+    addProperty(shorthand.properties()[0], shorthandId, startValue, important);
+    addProperty(shorthand.properties()[1], shorthandId, endValue, important);
     return true;
 }
 
 bool CSSPropertyParser::consumeGridAreaShorthand(bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
     ASSERT(gridAreaShorthand().length() == 4);
     CSSValue* rowStartValue = consumeGridLine(m_range);
     if (!rowStartValue)
         return false;
@@ skipping 17 matching lines @@
     }
     if (!m_range.atEnd())
         return false;
     if (!columnStartValue)
         columnStartValue = rowStartValue->isCustomIdentValue() ? rowStartValue : cssValuePool().createIdentifierValue(CSSValueAuto);
     if (!rowEndValue)
         rowEndValue = rowStartValue->isCustomIdentValue() ? rowStartValue : cssValuePool().createIdentifierValue(CSSValueAuto);
     if (!columnEndValue)
         columnEndValue = columnStartValue->isCustomIdentValue() ? columnStartValue : cssValuePool().createIdentifierValue(CSSValueAuto);
 
-    addProperty(CSSPropertyGridRowStart, rowStartValue, important);
-    addProperty(CSSPropertyGridColumnStart, columnStartValue, important);
-    addProperty(CSSPropertyGridRowEnd, rowEndValue, important);
-    addProperty(CSSPropertyGridColumnEnd, columnEndValue, important);
+    addProperty(CSSPropertyGridRowStart, CSSPropertyGridArea, rowStartValue, important);
+    addProperty(CSSPropertyGridColumnStart, CSSPropertyGridArea, columnStartValue, important);
+    addProperty(CSSPropertyGridRowEnd, CSSPropertyGridArea, rowEndValue, important);
+    addProperty(CSSPropertyGridColumnEnd, CSSPropertyGridArea, columnEndValue, important);
     return true;
 }
 
-bool CSSPropertyParser::consumeGridTemplateRowsAndAreasAndColumns(bool important)
+bool CSSPropertyParser::consumeGridTemplateRowsAndAreasAndColumns(CSSPropertyID shorthandId, bool important)
 {
     NamedGridAreaMap gridAreaMap;
     size_t rowCount = 0;
     size_t columnCount = 0;
     CSSValueList* templateRows = CSSValueList::createSpaceSeparated();
 
     // Persists between loop iterations so we can use the same value for
     // consecutive <line-names> values
     CSSGridLineNamesValue* lineNames = nullptr;
 
@@ skipping 24 matching lines @@
     CSSValue* columnsValue = nullptr;
     if (!m_range.atEnd()) {
         if (!consumeSlashIncludingWhitespace(m_range))
             return false;
         columnsValue = consumeGridTrackList(m_range, m_context.mode());
         if (!columnsValue || !m_range.atEnd())
             return false;
     } else {
         columnsValue = cssValuePool().createIdentifierValue(CSSValueNone);
     }
-    addProperty(CSSPropertyGridTemplateRows, templateRows, important);
-    addProperty(CSSPropertyGridTemplateColumns, columnsValue, important);
-    addProperty(CSSPropertyGridTemplateAreas, CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount), important);
+    addProperty(CSSPropertyGridTemplateRows, shorthandId, templateRows, important);
+    addProperty(CSSPropertyGridTemplateColumns, shorthandId, columnsValue, important);
+    addProperty(CSSPropertyGridTemplateAreas, shorthandId, CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount), important);
     return true;
 }
 
-bool CSSPropertyParser::consumeGridTemplateShorthand(bool important)
+bool CSSPropertyParser::consumeGridTemplateShorthand(CSSPropertyID shorthandId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
     ASSERT(gridTemplateShorthand().length() == 3);
 
     CSSParserTokenRange rangeCopy = m_range;
     CSSValue* rowsValue = consumeIdent<CSSValueNone>(m_range);
 
     // 1- 'none' case.
     if (rowsValue && m_range.atEnd()) {
-        addProperty(CSSPropertyGridTemplateRows, cssValuePool().createIdentifierValue(CSSValueNone), important);
-        addProperty(CSSPropertyGridTemplateColumns, cssValuePool().createIdentifierValue(CSSValueNone), important);
-        addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateRows, shorthandId, cssValuePool().createIdentifierValue(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateColumns, shorthandId, cssValuePool().createIdentifierValue(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateAreas, shorthandId, cssValuePool().createIdentifierValue(CSSValueNone), important);
         return true;
     }
 
     // 2- <grid-template-rows> / <grid-template-columns>
     if (!rowsValue)
         rowsValue = consumeGridTrackList(m_range, m_context.mode());
 
     if (rowsValue) {
         if (!consumeSlashIncludingWhitespace(m_range))
             return false;
         CSSValue* columnsValue = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode());
         if (!columnsValue || !m_range.atEnd())
             return false;
 
-        addProperty(CSSPropertyGridTemplateRows, rowsValue, important);
-        addProperty(CSSPropertyGridTemplateColumns, columnsValue, important);
-        addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createIdentifierValue(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateRows, shorthandId, rowsValue, important);
+        addProperty(CSSPropertyGridTemplateColumns, shorthandId, columnsValue, important);
+        addProperty(CSSPropertyGridTemplateAreas, shorthandId, cssValuePool().createIdentifierValue(CSSValueNone), important);
         return true;
     }
 
     // 3- [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <track-list> ]?
     m_range = rangeCopy;
-    return consumeGridTemplateRowsAndAreasAndColumns(important);
+    return consumeGridTemplateRowsAndAreasAndColumns(shorthandId, important);
 }
 
 bool CSSPropertyParser::consumeGridShorthand(bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
     ASSERT(shorthandForProperty(CSSPropertyGrid).length() == 8);
 
     CSSParserTokenRange rangeCopy = m_range;
 
     // 1- <grid-template>
-    if (consumeGridTemplateShorthand(important)) {
+    if (consumeGridTemplateShorthand(CSSPropertyGrid, important)) {
         // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
         // The sub-properties not specified are set to their initial value, as normal for shorthands.
-        addProperty(CSSPropertyGridAutoFlow, cssValuePool().createImplicitInitialValue(), important);
-        addProperty(CSSPropertyGridAutoColumns, cssValuePool().createImplicitInitialValue(), important);
-        addProperty(CSSPropertyGridAutoRows, cssValuePool().createImplicitInitialValue(), important);
-        addProperty(CSSPropertyGridColumnGap, cssValuePool().createImplicitInitialValue(), important);
-        addProperty(CSSPropertyGridRowGap, cssValuePool().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+        addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
         return true;
     }
 
     m_range = rangeCopy;
 
     // 2- <grid-auto-flow> [ <grid-auto-rows> [ / <grid-auto-columns> ]? ]
     CSSValueList* gridAutoFlow = consumeGridAutoFlow(m_range);
     if (!gridAutoFlow)
         return false;
 
@@ skipping 16 matching lines @@
         autoColumnsValue = cssValuePool().createImplicitInitialValue();
         autoRowsValue = cssValuePool().createImplicitInitialValue();
     }
 
     // if <grid-auto-columns> value is omitted, it is set to the value specified for grid-auto-rows.
     if (!autoColumnsValue)
         autoColumnsValue = autoRowsValue;
 
     // It can only be specified the explicit or the implicit grid properties in a single grid declaration.
     // The sub-properties not specified are set to their initial value, as normal for shorthands.
-    addProperty(CSSPropertyGridTemplateColumns, cssValuePool().createImplicitInitialValue(), important);
-    addProperty(CSSPropertyGridTemplateRows, cssValuePool().createImplicitInitialValue(), important);
-    addProperty(CSSPropertyGridTemplateAreas, cssValuePool().createImplicitInitialValue(), important);
-    addProperty(CSSPropertyGridAutoFlow, gridAutoFlow, important);
-    addProperty(CSSPropertyGridAutoColumns, autoColumnsValue, important);
-    addProperty(CSSPropertyGridAutoRows, autoRowsValue, important);
-    addProperty(CSSPropertyGridColumnGap, cssValuePool().createImplicitInitialValue(), important);
-    addProperty(CSSPropertyGridRowGap, cssValuePool().createImplicitInitialValue(), important);
-
+    addProperty(CSSPropertyGridTemplateColumns, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+    addProperty(CSSPropertyGridTemplateRows, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+    addProperty(CSSPropertyGridTemplateAreas, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+    addProperty(CSSPropertyGridAutoFlow, CSSPropertyGrid, gridAutoFlow, important);
+    addProperty(CSSPropertyGridAutoColumns, CSSPropertyGrid, autoColumnsValue, important);
+    addProperty(CSSPropertyGridAutoRows, CSSPropertyGrid, autoRowsValue, important);
+    addProperty(CSSPropertyGridColumnGap, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
+    addProperty(CSSPropertyGridRowGap, CSSPropertyGrid, cssValuePool().createImplicitInitialValue(), important);
     return true;
 }
 
 bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
 
-    CSSPropertyID oldShorthand = m_currentShorthand;
-    // TODO(rob.buis): Remove this when the legacy property parser is gone
-    m_currentShorthand = property;
     switch (property) {
     case CSSPropertyWebkitMarginCollapse: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginBeforeCollapse, id, m_context.mode()))
             return false;
         CSSValue* beforeCollapse = cssValuePool().createIdentifierValue(id);
-        addProperty(CSSPropertyWebkitMarginBeforeCollapse, beforeCollapse, important);
+        addProperty(CSSPropertyWebkitMarginBeforeCollapse, CSSPropertyWebkitMarginCollapse, beforeCollapse, important);
         if (m_range.atEnd()) {
-            addProperty(CSSPropertyWebkitMarginAfterCollapse, beforeCollapse, important);
+            addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, beforeCollapse, important);
             return true;
         }
         id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginAfterCollapse, id, m_context.mode()))
             return false;
-        addProperty(CSSPropertyWebkitMarginAfterCollapse, cssValuePool().createIdentifierValue(id), important);
+        addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
     case CSSPropertyOverflow: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyOverflowY, id, m_context.mode()))
             return false;
         if (!m_range.atEnd())
             return false;
         CSSValue* overflowYValue = cssValuePool().createIdentifierValue(id);
 
         CSSValue* overflowXValue = nullptr;
 
         // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
         // set using the shorthand, then for now overflow-x will default to auto, but once we implement
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
             overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);
         else
             overflowXValue = overflowYValue;
-        addProperty(CSSPropertyOverflowX, overflowXValue, important);
-        addProperty(CSSPropertyOverflowY, overflowYValue, important);
+        addProperty(CSSPropertyOverflowX, CSSPropertyOverflow, overflowXValue, important);
+        addProperty(CSSPropertyOverflowY, CSSPropertyOverflow, overflowYValue, important);
         return true;
     }
     case CSSPropertyFont: {
         const CSSParserToken& token = m_range.peek();
         if (token.id() >= CSSValueCaption && token.id() <= CSSValueStatusBar)
             return consumeSystemFont(important);
         return consumeFont(important);
     }
     case CSSPropertyBorderSpacing:
         return consumeBorderSpacing(important);
-    case CSSPropertyColumns: {
-        // TODO(rwlbuis): investigate if this shorthand hack can be removed.
-        m_currentShorthand = oldShorthand;
+    case CSSPropertyColumns:
         return consumeColumns(important);
-    }
     case CSSPropertyAnimation:
         return consumeAnimationShorthand(animationShorthandForParsing(), unresolvedProperty == CSSPropertyAliasWebkitAnimation, important);
     case CSSPropertyTransition:
         return consumeAnimationShorthand(transitionShorthandForParsing(), false, important);
     case CSSPropertyTextDecoration:
         ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
         return consumeShorthandGreedily(textDecorationShorthand(), important);
     case CSSPropertyMargin:
         return consume4Values(marginShorthand(), important);
     case CSSPropertyPadding:
@@ skipping 11 matching lines @@
     case CSSPropertyWebkitBorderBefore:
         return consumeShorthandGreedily(webkitBorderBeforeShorthand(), important);
     case CSSPropertyWebkitBorderAfter:
         return consumeShorthandGreedily(webkitBorderAfterShorthand(), important);
     case CSSPropertyWebkitTextStroke:
         return consumeShorthandGreedily(webkitTextStrokeShorthand(), important);
     case CSSPropertyMarker: {
         CSSValue* marker = parseSingleValue(CSSPropertyMarkerStart);
         if (!marker || !m_range.atEnd())
             return false;
-        addProperty(CSSPropertyMarkerStart, marker, important);
-        addProperty(CSSPropertyMarkerMid, marker, important);
-        addProperty(CSSPropertyMarkerEnd, marker, important);
+        addProperty(CSSPropertyMarkerStart, CSSPropertyMarker, marker, important);
+        addProperty(CSSPropertyMarkerMid, CSSPropertyMarker, marker, important);
+        addProperty(CSSPropertyMarkerEnd, CSSPropertyMarker, marker, important);
         return true;
     }
     case CSSPropertyFlex:
         return consumeFlex(important);
     case CSSPropertyFlexFlow:
         return consumeShorthandGreedily(flexFlowShorthand(), important);
     case CSSPropertyColumnRule:
         return consumeShorthandGreedily(columnRuleShorthand(), important);
     case CSSPropertyListStyle:
         return consumeShorthandGreedily(listStyleShorthand(), important);
     case CSSPropertyBorderRadius: {
         CSSPrimitiveValue* horizontalRadii[4] = { 0 };
         CSSPrimitiveValue* verticalRadii[4] = { 0 };
         if (!consumeRadii(horizontalRadii, verticalRadii, m_range, m_context.mode(), unresolvedProperty == CSSPropertyAliasWebkitBorderRadius))
             return false;
-        addProperty(CSSPropertyBorderTopLeftRadius, CSSValuePair::create(horizontalRadii[0], verticalRadii[0], CSSValuePair::DropIdenticalValues), important);
-        addProperty(CSSPropertyBorderTopRightRadius, CSSValuePair::create(horizontalRadii[1], verticalRadii[1], CSSValuePair::DropIdenticalValues), important);
-        addProperty(CSSPropertyBorderBottomRightRadius, CSSValuePair::create(horizontalRadii[2], verticalRadii[2], CSSValuePair::DropIdenticalValues), important);
-        addProperty(CSSPropertyBorderBottomLeftRadius, CSSValuePair::create(horizontalRadii[3], verticalRadii[3], CSSValuePair::DropIdenticalValues), important);
+        addProperty(CSSPropertyBorderTopLeftRadius, CSSPropertyBorderRadius, CSSValuePair::create(horizontalRadii[0], verticalRadii[0], CSSValuePair::DropIdenticalValues), important);
+        addProperty(CSSPropertyBorderTopRightRadius, CSSPropertyBorderRadius, CSSValuePair::create(horizontalRadii[1], verticalRadii[1], CSSValuePair::DropIdenticalValues), important);
+        addProperty(CSSPropertyBorderBottomRightRadius, CSSPropertyBorderRadius, CSSValuePair::create(horizontalRadii[2], verticalRadii[2], CSSValuePair::DropIdenticalValues), important);
+        addProperty(CSSPropertyBorderBottomLeftRadius, CSSPropertyBorderRadius, CSSValuePair::create(horizontalRadii[3], verticalRadii[3], CSSValuePair::DropIdenticalValues), important);
         return true;
     }
     case CSSPropertyBorderColor:
         return consume4Values(borderColorShorthand(), important);
     case CSSPropertyBorderStyle:
         return consume4Values(borderStyleShorthand(), important);
     case CSSPropertyBorderWidth:
         return consume4Values(borderWidthShorthand(), important);
     case CSSPropertyBorderTop:
         return consumeShorthandGreedily(borderTopShorthand(), important);
@@ skipping 14 matching lines @@
     case CSSPropertyWebkitColumnBreakAfter:
     case CSSPropertyWebkitColumnBreakBefore:
     case CSSPropertyWebkitColumnBreakInside:
         return consumeLegacyBreakProperty(property, important);
     case CSSPropertyWebkitMaskPosition:
     case CSSPropertyBackgroundPosition: {
         CSSValue* resultX = nullptr;
         CSSValue* resultY = nullptr;
         if (!consumeBackgroundPosition(m_range, m_context, UnitlessQuirk::Allow, resultX, resultY) || !m_range.atEnd())
             return false;
-        addProperty(property == CSSPropertyBackgroundPosition ? CSSPropertyBackgroundPositionX : CSSPropertyWebkitMaskPositionX, resultX, important);
-        addProperty(property == CSSPropertyBackgroundPosition ? CSSPropertyBackgroundPositionY : CSSPropertyWebkitMaskPositionY, resultY, important);
+        addProperty(property == CSSPropertyBackgroundPosition ? CSSPropertyBackgroundPositionX : CSSPropertyWebkitMaskPositionX, property, resultX, important);
+        addProperty(property == CSSPropertyBackgroundPosition ? CSSPropertyBackgroundPositionY : CSSPropertyWebkitMaskPositionY, property, resultY, important);
         return true;
     }
     case CSSPropertyBackgroundRepeat:
     case CSSPropertyWebkitMaskRepeat: {
         CSSValue* resultX = nullptr;
         CSSValue* resultY = nullptr;
         bool implicit = false;
         if (!consumeRepeatStyle(m_range, resultX, resultY, implicit) || !m_range.atEnd())
             return false;
-        addProperty(property == CSSPropertyBackgroundRepeat ? CSSPropertyBackgroundRepeatX : CSSPropertyWebkitMaskRepeatX, resultX, important, implicit);
-        addProperty(property == CSSPropertyBackgroundRepeat ? CSSPropertyBackgroundRepeatY : CSSPropertyWebkitMaskRepeatY, resultY, important, implicit);
+        addProperty(property == CSSPropertyBackgroundRepeat ? CSSPropertyBackgroundRepeatX : CSSPropertyWebkitMaskRepeatX, property, resultX, important, implicit);
+        addProperty(property == CSSPropertyBackgroundRepeat ? CSSPropertyBackgroundRepeatY : CSSPropertyWebkitMaskRepeatY, property, resultY, important, implicit);
         return true;
     }
     case CSSPropertyBackground:
         return consumeBackgroundShorthand(backgroundShorthand(), important);
     case CSSPropertyWebkitMask:
         return consumeBackgroundShorthand(webkitMaskShorthand(), important);
     case CSSPropertyGridGap: {
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled() && shorthandForProperty(CSSPropertyGridGap).length() == 2);
         CSSValue* rowGap = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative);
         CSSValue* columnGap = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative);
         if (!rowGap || !m_range.atEnd())
             return false;
         if (!columnGap)
             columnGap = rowGap;
-        addProperty(CSSPropertyGridRowGap, rowGap, important);
-        addProperty(CSSPropertyGridColumnGap, columnGap, important);
+        addProperty(CSSPropertyGridRowGap, CSSPropertyGridGap, rowGap, important);
+        addProperty(CSSPropertyGridColumnGap, CSSPropertyGridGap, columnGap, important);
         return true;
     }
     case CSSPropertyGridColumn:
     case CSSPropertyGridRow:
         return consumeGridItemPositionShorthand(property, important);
     case CSSPropertyGridArea:
         return consumeGridAreaShorthand(important);
     case CSSPropertyGridTemplate:
-        return consumeGridTemplateShorthand(important);
+        return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
     case CSSPropertyGrid:
         return consumeGridShorthand(important);
     default:
-        m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink