[CSS Typed OM] Implement support for CSSValue -> CSSCalcLength

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 "bindings/core/v8/ExceptionState.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/cssom/CSSCalcDictionary.h"
 #include "core/css/cssom/CSSSimpleLength.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 namespace {
 
 static CSSPrimitiveValue::UnitType unitFromIndex(int index) {
+  DCHECK(index < CSSLengthValue::kNumSupportedUnits);
   int lowestValue = static_cast<int>(CSSPrimitiveValue::UnitType::Percentage);
   return static_cast<CSSPrimitiveValue::UnitType>(index + lowestValue);
 }
 
 int indexForUnit(CSSPrimitiveValue::UnitType unit) {
   return (static_cast<int>(unit) -
           static_cast<int>(CSSPrimitiveValue::UnitType::Percentage));
 }
 
 }  // namespace
@@ skipping 105 matching lines @@
 CSSValue* CSSCalcLength::toCSSValue() const {
   CSSCalcExpressionNode* node = m_unitData.toCSSCalcExpressionNode();
   if (node)
     return CSSPrimitiveValue::create(CSSCalcValue::create(node));
   return nullptr;
 }
 
 std::unique_ptr<CSSCalcLength::UnitData>
 CSSCalcLength::UnitData::fromExpressionNode(
     const CSSCalcExpressionNode* expressionNode) {
-  return nullptr;
+  CalculationCategory category = expressionNode->category();
+  DCHECK(category == CalculationCategory::CalcLength ||
+         category == CalculationCategory::CalcPercentLength ||
+         category == CalculationCategory::CalcPercent);
+
+  if (expressionNode->getType() ==
+      CSSCalcExpressionNode::Type::CssCalcPrimitiveValue) {
+    CSSPrimitiveValue::UnitType unit = expressionNode->typeWithCalcResolved();
+    DCHECK(CSSLengthValue::isSupportedLengthUnit(unit));
+    std::unique_ptr<UnitData> result(new UnitData());
+    result->set(unit, expressionNode->doubleValue());
+    return result;
+  }
+
+  const CSSCalcExpressionNode* left = expressionNode->leftExpressionNode();
+  const CSSCalcExpressionNode* right = expressionNode->rightExpressionNode();
+  CalcOperator op = expressionNode->operatorType();
+
+  if (op == CalcMultiply) {
+    std::unique_ptr<UnitData> unitData = nullptr;
+    double argument = 0;
+    // One side should be a number.
+    if (left->category() == CalculationCategory::CalcNumber) {
+      unitData = UnitData::fromExpressionNode(right);
+      argument = left->doubleValue();
+    } else if (right->category() == CalculationCategory::CalcNumber) {
+      unitData = UnitData::fromExpressionNode(left);
+      argument = right->doubleValue();
+    } else {
+      NOTREACHED();
+      return nullptr;
+    }
+    DCHECK(unitData);
+    unitData->multiply(argument);
+    return unitData;
+  }
+
+  if (op == CalcDivide) {
+    // Divisor must always be on the RHS.
+    DCHECK_EQ(right->category(), CalculationCategory::CalcNumber);
+    std::unique_ptr<UnitData> unitData = UnitData::fromExpressionNode(left);
+    DCHECK(unitData);
+    unitData->divide(right->doubleValue());
+    return unitData;
+  }
+
+  // Add and subtract.
+  std::unique_ptr<UnitData> leftUnitData = UnitData::fromExpressionNode(left);
+  std::unique_ptr<UnitData> rightUnitData = UnitData::fromExpressionNode(right);
+  DCHECK(leftUnitData);
+  DCHECK(rightUnitData);
+
+  if (op == CalcAdd)
+    leftUnitData->add(*rightUnitData);
+  else if (op == CalcSubtract)
+    leftUnitData->subtract(*rightUnitData);
+  else
+    NOTREACHED();
+
+  return leftUnitData;
 }
 
 CSSCalcExpressionNode* CSSCalcLength::UnitData::toCSSCalcExpressionNode()
     const {
   CSSCalcExpressionNode* node = nullptr;
   for (unsigned i = 0; i < CSSLengthValue::kNumSupportedUnits; ++i) {
     if (!hasAtIndex(i))
       continue;
     double value = getAtIndex(i);
     if (node) {
@@ skipping 68 matching lines @@
 void CSSCalcLength::UnitData::divide(double x) {
   DCHECK_NE(x, 0);
   for (int i = 0; i < CSSLengthValue::kNumSupportedUnits; ++i) {
     if (hasAtIndex(i)) {
       setAtIndex(i, getAtIndex(i) / x);
     }
   }
 }
 
 }  // namespace blink