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);
 }
 
-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