[WIP] Add support for CSSValue-> CSSLengthValue and CSSTranslation

third_party/WebKit/Source/core/css/cssom/CSSCalcLength.cpp

 // Copyright 2016 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/cssom/CSSCalcLength.h"
 
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSPrimitiveValue.h"
+#include "core/css/CSSValue.h"
 #include "core/css/cssom/CSSSimpleLength.h"
 #include "core/css/cssom/CalcDictionary.h"
+#include "core/css/cssom/CalcDictionaryHelper.h"
 #include "wtf/Vector.h"
 
+#include <iostream>
+
 namespace blink {
 
 CSSCalcLength::CSSCalcLength() : m_values(CSSLengthValue::kNumSupportedUnits), m_hasValues(CSSLengthValue::kNumSupportedUnits) {}
 
 CSSCalcLength::CSSCalcLength(const CSSCalcLength& other) :
     m_values(other.m_values),
     m_hasValues(other.m_hasValues)
 {}
 
 CSSCalcLength::CSSCalcLength(const CSSSimpleLength& other) :
     m_values(CSSLengthValue::kNumSupportedUnits), m_hasValues(CSSLengthValue::kNumSupportedUnits)
 {
     set(other.value(), other.lengthUnit());
 }
 
 CSSCalcLength* CSSCalcLength::create(const CSSLengthValue* length)
 {
     if (length->type() == SimpleLengthType) {
         const CSSSimpleLength* simpleLength = toCSSSimpleLength(length);
         return new CSSCalcLength(*simpleLength);
     }
 
     return new CSSCalcLength(*toCSSCalcLength(length));
 }
 
-CSSCalcLength* CSSCalcLength::create(const CalcDictionary& dictionary, ExceptionState& exceptionState)
+CSSCalcLength* CSSCalcLength::create(const CalcDictionary& dictionary)
 {
     CSSCalcLength* result = new CSSCalcLength();
     int numSet = 0;
 
 #define setFromDictValue(name, camelName, primitiveName) \
     if (dictionary.has##camelName()) { \
         result->set(dictionary.name(), CSSPrimitiveValue::UnitType::primitiveName); \
         numSet++; \
     }
 
     setFromDictValue(px, Px, Pixels)
     setFromDictValue(percent, Percent, Percentage)
     setFromDictValue(em, Em, Ems)
     setFromDictValue(ex, Ex, Exs)
     setFromDictValue(ch, Ch, Chs)
     setFromDictValue(rem, Rem, Rems)
     setFromDictValue(vw, Vw, ViewportWidth)
     setFromDictValue(vh, Vh, ViewportHeight)
     setFromDictValue(vmin, Vmin, ViewportMin)
     setFromDictValue(vmax, Vmax, ViewportMax)
     setFromDictValue(cm, Cm, Centimeters)
     setFromDictValue(mm, Mm, Millimeters)
     setFromDictValue(in, In, Inches)
     setFromDictValue(pc, Pc, Picas)
     setFromDictValue(pt, Pt, Points)
 
-    if (numSet == 0) {
+    if (numSet == 0)
+        return nullptr;
+
+    return result;
+}
+
+CSSCalcLength* CSSCalcLength::create(const CalcDictionary& dictionary, ExceptionState& exceptionState)
+{
+    CSSCalcLength* result = CSSCalcLength::create(dictionary);
+    if (!result) {
         exceptionState.throwTypeError("Must specify at least one value in CalcDictionary for creating a CSSCalcLength.");
     }
     return result;
 }
 
+CSSCalcLength* CSSCalcLength::populateCalcLengthFromExpressionNode(const CSSCalcExpressionNode* expressionNode)
+{
+    std::cout << "populateCalcLengthFromExpressionNode" << std::endl;
+    if (expressionNode->getType() == CSSCalcExpressionNode::Type::CssCalcPrimitiveValue) {
+        std::cout << "node is simple" << std::endl;
+        CSSPrimitiveValue::UnitType unit = expressionNode->typeWithCalcResolved();
+        int unitIndex = CSSCalcLength::indexForUnit(unit);
+        if (unitIndex < 0 || unitIndex >= kNumSupportedUnits) {
+            std::cout << "Didn't recognize unit." << std::endl;
+            return nullptr;
+        }
+        CSSCalcLength* result = new CSSCalcLength();
+        result->setAtIndex(expressionNode->doubleValue(), unitIndex);
+        return result;
+    }
+
+    const CSSCalcExpressionNode* left = expressionNode->getLHS();
+    const CSSCalcExpressionNode* right = expressionNode->getRHS();
+    CalcOperator op = expressionNode->op();
+
+    CSSCalcLength* leftDict = nullptr;
+    CSSCalcLength* rightDict = nullptr;
+    if (op == CalcMultiply) {
+        // One side should be a plain number.
+        if (left->getType() == CSSCalcExpressionNode::Type::CssCalcPrimitiveValue) {
+            rightDict = populateCalcLengthFromExpressionNode(right);
+            if (!rightDict || left->typeWithCalcResolved() != CSSPrimitiveValue::UnitType::Number) {
+                if (!rightDict)
+                    std::cout << "!rightDict" << std::endl;
+                else
+                    std::cout << "left wasn't a number value" << std::endl;
+                return nullptr;
+            }
+            rightDict->multiplyInternal(left->doubleValue());
+        } else if (right->getType() == CSSCalcExpressionNode::Type::CssCalcPrimitiveValue) {
+            leftDict = populateCalcLengthFromExpressionNode(left);
+            if (!leftDict || right->typeWithCalcResolved() != CSSPrimitiveValue::UnitType::Number) {
+                if (!leftDict)
+                    std::cout << "!leftDict" << std::endl;
+                else
+                    std::cout << "right wasn't a number value" << std::endl;
+                return nullptr;
+            }
+            leftDict->multiplyInternal(right->doubleValue());
+        } else {
+            std::cout << "Neither side was a primitive value" << std::endl;
+            return nullptr;
+        }
+    }
+
+    leftDict = populateCalcLengthFromExpressionNode(left);
+    rightDict = populateCalcLengthFromExpressionNode(right);
+    if (!leftDict || !rightDict) {
+        std::cout << "One of left or right didn't expand to a dict" << std::endl;
+        return nullptr;
+    }
+
+    if (op == CalcAdd) {
+        //CalcDictionaryHelper::add(leftDict, rightDict);
+        return leftDict;
+    } else if (op == CalcSubtract) {
+        //CalcDictionaryHelper::subtract(leftDict, rightDict);
+        return leftDict;
+    }
+
+    std::cout << "Unrecognized op" << std::endl;
+    return nullptr;
+
+    /*
+    if (expressionNode->getType() == CSSCalcExpressionNode::Type::CssCalcPrimitiveValue) {
+        if (operation == CalcAdd || operation == CalcSubtract) {
+            int unitIndex = CSSCalcLength::indexForUnit(expressionNode->typeWithCalcResolved());
+            if (unitIndex < 0 || unitIndex >= kNumSupportedUnits) {
+                std::cout << "Didn't recognize unit." << std::endl;
+                *error = true;
+            } else {
+                if (operation == CalcAdd)
+                    std::cout << "Adding ";
+                else
+                    std::cout << "Subtracting ";
+                std::cout << expressionNode->doubleValue();
+                std::cout << " ";
+                std::cout << int(expressionNode->typeWithCalcResolved()) << std::endl;
+                calcLength->setAtIndex(
+                    operation == CalcAdd ?
+                        calcLength->getAtIndex(unitIndex) + expressionNode->doubleValue() :
+                        calcLength->getAtIndex(unitIndex) - expressionNode->doubleValue(),
+                    unitIndex);
+            }
+        } else if (operation == CalcMultiply) {
+            std::cout << "Multiplying " << expressionNode->doubleValue() << std::endl;
+            calcLength->multiplyInternal(expressionNode->doubleValue());
+        } else if (operation == CalcDivide) {
+            std::cout << "Dividing " << expressionNode->doubleValue() << std::endl;
+            calcLength->divideInternal(expressionNode->doubleValue());
+        } else {
+            std::cout << "Didn't recognize operator." << std::endl;
+            *error = true;
+        }
+        return;
+    }
+
+    populateCalcLengthFromExpressionNode(expressionNode->getLHS(), CalcAdd, calcLength, error);
+    populateCalcLengthFromExpressionNode(expressionNode->getRHS(), expressionNode->op(), calcLength, error);
+    */
+}
+
+CSSCalcLength* CSSCalcLength::fromCSSValue(const CSSValue& value)
+{
+    if (!value.isPrimitiveValue())
+        return nullptr;
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    if (!primitiveValue.isLength() || !primitiveValue.isCalculated())
+        return nullptr;
+
+    const CSSCalcValue* calcValue = primitiveValue.cssCalcValue();
+    return populateCalcLengthFromExpressionNode(calcValue->expressionNode());
+}
+
 bool CSSCalcLength::containsPercent() const
 {
     return has(CSSPrimitiveValue::UnitType::Percentage);
 }
 
 CSSLengthValue* CSSCalcLength::addInternal(const CSSLengthValue* other, ExceptionState& exceptionState)
 {
     CSSCalcLength* result = CSSCalcLength::create(other, exceptionState);
     for (int i = 0; i < CSSLengthValue::kNumSupportedUnits; ++i) {
         if (hasAtIndex(i)) {
@@ skipping 13 matching lines @@
                 result->setAtIndex(getAtIndex(i) - o->getAtIndex(i), i);
             }
         }
     } else {
         const CSSSimpleLength* o = toCSSSimpleLength(other);
         result->set(get(o->lengthUnit()) - o->value(), o->lengthUnit());
     }
     return result;
 }
 
-CSSLengthValue* CSSCalcLength::multiplyInternal(double x, ExceptionState& exceptionState)
+CSSLengthValue* CSSCalcLength::multiplyInternal(double x)
 {
-    CSSCalcLength* result = CSSCalcLength::create(this, exceptionState);
+    CSSCalcLength* result = CSSCalcLength::create(this);
     for (unsigned i = 0; i < CSSLengthValue::kNumSupportedUnits; ++i) {
         if (hasAtIndex(i)) {
             result->setAtIndex(getAtIndex(i) * x, i);
         }
     }
     return result;
 }
 
-CSSLengthValue* CSSCalcLength::divideInternal(double x, ExceptionState& exceptionState)
+CSSLengthValue* CSSCalcLength::divideInternal(double x)
 {
-    CSSCalcLength* result = CSSCalcLength::create(this, exceptionState);
+    CSSCalcLength* result = CSSCalcLength::create(this);
     for (unsigned i = 0; i < CSSLengthValue::kNumSupportedUnits; ++i) {
         if (hasAtIndex(i)) {
             result->setAtIndex(getAtIndex(i) / x, i);
         }
     }
     return result;
 }
 
 CSSValue* CSSCalcLength::toCSSValue() const
 {
@@ skipping 14 matching lines @@
     }
     return CSSPrimitiveValue::create(CSSCalcValue::create(node));
 }
 
 int CSSCalcLength::indexForUnit(CSSPrimitiveValue::UnitType unit)
 {
     return (static_cast<int>(unit) - static_cast<int>(CSSPrimitiveValue::UnitType::Percentage));
 }
 
 } // namespace blink