[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 104 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) {

[alancutter (OOO until 2018), 2016/10/13 22:19:05]

This UnitData type would be a great representation for CSSCalculationValues
(though I'd name it something less generic). Please consider performing this
tree flattening at calc() parse time, I expect the array based implementation to
simplify multiple areas of code dealing with calc() including typed OM.

[meade_UTC10, 2016/11/16 19:28:21]

I agree, but I don't want to block typed om on refactoring CSSCalculationValue.
I've added this to our backlog instead.

-  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();
+    if (!CSSLengthValue::isSupportedLengthUnit(unit)) {
+      return nullptr;
+    }
+    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 {
+      return nullptr;
+    }
+    if (!unitData)
+      return nullptr;
+    unitData->multiply(argument);
+    return unitData;
+  }
+
+  if (op == CalcDivide) {
+    // Divisor must always be on the RHS.
+    if (right->category() != CalculationCategory::CalcNumber)
+      return nullptr;
+    std::unique_ptr<UnitData> unitData = UnitData::fromExpressionNode(left);
+    if (!unitData)
+      return nullptr;
+    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);
+  if (!leftUnitData || !rightUnitData) {
+    return nullptr;
+  }
+
+  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