Add expansion of shorthands with custom properties to longhands using a pending substition value.

third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.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/resolver/CSSVariableResolver.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/StyleBuilderFunctions.h"
 #include "core/StylePropertyShorthand.h"
+#include "core/css/CSSPendingSubstitutionValue.h"
 #include "core/css/CSSUnsetValue.h"
+#include "core/css/CSSValuePool.h"
 #include "core/css/CSSVariableData.h"
 #include "core/css/CSSVariableReferenceValue.h"
 #include "core/css/parser/CSSParserToken.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/StyleVariableData.h"
 #include "wtf/Vector.h"
 
@@ skipping 114 matching lines @@
     CSSVariableResolver resolver(styleVariableData);
     Vector<CSSParserToken> tokens;
     if (!resolver.resolveTokenRange(value.variableDataValue()->tokens(), tokens))
         return CSSUnsetValue::create();
     CSSValue* result = CSSPropertyParser::parseSingleValue(id, tokens, strictCSSParserContext());
     if (!result)
         return CSSUnsetValue::create();
     return result;
 }
 
-void CSSVariableResolver::resolveAndApplyVariableReferences(StyleResolverState& state, CSSPropertyID id, const CSSVariableReferenceValue& value)
+const CSSValue* CSSVariableResolver::resolveVariableReferences(StyleResolverState& state, CSSPropertyID id, const CSSVariableReferenceValue& value)
 {
+    // Longhand variable references follow this path.

[Timothy Loh, 2016/06/22 00:06:12]

Longhand -> Non-shorthand

[Andy Mutton, 2016/06/24 04:53:26]

Done.

     CSSVariableResolver resolver(state.style()->variables());
 
     Vector<CSSParserToken> tokens;
     if (resolver.resolveTokenRange(value.variableDataValue()->tokens(), tokens)) {
         CSSParserContext context(HTMLStandardMode, 0);
 
-        HeapVector<CSSProperty, 256> parsedProperties;
-
-        // TODO: Non-shorthands should just call CSSPropertyParser::parseSingleValue
-        if (CSSPropertyParser::parseValue(id, false, CSSParserTokenRange(tokens), context, parsedProperties, StyleRule::RuleType::Style)) {
-            unsigned parsedPropertiesCount = parsedProperties.size();
-            for (unsigned i = 0; i < parsedPropertiesCount; ++i)
-                StyleBuilder::applyProperty(parsedProperties[i].id(), state, *parsedProperties[i].value());
-            return;
+        CSSValue* value = CSSPropertyParser::parseSingleValue(id, CSSParserTokenRange(tokens), context);
+        if (value) {

[Timothy Loh, 2016/06/22 00:06:11]

Braces { } are not required in Blink for single-line if statements (I prefer
omitting it generally, but it's up to you)

[Andy Mutton, 2016/06/24 04:53:26]

I prefer keeping, but I also don't really care about my preferences vs. matching
what everyone else does. Done.

+            return value;
         }
     }
 
-    CSSUnsetValue* unset = CSSUnsetValue::create();
-    if (isShorthandProperty(id)) {
-        StylePropertyShorthand shorthand = shorthandForProperty(id);
-        for (unsigned i = 0; i < shorthand.length(); i++)
-            StyleBuilder::applyProperty(shorthand.properties()[i], state, *unset);
-        return;
+    return CSSUnsetValue::create();
+}
+
+const CSSValue* CSSVariableResolver::resolvePendingSubstitutions(StyleResolverState& state, CSSPropertyID id, const CSSPendingSubstitutionValue& pendingValue)
+{
+    // Longhands from shorthand references follow this path.
+    const CSSValue* value = state.cssValueForLonghandPropertyId(id);
+    if (!value) {
+        // Property cache is unset. Let's fill it.
+        CSSVariableReferenceValue* shorthandValue = pendingValue.shorthandValue();
+        CSSPropertyID shorthandPropertyId = pendingValue.shorthandPropertyId();
+
+        CSSVariableResolver resolver(state.style()->variables());
+
+        Vector<CSSParserToken> tokens;
+        if (resolver.resolveTokenRange(shorthandValue->variableDataValue()->tokens(), tokens)) {
+            CSSParserContext context(HTMLStandardMode, 0);
+
+            HeapVector<CSSProperty, 256> parsedProperties;
+
+            if (CSSPropertyParser::parseValue(shorthandPropertyId, false, CSSParserTokenRange(tokens), context, parsedProperties, StyleRule::RuleType::Style)) {
+                unsigned parsedPropertiesCount = parsedProperties.size();
+                for (unsigned i = 0; i < parsedPropertiesCount; ++i) {
+                    state.setCssValueForLonghandPropertyId(parsedProperties[i].id(), parsedProperties[i].value());
+                }
+            }
+        }
+        value = state.cssValueForLonghandPropertyId(id);
     }
 
-    StyleBuilder::applyProperty(id, state, *unset);
+    if (value) {
+        return value;
+    }
+
+    return CSSUnsetValue::create();
 }
 
+
 void CSSVariableResolver::resolveVariableDefinitions(StyleVariableData* variables)
 {
     if (!variables)
         return;
 
     CSSVariableResolver resolver(variables);
     for (auto& variable : variables->m_data) {
         if (variable.value && variable.value->needsVariableResolution())
             variable.value = resolver.resolveCustomProperty(variable.key, *variable.value);
     }
 }
 
 CSSVariableResolver::CSSVariableResolver(StyleVariableData* styleVariableData)
     : m_styleVariableData(styleVariableData)
 {
 }
 
 } // namespace blink