CSS Properties and Values API: Support non-inherited custom properties

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 "core/style/StyleInheritedVariables.h"
+#include "core/style/StyleNonInheritedVariables.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)
 {
     if (m_variablesSeen.contains(name)) {
         m_cycleStartPoints.add(name);
         return nullptr;
     }
 
     DCHECK(m_registry || !RuntimeEnabledFeatures::cssVariables2Enabled());
     const PropertyRegistry::Registration* registration = m_registry ? m_registry->registration(name) : nullptr;
 
     CSSVariableData* variableData = nullptr;
-    if (m_styleVariableData)
-        variableData = m_styleVariableData->getVariable(name);
+    if (!registration || registration->inherits()) {
+        if (m_inheritedVariables)
+            variableData = m_inheritedVariables->getVariable(name);
+    } else {
+        variableData = m_nonInheritedVariables->getVariable(name);
+    }
     if (!variableData)
         return registration ? registration->initialVariableData() : nullptr;
     if (!variableData->needsVariableResolution())
         return variableData;
 
     RefPtr<CSSVariableData> newVariableData = resolveCustomProperty(name, *variableData);
-    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);
-        if (!newVariableData)
-            return registration->initialVariableData();
+    if (!registration) {
+        m_inheritedVariables->setVariable(name, newVariableData);
         return newVariableData.get();
     }
 
-    m_styleVariableData->setVariable(name, newVariableData);
+    const CSSValue* parsedValue = nullptr;
+    if (newVariableData) {
+        parsedValue = newVariableData->parseForSyntax(registration->syntax());
+        if (parsedValue)
+            parsedValue = &StyleBuilderConverter::convertRegisteredPropertyValue(m_styleResolverState, *parsedValue);
+        else
+            newVariableData = nullptr;
+    }
+    if (registration->inherits()) {
+        m_inheritedVariables->setVariable(name, newVariableData);
+        m_inheritedVariables->setRegisteredVariable(name, parsedValue);
+    } else {
+        m_nonInheritedVariables->setVariable(name, newVariableData);
+        m_nonInheritedVariables->setRegisteredVariable(name, parsedValue);
+    }
+    if (!newVariableData)
+        return registration->initialVariableData();
     return newVariableData.get();
 }
 
 PassRefPtr<CSSVariableData> CSSVariableResolver::resolveCustomProperty(AtomicString name, const CSSVariableData& variableData)
 {
     ASSERT(variableData.needsVariableResolution());
 
     Vector<CSSParserToken> tokens;
     m_variablesSeen.add(name);
     bool success = resolveTokenRange(variableData.tokens(), tokens);
     m_variablesSeen.remove(name);
 
     // The old variable data holds onto the backing string the new resolved CSSVariableData
-    // relies on. Ensure it will live beyond us overwriting the RefPtr in StyleVariableData.
+    // relies on. Ensure it will live beyond us overwriting the RefPtr in StyleInheritedVariables.
     ASSERT(variableData.refCount() > 1);
 
     if (!success || !m_cycleStartPoints.isEmpty()) {
         m_cycleStartPoints.remove(name);
         return nullptr;
     }
     return CSSVariableData::createResolved(tokens, variableData);
 }
 
 bool CSSVariableResolver::resolveVariableReference(CSSParserTokenRange range, Vector<CSSParserToken>& result)
@@ skipping 113 matching lines @@
 
     if (value)
         return value;
 
     return CSSUnsetValue::create();
 }
 
 
 void CSSVariableResolver::resolveVariableDefinitions(const StyleResolverState& state)
 {
-    StyleVariableData* variables = state.style()->variables();
-    if (!variables)
+    StyleInheritedVariables* inheritedVariables = state.style()->inheritedVariables();
+    StyleNonInheritedVariables* nonInheritedVariables = state.style()->nonInheritedVariables();
+    if (!inheritedVariables && !nonInheritedVariables)
         return;
 
     CSSVariableResolver resolver(state);
-    for (auto& variable : variables->m_data)
-        resolver.valueForCustomProperty(variable.key);
+    if (inheritedVariables) {
+        for (auto& variable : inheritedVariables->m_data)
+            resolver.valueForCustomProperty(variable.key);
+    }
+    if (nonInheritedVariables) {
+        for (auto& variable : nonInheritedVariables->m_data)
+            resolver.valueForCustomProperty(variable.key);
+    }
 }
 
 CSSVariableResolver::CSSVariableResolver(const StyleResolverState& state)
     : m_styleResolverState(state)
-    , m_styleVariableData(state.style()->variables())
+    , m_inheritedVariables(state.style()->inheritedVariables())
+    , m_nonInheritedVariables(state.style()->nonInheritedVariables())
     , m_registry(state.document().propertyRegistry())
 {
 }
 
 DEFINE_TRACE(CSSVariableResolver) { visitor->trace(m_registry); }
 
 } // namespace blink