Skeleton implementation of CSS Properties and Values API

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/CSSVariableData.h"
 #include "core/css/CSSVariableReferenceValue.h"
+#include "core/css/PropertyRegistry.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/StyleBuilderConverter.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/StyleVariableData.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 bool CSSVariableResolver::resolveFallback(CSSParserTokenRange range, Vector<CSSParserToken>& result)
 {
     if (range.atEnd())
         return false;
     ASSERT(range.peek().type() == CommaToken);
     range.consume();
     return resolveTokenRange(range, result);
 }
 
 CSSVariableData* CSSVariableResolver::valueForCustomProperty(AtomicString name)
 {
+    // TODO(timloh): Registered properties shouldn't return nullptr in failure
+    // cases (aside from cycles?), but instead return the initial/inherited value.
     if (m_variablesSeen.contains(name)) {
         m_cycleStartPoints.add(name);
         return nullptr;
     }
 
     if (!m_styleVariableData)
         return nullptr;
     CSSVariableData* variableData = m_styleVariableData->getVariable(name);
     if (!variableData)
         return nullptr;
     if (!variableData->needsVariableResolution())
         return variableData;
     RefPtr<CSSVariableData> newVariableData = resolveCustomProperty(name, *variableData);
+
+    DCHECK(m_registry || !RuntimeEnabledFeatures::cssVariables2Enabled());
+    if (m_registry) {
+        const PropertyRegistry::Registration* registration = m_registry->registration(name);
+        if (registration) {
+            const CSSValue* parsedValue = nullptr;
+            if (newVariableData) {
+                parsedValue = newVariableData->parseForSyntax(registration->syntax());
+                if (parsedValue)
+                    parsedValue = &StyleBuilderConverter::convertRegisteredPropertyValue(m_styleResolverState, *parsedValue);
+                else
+                    newVariableData = nullptr;
+            }
+            m_styleVariableData->setVariable(name, newVariableData);
+            m_styleVariableData->setRegisteredInheritedProperty(name, parsedValue);
+            return newVariableData.get();
+        }
+    }
+
     m_styleVariableData->setVariable(name, newVariableData);
     return newVariableData.get();
 }
 
 PassRefPtr<CSSVariableData> CSSVariableResolver::resolveCustomProperty(AtomicString name, const CSSVariableData& variableData)
 {
     ASSERT(variableData.needsVariableResolution());
 
     Vector<CSSParserToken> tokens;
     m_variablesSeen.add(name);
@@ skipping 68 matching lines @@
             result.append(range.consume());
         }
     }
     return success;
 }
 
 const CSSValue* CSSVariableResolver::resolveVariableReferences(const StyleResolverState& state, CSSPropertyID id, const CSSVariableReferenceValue& value)
 {
     ASSERT(!isShorthandProperty(id));
 
-    CSSVariableResolver resolver(state.style()->variables());
+    CSSVariableResolver resolver(state);
     Vector<CSSParserToken> tokens;
     if (!resolver.resolveTokenRange(value.variableDataValue()->tokens(), tokens))
         return CSSUnsetValue::create();
     const CSSValue* result = CSSPropertyParser::parseSingleValue(id, tokens, strictCSSParserContext());
     if (!result)
         return CSSUnsetValue::create();
     return result;
 }
 
 const CSSValue* CSSVariableResolver::resolvePendingSubstitutions(StyleResolverState& state, CSSPropertyID id, const CSSPendingSubstitutionValue& pendingValue)
 {
     // Longhands from shorthand references follow this path.
     HeapHashMap<CSSPropertyID, Member<const CSSValue>>& propertyCache = state.parsedPropertiesForPendingSubstitution(pendingValue);
 
     const CSSValue* value = propertyCache.get(id);
     if (!value) {
         // TODO(timloh): We shouldn't retry this for all longhands if the shorthand ends up invalid
         CSSVariableReferenceValue* shorthandValue = pendingValue.shorthandValue();
         CSSPropertyID shorthandPropertyId = pendingValue.shorthandPropertyId();
 
-        CSSVariableResolver resolver(state.style()->variables());
+        CSSVariableResolver resolver(state);
 
         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) {
                     propertyCache.set(parsedProperties[i].id(), parsedProperties[i].value());
                 }
             }
         }
         value = propertyCache.get(id);
     }
 
     if (value)
         return value;
 
     return CSSUnsetValue::create();
 }
 
 
-void CSSVariableResolver::resolveVariableDefinitions(StyleVariableData* variables)
+void CSSVariableResolver::resolveVariableDefinitions(const StyleResolverState& state)
 {
+    StyleVariableData* variables = state.style()->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 resolver(state);
+    for (auto& variable : variables->m_data)
+        resolver.valueForCustomProperty(variable.key);

[meade_UTC10, 2016/09/06 04:52:06]

This loop looks like it shouldn't do anything (when compared to the LHS anyway).
Perhaps valueForCustomProperty needs renaming? It seems like it does the
resolving for the property if needed, as well as returning the value.

[Timothy Loh, 2016/09/06 08:21:17]

Agreed, but I don't have any good names here (suggestions welcome)

 }
 
-CSSVariableResolver::CSSVariableResolver(StyleVariableData* styleVariableData)
-    : m_styleVariableData(styleVariableData)
+CSSVariableResolver::CSSVariableResolver(const StyleResolverState& state)
+    : m_styleResolverState(state)
+    , m_styleVariableData(state.style()->variables())
+    , m_registry(state.document().propertyRegistry())
 {
 }
 
+DEFINE_TRACE(CSSVariableResolver) { visitor->trace(m_registry); }
+
 } // namespace blink