Changeset 127220 in webkit for trunk/Source/WebCore/css/CSSCalculationValue.cpp

Timestamp:

Aug 30, 2012, 6:13:50 PM (13 years ago)

Author:

[email protected]

Message:

Make it possible to use CSS Variables inside Calc expressions.
​https://bugs.webkit.org/show_bug.cgi?id=95284

Reviewed by Tony Chang.

Allows calc expressions to contain unevaluated variables, which are then resolved in StyleResolver.cpp when building the RenderStyle tree.

Tests:
fast/css/variables/calc.html

• css/CSSCalculationValue.cpp:

(WebCore::unitCategory):
(WebCore):
(WebCore::CSSCalcValue::customSerializeResolvingVariables):
Generates a CSS expression with variables resolved into their corresponding values.
(WebCore::CSSCalcValue::hasVariableReference):
Returns true if the calculation's expression tree refers to a variable (that needs to be resolved).
(CSSCalcPrimitiveValue):
(WebCore::CSSCalcPrimitiveValue::serializeResolvingVariables):
Resolves the variable using the underlying CSSPrimitiveValue's serializeResolvingVariables function.
(WebCore::CSSCalcPrimitiveValue::hasVariableReference):
(WebCore::CSSCalcPrimitiveValue::toCalcValue):
(WebCore::CSSCalcPrimitiveValue::doubleValue):
(WebCore::CSSCalcPrimitiveValue::computeLengthPx):
(WebCore::CSSCalcBinaryOperation::create):
(CSSCalcBinaryOperation):
(WebCore::CSSCalcBinaryOperation::serializeResolvingVariables):
Builds a CSS expression for contained subtrees.
(WebCore::CSSCalcBinaryOperation::hasVariableReference):
Returns true if either subtree contains a variable.

• css/CSSCalculationValue.h:

(CSSCalcExpressionNode):
(CSSCalcValue):

• css/CSSGrammar.y:
• css/CSSParser.cpp:

(WebCore::CSSParser::validCalculationUnit):

• css/CSSPrimitiveValue.cpp:

(WebCore::CSSPrimitiveValue::primitiveType):
(WebCore::CSSPrimitiveValue::customSerializeResolvingVariables):

• css/StyleResolver.cpp:

(WebCore::StyleResolver::collectMatchingRulesForList):

File:

• trunk/Source/WebCore/css/CSSCalculationValue.cpp (modified) (9 diffs)

trunk/Source/WebCore/css/CSSCalculationValue.cpp

@@ -69 +69 @@
     case CSSPrimitiveValue::CSS_REMS:
         return CalcLength;
+#if ENABLE(CSS_VARIABLES)
+    case CSSPrimitiveValue::CSS_VARIABLE_NAME:
+        return CalcVariable;
+#endif
     default:
         return CalcOther;
     }
 }
-    
-String CSSCalcValue::customCssText() const
+
+static String buildCssText(const String& expression)
 {
     StringBuilder result;
-    
     result.append("-webkit-calc");
-    String expression = m_expression->customCssText();
     bool expressionHasSingleTerm = expression[0] != '(';
     if (expressionHasSingleTerm)
@@ -89 +91 @@
 }
 
+String CSSCalcValue::customCssText() const
+{
+    return buildCssText(m_expression->customCssText());
+}
+
+#if ENABLE(CSS_VARIABLES)
+String CSSCalcValue::customSerializeResolvingVariables(const HashMap<AtomicString, String>& variables) const
+{
+    return buildCssText(m_expression->serializeResolvingVariables(variables));
+}
+
+bool CSSCalcValue::hasVariableReference() const
+{
+    return m_expression->hasVariableReference();
+}
+#endif
+
 void CSSCalcValue::reportDescendantMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
@@ -130 +149 @@
         return m_value->cssText();
     }
+
+#if ENABLE(CSS_VARIABLES)
+    virtual String serializeResolvingVariables(const HashMap<AtomicString, String>& variables) const
+    {
+        return m_value->customSerializeResolvingVariables(variables);
+    }
+    
+    virtual bool hasVariableReference() const
+    {
+        return m_value->isVariableName();
+    }
+#endif
 
     virtual PassOwnPtr<CalcExpressionNode> toCalcValue(RenderStyle* style, RenderStyle* rootStyle, double zoom) const
@@ -144 +175 @@
         // to a CalcExpressionNode. CalcPercentNumber makes no sense as a Length.
         case CalcPercentNumber:
+#if ENABLE(CSS_VARIABLES)
+        case CalcVariable:
+#endif
         case CalcOther:
             ASSERT_NOT_REACHED();
@@ -159 +193 @@
         case CalcPercentLength:
         case CalcPercentNumber:
+#if ENABLE(CSS_VARIABLES)
+        case CalcVariable:
+#endif
         case CalcOther:
             ASSERT_NOT_REACHED();
@@ -176 +213 @@
         case CalcPercentLength:
         case CalcPercentNumber:
+#if ENABLE(CSS_VARIABLES)
+        case CalcVariable:
+#endif
         case CalcOther:
             ASSERT_NOT_REACHED();
@@ -192 +232 @@
     explicit CSSCalcPrimitiveValue(CSSPrimitiveValue* value, bool isInteger)
         : CSSCalcExpressionNode(unitCategory((CSSPrimitiveValue::UnitTypes)value->primitiveType()), isInteger)
-        , m_value(value)                 
+        , m_value(value)
     {
     }
@@ -206 +246 @@
     { CalcOther,         CalcPercentLength, CalcPercentLength, CalcOther,         CalcPercentLength },
 };    
-    
+
+static CalculationCategory determineCategory(const CSSCalcExpressionNode& leftSide, const CSSCalcExpressionNode& rightSide, CalcOperator op)
+{
+    CalculationCategory leftCategory = leftSide.category();
+    CalculationCategory rightCategory = rightSide.category();
+
+    if (leftCategory == CalcOther || rightCategory == CalcOther)
+        return CalcOther;
+
+#if ENABLE(CSS_VARIABLES)
+    if (leftCategory == CalcVariable || rightCategory == CalcVariable)
+        return CalcVariable;
+#endif
+
+    switch (op) {
+    case CalcAdd:
+    case CalcSubtract:             
+        return addSubtractResult[leftCategory][rightCategory];
+    case CalcMultiply:
+        if (leftCategory != CalcNumber && rightCategory != CalcNumber) 
+            return CalcOther;
+        return leftCategory == CalcNumber ? rightCategory : leftCategory;
+    case CalcDivide:
+        if (rightCategory != CalcNumber || rightSide.isZero())
+            return CalcOther;
+        return leftCategory;
+    }
+    
+    ASSERT_NOT_REACHED();
+    return CalcOther;
+}
+
 class CSSCalcBinaryOperation : public CSSCalcExpressionNode {
+
 public:
     static PassRefPtr<CSSCalcBinaryOperation> create(PassRefPtr<CSSCalcExpressionNode> leftSide, PassRefPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
     {
-        CalculationCategory leftCategory = leftSide->category();
-        CalculationCategory rightCategory = rightSide->category();
-        CalculationCategory newCategory = CalcOther;
+        ASSERT(leftSide->category() != CalcOther && rightSide->category() != CalcOther);
         
-        ASSERT(leftCategory != CalcOther && rightCategory != CalcOther);
-        
-        switch (op) {
-        case CalcAdd:
-        case CalcSubtract:             
-            if (leftCategory == CalcOther || rightCategory == CalcOther)
-                return 0;
-            newCategory = addSubtractResult[leftCategory][rightCategory];
-            break;   
-                
-        case CalcMultiply:
-            if (leftCategory != CalcNumber && rightCategory != CalcNumber) 
-                return 0;
-            
-            newCategory = leftCategory == CalcNumber ? rightCategory : leftCategory;
-            break;
-                
-        case CalcDivide:
-            if (rightCategory != CalcNumber || rightSide->isZero())
-                return 0;
-            newCategory = leftCategory;
-            break;
-        }
-        
+        CalculationCategory newCategory = determineCategory(*leftSide, *rightSide, op);
+
         if (newCategory == CalcOther)
             return 0;
-            
+
         return adoptRef(new CSSCalcBinaryOperation(leftSide, rightSide, op, newCategory));
     }
@@ -280 +328 @@
     }
 
-    virtual String customCssText() const
+    static String buildCssText(const String& leftExpression, const String& rightExpression, CalcOperator op)
     {
         StringBuilder result;
         result.append('(');
-        result.append(m_leftSide->customCssText());
+        result.append(leftExpression);
         result.append(' ');
-        result.append(static_cast<char>(m_operator));
+        result.append(static_cast<char>(op));
         result.append(' ');
-        result.append(m_rightSide->customCssText());
+        result.append(rightExpression);
         result.append(')');
     
-        return result.toString();    
-    }
+        return result.toString();  
+    }
+
+    virtual String customCssText() const
+    {
+        return buildCssText(m_leftSide->customCssText(), m_rightSide->customCssText(), m_operator);
+    }
+
+#if ENABLE(CSS_VARIABLES)
+    virtual String serializeResolvingVariables(const HashMap<AtomicString, String>& variables) const
+    {
+        return buildCssText(m_leftSide->serializeResolvingVariables(variables), m_rightSide->serializeResolvingVariables(variables), m_operator);
+    }
+
+    virtual bool hasVariableReference() const
+    {
+        return m_leftSide->hasVariableReference() || m_rightSide->hasVariableReference();
+    }
+#endif
 
 private: