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

third_party/WebKit/Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 22 matching lines @@
 #include "core/style/AppliedTextDecoration.h"
 #include "core/style/BorderEdge.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "core/style/ContentData.h"
 #include "core/style/CursorData.h"
 #include "core/style/DataEquivalency.h"
 #include "core/style/QuotesData.h"
 #include "core/style/ShadowList.h"
 #include "core/style/StyleImage.h"
 #include "core/style/StyleInheritedData.h"
-#include "core/style/StyleVariableData.h"
+#include "core/style/StyleInheritedVariables.h"
+#include "core/style/StyleNonInheritedVariables.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/Font.h"
 #include "platform/fonts/FontSelector.h"
 #include "platform/geometry/FloatRoundedRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/transforms/RotateTransformOperation.h"
 #include "platform/transforms/ScaleTransformOperation.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 #include "wtf/MathExtras.h"
@@ skipping 820 matching lines @@
     if (!value->nativeInvalidationProperties() || !value->customInvalidationProperties())
         return true;
 
     for (CSSPropertyID propertyID : *value->nativeInvalidationProperties()) {
         // TODO(ikilpatrick): remove isInterpolableProperty check once
         // CSSPropertyEquality::propertiesEqual correctly handles all properties.
         if (!CSSPropertyMetadata::isInterpolableProperty(propertyID) || !CSSPropertyEquality::propertiesEqual(propertyID, *this, other))
             return true;
     }
 
-    if (variables() || other.variables()) {
+    if (inheritedVariables() || other.inheritedVariables()) {
         for (const AtomicString& property : *value->customInvalidationProperties()) {
-            CSSVariableData* thisVar = variables() ? variables()->getVariable(property) : nullptr;
-            CSSVariableData* otherVar = other.variables() ? other.variables()->getVariable(property) : nullptr;
+            CSSVariableData* thisVar = inheritedVariables() ? inheritedVariables()->getVariable(property) : nullptr;
+            CSSVariableData* otherVar = other.inheritedVariables() ? other.inheritedVariables()->getVariable(property) : nullptr;
 
             if (!dataEquivalent(thisVar, otherVar))
                 return true;
         }
     }
 
     return false;
 }
 
 void ComputedStyle::updatePropertySpecificDifferences(const ComputedStyle& other, StyleDifference& diff) const
@@ skipping 535 matching lines @@
         return empty;
     }
     if (m_inheritedData.m_textUnderline) {
         DEFINE_STATIC_LOCAL(Vector<AppliedTextDecoration>, underline, (1, AppliedTextDecoration(TextDecorationUnderline)));
         return underline;
     }
 
     return m_rareInheritedData->appliedTextDecorations->vector();
 }
 
-StyleVariableData* ComputedStyle::variables() const
+StyleInheritedVariables* ComputedStyle::inheritedVariables() const
 {
     return m_rareInheritedData->variables.get();
 }
 
-void ComputedStyle::setVariable(const AtomicString& name, PassRefPtr<CSSVariableData> value)
+StyleNonInheritedVariables* ComputedStyle::nonInheritedVariables() const
 {
-    RefPtr<StyleVariableData>& variables = m_rareInheritedData.access()->variables;
+    return m_rareNonInheritedData->m_variables.get();
+}
+
+StyleInheritedVariables& ComputedStyle::mutableInheritedVariables()
+{
+    RefPtr<StyleInheritedVariables>& variables = m_rareInheritedData.access()->variables;
     if (!variables)
-        variables = StyleVariableData::create();
+        variables = StyleInheritedVariables::create();
     else if (!variables->hasOneRef())
         variables = variables->copy();
-    variables->setVariable(name, std::move(value));
+    return *variables;
 }
 
-void ComputedStyle::setRegisteredInheritedProperty(const AtomicString& name, const CSSValue* parsedValue)
+StyleNonInheritedVariables& ComputedStyle::mutableNonInheritedVariables()
 {
-    RefPtr<StyleVariableData>& variables = m_rareInheritedData.access()->variables;
-    // The CSSVariableData needs to be set before calling this function
-    DCHECK(variables);
-    DCHECK(!!parsedValue == !!variables->getVariable(name));
-    DCHECK(!(variables->getVariable(name) && variables->getVariable(name)->needsVariableResolution()));
-
-    if (!variables->hasOneRef())
-        variables = variables->copy();
-    variables->setRegisteredInheritedProperty(name, parsedValue);
+    std::unique_ptr<StyleNonInheritedVariables>& variables = m_rareNonInheritedData.access()->m_variables;
+    if (!variables)
+        variables = StyleNonInheritedVariables::create();
+    return *variables;
 }
 
-void ComputedStyle::removeVariable(const AtomicString& name)
+void ComputedStyle::setUnresolvedInheritedVariable(const AtomicString& name, PassRefPtr<CSSVariableData> value)
 {
-    RefPtr<StyleVariableData>& variables = m_rareInheritedData.access()->variables;
-    if (!variables)
-        return;
-    if (!variables->hasOneRef())
-        variables = variables->copy();
-    variables->removeVariable(name);
+    DCHECK(value && value->needsVariableResolution());
+    mutableInheritedVariables().setVariable(name, std::move(value));
+}
+
+void ComputedStyle::setUnresolvedNonInheritedVariable(const AtomicString& name, PassRefPtr<CSSVariableData> value)
+{
+    DCHECK(value && value->needsVariableResolution());
+    mutableNonInheritedVariables().setVariable(name, std::move(value));
+}
+
+void ComputedStyle::setResolvedUnregisteredVariable(const AtomicString& name, PassRefPtr<CSSVariableData> value)
+{
+    DCHECK(value && !value->needsVariableResolution());
+    mutableInheritedVariables().setVariable(name, std::move(value));
+}
+
+void ComputedStyle::setResolvedInheritedVariable(const AtomicString& name, PassRefPtr<CSSVariableData> value, const CSSValue* parsedValue)
+{
+    DCHECK(!!value == !!parsedValue);
+    DCHECK(!(value && value->needsVariableResolution()));
+
+    StyleInheritedVariables& variables = mutableInheritedVariables();
+    variables.setVariable(name, std::move(value));
+    variables.setRegisteredVariable(name, parsedValue);
+}
+
+void ComputedStyle::setResolvedNonInheritedVariable(const AtomicString& name, PassRefPtr<CSSVariableData> value, const CSSValue* parsedValue)
+{
+    DCHECK(!!value == !!parsedValue);
+    DCHECK(!(value && value->needsVariableResolution()));
+
+    StyleNonInheritedVariables& variables = mutableNonInheritedVariables();
+    variables.setVariable(name, std::move(value));
+    variables.setRegisteredVariable(name, parsedValue);
+}
+
+void ComputedStyle::removeInheritedVariable(const AtomicString& name)
+{
+    mutableInheritedVariables().removeVariable(name);
+}
+
+void ComputedStyle::removeNonInheritedVariable(const AtomicString& name)
+{
+    mutableNonInheritedVariables().removeVariable(name);
 }
 
 float ComputedStyle::wordSpacing() const { return getFontDescription().wordSpacing(); }
 float ComputedStyle::letterSpacing() const { return getFontDescription().letterSpacing(); }
 
 bool ComputedStyle::setFontDescription(const FontDescription& v)
 {
     if (m_styleInheritedData->font.getFontDescription() != v) {
         m_styleInheritedData.access()->font = Font(v);
         return true;
@@ skipping 564 matching lines @@
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 } // namespace blink