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

third_party/WebKit/Source/core/css/resolver/StyleBuilderCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
@@ skipping 52 matching lines @@
 #include "core/css/resolver/TransformBuilder.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "core/style/ContentData.h"
 #include "core/style/CounterContent.h"
 #include "core/style/QuotesData.h"
 #include "core/style/SVGComputedStyle.h"
 #include "core/style/StyleGeneratedImage.h"
-#include "core/style/StyleVariableData.h"
+#include "core/style/StyleInheritedVariables.h"
+#include "core/style/StyleNonInheritedVariables.h"
 #include "platform/fonts/FontDescription.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
@@ skipping 713 matching lines @@
 
 void StyleBuilderFunctions::applyValueCSSPropertyVariable(StyleResolverState& state, const CSSValue& value)
 {
     const CSSCustomPropertyDeclaration& declaration = toCSSCustomPropertyDeclaration(value);
     const AtomicString& name = declaration.name();
     const PropertyRegistry::Registration* registration = nullptr;
     const PropertyRegistry* registry = state.document().propertyRegistry();
     if (registry)
         registration = registry->registration(name);
 
-    switch (declaration.id()) {
-    case CSSValueInitial:
-        state.style()->removeVariable(name);
-        break;
+    bool initial = declaration.id() == CSSValueInitial
+        || (declaration.id() == CSSValueUnset && registration && !registration->inherits());
+    bool inherit = declaration.id() == CSSValueInherit
+        || (declaration.id() == CSSValueUnset && (!registration || registration->inherits()));
+    DCHECK(!(initial && inherit));
 
-    case CSSValueUnset:
-    case CSSValueInherit: {
-        state.style()->removeVariable(name);
-        StyleVariableData* parentVariables = state.parentStyle()->variables();
+    if (declaration.id() == CSSValueInternalVariableValue) {
+        if (declaration.value()->needsVariableResolution()) {
+            if (!registration || registration->inherits())
+                state.style()->setUnresolvedInheritedVariable(name, declaration.value());
+            else
+                state.style()->setUnresolvedNonInheritedVariable(name, declaration.value());
+            return;
+        }
+
+        if (!registration) {
+            state.style()->setResolvedUnregisteredVariable(name, declaration.value());
+            return;
+        }
+
+        const CSSValue* parsedValue = declaration.value()->parseForSyntax(registration->syntax());
+        if (parsedValue) {
+            parsedValue = &StyleBuilderConverter::convertRegisteredPropertyValue(state, *parsedValue);
+            DCHECK(parsedValue);
+            if (registration->inherits())
+                state.style()->setResolvedInheritedVariable(name, declaration.value(), parsedValue);
+            else
+                state.style()->setResolvedNonInheritedVariable(name, declaration.value(), parsedValue);
+            return;
+        }
+        if (registration->inherits())
+            inherit = true;
+        else
+            initial = true;
+    }
+
+    DCHECK(initial ^ inherit);
+
+    if (initial) {
+        if (!registration || registration->inherits())
+            state.style()->removeInheritedVariable(name);
+        else
+            state.style()->removeNonInheritedVariable(name);
+        return;
+    }
+
+    if (!registration || registration->inherits()) {
+        state.style()->removeInheritedVariable(name);
+        StyleInheritedVariables* parentVariables = state.parentStyle()->inheritedVariables();
         if (!parentVariables)
             return;
-        CSSVariableData* value = parentVariables->getVariable(name);
-        if (!value)
-            return;
-        state.style()->setVariable(name, value);
-        if (registration)
-            state.style()->setRegisteredInheritedProperty(name, parentVariables->registeredInheritedProperty(name));
-        break;
+        CSSVariableData* parentValue = parentVariables->getVariable(name);
+        if (parentValue) {
+            if (!registration)
+                state.style()->setResolvedUnregisteredVariable(name, parentValue);
+            else
+                state.style()->setResolvedInheritedVariable(name, parentValue, parentVariables->registeredVariable(name));
+        }
+        return;
     }
-    case CSSValueInternalVariableValue:
-        if (registration) {
-            if (declaration.value()->needsVariableResolution()) {
-                state.style()->setVariable(name, declaration.value());
-                return;
-            }
-            const CSSValue* parsedValue = declaration.value()->parseForSyntax(registration->syntax());
-            if (!parsedValue) {
-                state.style()->setVariable(name, nullptr);
-                state.style()->setRegisteredInheritedProperty(name, nullptr);
-                return;
-            }
-            parsedValue = &StyleBuilderConverter::convertRegisteredPropertyValue(state, *parsedValue);
-            state.style()->setVariable(name, declaration.value());
-            state.style()->setRegisteredInheritedProperty(name, parsedValue);
-            return;
-        }
-        state.style()->setVariable(name, declaration.value());
-        break;
-    default:
-        NOTREACHED();
-    }
+
+    state.style()->removeNonInheritedVariable(name);
+    StyleNonInheritedVariables* parentVariables = state.parentStyle()->nonInheritedVariables();
+    if (!parentVariables)
+        return;
+    CSSVariableData* parentValue = parentVariables->getVariable(name);
+    if (parentValue)
+        state.style()->setResolvedNonInheritedVariable(name, parentValue, parentVariables->registeredVariable(name));
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyBaselineShift(StyleResolverState& state)
 {
     const SVGComputedStyle& parentSvgStyle = state.parentStyle()->svgStyle();
     EBaselineShift baselineShift = parentSvgStyle.baselineShift();
     SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
     svgStyle.setBaselineShift(baselineShift);
     if (baselineShift == BS_LENGTH)
         svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
@@ skipping 24 matching lines @@
     }
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyPosition(StyleResolverState& state)
 {
     if (!state.parentNode()->isDocumentNode())
         state.style()->setPosition(state.parentStyle()->position());
 }
 
 } // namespace blink