src/third_party/WebKit/Source/core/css/CSSCalculationValue.cpp

   1 /*
   2  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "core/css/CSSCalculationValue.h"
  33
  34 #include "core/css/CSSPrimitiveValueMappings.h"
  35 #include "core/css/resolver/StyleResolver.h"
  36 #include "wtf/MathExtras.h"
  37 #include "wtf/OwnPtr.h"
  38 #include "wtf/text/StringBuilder.h"
  39
  40 static const int maxExpressionDepth = 100;
  41
  42 enum ParseState {
  43     OK,
  44     TooDeep,
  45     NoMoreTokens
  46 };
  47
  48 namespace WebCore {
  49
  50 static CalculationCategory unitCategory(CSSPrimitiveValue::UnitType type)
  51 {
  52     switch (type) {
  53     case CSSPrimitiveValue::CSS_NUMBER:
  54     case CSSPrimitiveValue::CSS_PARSER_INTEGER:
  55         return CalcNumber;
  56     case CSSPrimitiveValue::CSS_PERCENTAGE:
  57         return CalcPercent;
  58     case CSSPrimitiveValue::CSS_EMS:
  59     case CSSPrimitiveValue::CSS_EXS:
  60     case CSSPrimitiveValue::CSS_PX:
  61     case CSSPrimitiveValue::CSS_CM:
  62     case CSSPrimitiveValue::CSS_MM:
  63     case CSSPrimitiveValue::CSS_IN:
  64     case CSSPrimitiveValue::CSS_PT:
  65     case CSSPrimitiveValue::CSS_PC:
  66     case CSSPrimitiveValue::CSS_REMS:
  67     case CSSPrimitiveValue::CSS_CHS:
  68     case CSSPrimitiveValue::CSS_VW:
  69     case CSSPrimitiveValue::CSS_VH:
  70     case CSSPrimitiveValue::CSS_VMIN:
  71     case CSSPrimitiveValue::CSS_VMAX:
  72         return CalcLength;
  73     // FIXME: Support angle, time and frequency units.
  74     // http://www.w3.org/TR/css3-values/#calc-notation
  75     default:
  76         return CalcOther;
  77     }
  78 }
  79
  80 static bool hasDoubleValue(CSSPrimitiveValue::UnitType type)
  81 {
  82     switch (type) {
  83     case CSSPrimitiveValue::CSS_NUMBER:
  84     case CSSPrimitiveValue::CSS_PARSER_INTEGER:
  85     case CSSPrimitiveValue::CSS_PERCENTAGE:
  86     case CSSPrimitiveValue::CSS_EMS:
  87     case CSSPrimitiveValue::CSS_EXS:
  88     case CSSPrimitiveValue::CSS_CHS:
  89     case CSSPrimitiveValue::CSS_REMS:
  90     case CSSPrimitiveValue::CSS_PX:
  91     case CSSPrimitiveValue::CSS_CM:
  92     case CSSPrimitiveValue::CSS_MM:
  93     case CSSPrimitiveValue::CSS_IN:
  94     case CSSPrimitiveValue::CSS_PT:
  95     case CSSPrimitiveValue::CSS_PC:
  96     case CSSPrimitiveValue::CSS_DEG:
  97     case CSSPrimitiveValue::CSS_RAD:
  98     case CSSPrimitiveValue::CSS_GRAD:
  99     case CSSPrimitiveValue::CSS_MS:
 100     case CSSPrimitiveValue::CSS_S:
 101     case CSSPrimitiveValue::CSS_HZ:
 102     case CSSPrimitiveValue::CSS_KHZ:
 103     case CSSPrimitiveValue::CSS_DIMENSION:
 104     case CSSPrimitiveValue::CSS_VW:
 105     case CSSPrimitiveValue::CSS_VH:
 106     case CSSPrimitiveValue::CSS_VMIN:
 107     case CSSPrimitiveValue::CSS_VMAX:
 108     case CSSPrimitiveValue::CSS_DPPX:
 109     case CSSPrimitiveValue::CSS_DPI:
 110     case CSSPrimitiveValue::CSS_DPCM:
 111     case CSSPrimitiveValue::CSS_FR:
 112         return true;
 113     case CSSPrimitiveValue::CSS_UNKNOWN:
 114     case CSSPrimitiveValue::CSS_STRING:
 115     case CSSPrimitiveValue::CSS_URI:
 116     case CSSPrimitiveValue::CSS_IDENT:
 117     case CSSPrimitiveValue::CSS_ATTR:
 118     case CSSPrimitiveValue::CSS_COUNTER:
 119     case CSSPrimitiveValue::CSS_RECT:
 120     case CSSPrimitiveValue::CSS_RGBCOLOR:
 121     case CSSPrimitiveValue::CSS_PAIR:
 122     case CSSPrimitiveValue::CSS_UNICODE_RANGE:
 123     case CSSPrimitiveValue::CSS_PARSER_OPERATOR:
 124     case CSSPrimitiveValue::CSS_PARSER_HEXCOLOR:
 125     case CSSPrimitiveValue::CSS_PARSER_IDENTIFIER:
 126     case CSSPrimitiveValue::CSS_TURN:
 127     case CSSPrimitiveValue::CSS_COUNTER_NAME:
 128     case CSSPrimitiveValue::CSS_SHAPE:
 129     case CSSPrimitiveValue::CSS_QUAD:
 130     case CSSPrimitiveValue::CSS_CALC:
 131     case CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_NUMBER:
 132     case CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_LENGTH:
 133     case CSSPrimitiveValue::CSS_PROPERTY_ID:
 134     case CSSPrimitiveValue::CSS_VALUE_ID:
 135         return false;
 136     };
 137     ASSERT_NOT_REACHED();
 138     return false;
 139 }
 140
 141 static String buildCSSText(const String& expression)
 142 {
 143     StringBuilder result;
 144     result.append("calc");
 145     bool expressionHasSingleTerm = expression[0] != '(';
 146     if (expressionHasSingleTerm)
 147         result.append('(');
 148     result.append(expression);
 149     if (expressionHasSingleTerm)
 150         result.append(')');
 151     return result.toString();
 152 }
 153
 154 String CSSCalcValue::customCSSText() const
 155 {
 156     return buildCSSText(m_expression->customCSSText());
 157 }
 158
 159 bool CSSCalcValue::equals(const CSSCalcValue& other) const
 160 {
 161     return compareCSSValuePtr(m_expression, other.m_expression);
 162 }
 163
 164 double CSSCalcValue::clampToPermittedRange(double value) const
 165 {
 166     return m_nonNegative && value < 0 ? 0 : value;
 167 }
 168
 169 double CSSCalcValue::doubleValue() const
 170 {
 171     return clampToPermittedRange(m_expression->doubleValue());
 172 }
 173
 174 double CSSCalcValue::computeLengthPx(const CSSToLengthConversionData& conversionData) const
 175 {
 176     return clampToPermittedRange(m_expression->computeLengthPx(conversionData));
 177 }
 178
 179 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CSSCalcExpressionNode)
 180
 181 class CSSCalcPrimitiveValue FINAL : public CSSCalcExpressionNode {
 182     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 183 public:
 184
 185     static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> create(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger)
 186     {
 187         return adoptRefWillBeNoop(new CSSCalcPrimitiveValue(value, isInteger));
 188     }
 189
 190     static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> create(double value, CSSPrimitiveValue::UnitType type, bool isInteger)
 191     {
 192         if (std::isnan(value) || std::isinf(value))
 193             return nullptr;
 194         return adoptRefWillBeNoop(new CSSCalcPrimitiveValue(CSSPrimitiveValue::create(value, type).get(), isInteger));
 195     }
 196
 197     virtual bool isZero() const OVERRIDE
 198     {
 199         return !m_value->getDoubleValue();
 200     }
 201
 202     virtual String customCSSText() const OVERRIDE
 203     {
 204         return m_value->cssText();
 205     }
 206
 207     virtual void accumulatePixelsAndPercent(const CSSToLengthConversionData& conversionData, PixelsAndPercent& value, float multiplier) const OVERRIDE
 208     {
 209         switch (m_category) {
 210         case CalcLength:
 211             value.pixels += m_value->computeLength<float>(conversionData) * multiplier;
 212             break;
 213         case CalcPercent:
 214             ASSERT(m_value->isPercentage());
 215             value.percent += m_value->getDoubleValue() * multiplier;
 216             break;
 217         default:
 218             ASSERT_NOT_REACHED();
 219         }
 220     }
 221
 222     virtual double doubleValue() const OVERRIDE
 223     {
 224         if (hasDoubleValue(primitiveType()))
 225             return m_value->getDoubleValue();
 226         ASSERT_NOT_REACHED();
 227         return 0;
 228     }
 229
 230     virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const OVERRIDE
 231     {
 232         switch (m_category) {
 233         case CalcLength:
 234             return m_value->computeLength<double>(conversionData);
 235         case CalcPercent:
 236         case CalcNumber:
 237             return m_value->getDoubleValue();
 238         case CalcPercentLength:
 239         case CalcPercentNumber:
 240         case CalcOther:
 241             ASSERT_NOT_REACHED();
 242             break;
 243         }
 244         ASSERT_NOT_REACHED();
 245         return 0;
 246     }
 247
 248     virtual void accumulateLengthArray(CSSLengthArray& lengthArray, double multiplier) const
 249     {
 250         ASSERT(category() != CalcNumber);
 251         m_value->accumulateLengthArray(lengthArray, multiplier);
 252     }
 253
 254     virtual bool equals(const CSSCalcExpressionNode& other) const OVERRIDE
 255     {
 256         if (type() != other.type())
 257             return false;
 258
 259         return compareCSSValuePtr(m_value, static_cast<const CSSCalcPrimitiveValue&>(other).m_value);
 260     }
 261
 262     virtual Type type() const OVERRIDE { return CssCalcPrimitiveValue; }
 263     virtual CSSPrimitiveValue::UnitType primitiveType() const OVERRIDE
 264     {
 265         return m_value->primitiveType();
 266     }
 267
 268
 269     virtual void trace(Visitor* visitor)
 270     {
 271         visitor->trace(m_value);
 272         CSSCalcExpressionNode::trace(visitor);
 273     }
 274
 275 private:
 276     CSSCalcPrimitiveValue(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger)
 277         : CSSCalcExpressionNode(unitCategory(value->primitiveType()), isInteger)
 278         , m_value(value)
 279     {
 280     }
 281
 282     RefPtrWillBeMember<CSSPrimitiveValue> m_value;
 283 };
 284
 285 static const CalculationCategory addSubtractResult[CalcOther][CalcOther] = {
 286 //                        CalcNumber         CalcLength         CalcPercent        CalcPercentNumber  CalcPercentLength
 287 /* CalcNumber */        { CalcNumber,        CalcOther,         CalcPercentNumber, CalcPercentNumber, CalcOther },
 288 /* CalcLength */        { CalcOther,         CalcLength,        CalcPercentLength, CalcOther,         CalcPercentLength },
 289 /* CalcPercent */       { CalcPercentNumber, CalcPercentLength, CalcPercent,       CalcPercentNumber, CalcPercentLength },
 290 /* CalcPercentNumber */ { CalcPercentNumber, CalcOther,         CalcPercentNumber, CalcPercentNumber, CalcOther },
 291 /* CalcPercentLength */ { CalcOther,         CalcPercentLength, CalcPercentLength, CalcOther,         CalcPercentLength },
 292 };
 293
 294 static CalculationCategory determineCategory(const CSSCalcExpressionNode& leftSide, const CSSCalcExpressionNode& rightSide, CalcOperator op)
 295 {
 296     CalculationCategory leftCategory = leftSide.category();
 297     CalculationCategory rightCategory = rightSide.category();
 298
 299     if (leftCategory == CalcOther || rightCategory == CalcOther)
 300         return CalcOther;
 301
 302     switch (op) {
 303     case CalcAdd:
 304     case CalcSubtract:
 305         return addSubtractResult[leftCategory][rightCategory];
 306     case CalcMultiply:
 307         if (leftCategory != CalcNumber && rightCategory != CalcNumber)
 308             return CalcOther;
 309         return leftCategory == CalcNumber ? rightCategory : leftCategory;
 310     case CalcDivide:
 311         if (rightCategory != CalcNumber || rightSide.isZero())
 312             return CalcOther;
 313         return leftCategory;
 314     }
 315
 316     ASSERT_NOT_REACHED();
 317     return CalcOther;
 318 }
 319
 320 static bool isIntegerResult(const CSSCalcExpressionNode* leftSide, const CSSCalcExpressionNode* rightSide, CalcOperator op)
 321 {
 322     // Not testing for actual integer values.
 323     // Performs W3C spec's type checking for calc integers.
 324     // http://www.w3.org/TR/css3-values/#calc-type-checking
 325     return op != CalcDivide && leftSide->isInteger() && rightSide->isInteger();
 326 }
 327
 328 class CSSCalcBinaryOperation FINAL : public CSSCalcExpressionNode {
 329 public:
 330     static PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> create(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
 331     {
 332         ASSERT(leftSide->category() != CalcOther && rightSide->category() != CalcOther);
 333
 334         CalculationCategory newCategory = determineCategory(*leftSide, *rightSide, op);
 335         if (newCategory == CalcOther)
 336             return nullptr;
 337
 338         return adoptRefWillBeNoop(new CSSCalcBinaryOperation(leftSide, rightSide, op, newCategory));
 339     }
 340
 341     static PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> createSimplified(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
 342     {
 343         CalculationCategory leftCategory = leftSide->category();
 344         CalculationCategory rightCategory = rightSide->category();
 345         ASSERT(leftCategory != CalcOther && rightCategory != CalcOther);
 346
 347         bool isInteger = isIntegerResult(leftSide.get(), rightSide.get(), op);
 348
 349         // Simplify numbers.
 350         if (leftCategory == CalcNumber && rightCategory == CalcNumber) {
 351             CSSPrimitiveValue::UnitType evaluationType = isInteger ? CSSPrimitiveValue::CSS_PARSER_INTEGER : CSSPrimitiveValue::CSS_NUMBER;
 352             return CSSCalcPrimitiveValue::create(evaluateOperator(leftSide->doubleValue(), rightSide->doubleValue(), op), evaluationType, isInteger);
 353         }
 354
 355         // Simplify addition and subtraction between same types.
 356         if (op == CalcAdd || op == CalcSubtract) {
 357             if (leftCategory == rightSide->category()) {
 358                 CSSPrimitiveValue::UnitType leftType = leftSide->primitiveType();
 359                 if (hasDoubleValue(leftType)) {
 360                     CSSPrimitiveValue::UnitType rightType = rightSide->primitiveType();
 361                     if (leftType == rightType)
 362                         return CSSCalcPrimitiveValue::create(evaluateOperator(leftSide->doubleValue(), rightSide->doubleValue(), op), leftType, isInteger);
 363                     CSSPrimitiveValue::UnitCategory leftUnitCategory = CSSPrimitiveValue::unitCategory(leftType);
 364                     if (leftUnitCategory != CSSPrimitiveValue::UOther && leftUnitCategory == CSSPrimitiveValue::unitCategory(rightType)) {
 365                         CSSPrimitiveValue::UnitType canonicalType = CSSPrimitiveValue::canonicalUnitTypeForCategory(leftUnitCategory);
 366                         if (canonicalType != CSSPrimitiveValue::CSS_UNKNOWN) {
 367                             double leftValue = leftSide->doubleValue() * CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(leftType);
 368                             double rightValue = rightSide->doubleValue() * CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(rightType);
 369                             return CSSCalcPrimitiveValue::create(evaluateOperator(leftValue, rightValue, op), canonicalType, isInteger);
 370                         }
 371                     }
 372                 }
 373             }
 374         } else {
 375             // Simplify multiplying or dividing by a number for simplifiable types.
 376             ASSERT(op == CalcMultiply || op == CalcDivide);
 377             CSSCalcExpressionNode* numberSide = getNumberSide(leftSide.get(), rightSide.get());
 378             if (!numberSide)
 379                 return create(leftSide, rightSide, op);
 380             if (numberSide == leftSide && op == CalcDivide)
 381                 return nullptr;
 382             CSSCalcExpressionNode* otherSide = leftSide == numberSide ? rightSide.get() : leftSide.get();
 383
 384             double number = numberSide->doubleValue();
 385             if (std::isnan(number) || std::isinf(number))
 386                 return nullptr;
 387             if (op == CalcDivide && !number)
 388                 return nullptr;
 389
 390             CSSPrimitiveValue::UnitType otherType = otherSide->primitiveType();
 391             if (hasDoubleValue(otherType))
 392                 return CSSCalcPrimitiveValue::create(evaluateOperator(otherSide->doubleValue(), number, op), otherType, isInteger);
 393         }
 394
 395         return create(leftSide, rightSide, op);
 396     }
 397
 398     virtual bool isZero() const OVERRIDE
 399     {
 400         return !doubleValue();
 401     }
 402
 403     virtual void accumulatePixelsAndPercent(const CSSToLengthConversionData& conversionData, PixelsAndPercent& value, float multiplier) const OVERRIDE
 404     {
 405         switch (m_operator) {
 406         case CalcAdd:
 407             m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier);
 408             m_rightSide->accumulatePixelsAndPercent(conversionData, value, multiplier);
 409             break;
 410         case CalcSubtract:
 411             m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier);
 412             m_rightSide->accumulatePixelsAndPercent(conversionData, value, -multiplier);
 413             break;
 414         case CalcMultiply:
 415             ASSERT((m_leftSide->category() == CalcNumber) != (m_rightSide->category() == CalcNumber));
 416             if (m_leftSide->category() == CalcNumber)
 417                 m_rightSide->accumulatePixelsAndPercent(conversionData, value, multiplier * m_leftSide->doubleValue());
 418             else
 419                 m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier * m_rightSide->doubleValue());
 420             break;
 421         case CalcDivide:
 422             ASSERT(m_rightSide->category() == CalcNumber);
 423             m_leftSide->accumulatePixelsAndPercent(conversionData, value, multiplier / m_rightSide->doubleValue());
 424             break;
 425         default:
 426             ASSERT_NOT_REACHED();
 427         }
 428     }
 429
 430     virtual double doubleValue() const OVERRIDE
 431     {
 432         return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());
 433     }
 434
 435     virtual double computeLengthPx(const CSSToLengthConversionData& conversionData) const OVERRIDE
 436     {
 437         const double leftValue = m_leftSide->computeLengthPx(conversionData);
 438         const double rightValue = m_rightSide->computeLengthPx(conversionData);
 439         return evaluate(leftValue, rightValue);
 440     }
 441
 442     virtual void accumulateLengthArray(CSSLengthArray& lengthArray, double multiplier) const
 443     {
 444         switch (m_operator) {
 445         case CalcAdd:
 446             m_leftSide->accumulateLengthArray(lengthArray, multiplier);
 447             m_rightSide->accumulateLengthArray(lengthArray, multiplier);
 448             break;
 449         case CalcSubtract:
 450             m_leftSide->accumulateLengthArray(lengthArray, multiplier);
 451             m_rightSide->accumulateLengthArray(lengthArray, -multiplier);
 452             break;
 453         case CalcMultiply:
 454             ASSERT((m_leftSide->category() == CalcNumber) != (m_rightSide->category() == CalcNumber));
 455             if (m_leftSide->category() == CalcNumber)
 456                 m_rightSide->accumulateLengthArray(lengthArray, multiplier * m_leftSide->doubleValue());
 457             else
 458                 m_leftSide->accumulateLengthArray(lengthArray, multiplier * m_rightSide->doubleValue());
 459             break;
 460         case CalcDivide:
 461             ASSERT(m_rightSide->category() == CalcNumber);
 462             m_leftSide->accumulateLengthArray(lengthArray, multiplier / m_rightSide->doubleValue());
 463             break;
 464         default:
 465             ASSERT_NOT_REACHED();
 466         }
 467     }
 468
 469     static String buildCSSText(const String& leftExpression, const String& rightExpression, CalcOperator op)
 470     {
 471         StringBuilder result;
 472         result.append('(');
 473         result.append(leftExpression);
 474         result.append(' ');
 475         result.append(static_cast<char>(op));
 476         result.append(' ');
 477         result.append(rightExpression);
 478         result.append(')');
 479
 480         return result.toString();
 481     }
 482
 483     virtual String customCSSText() const OVERRIDE
 484     {
 485         return buildCSSText(m_leftSide->customCSSText(), m_rightSide->customCSSText(), m_operator);
 486     }
 487
 488     virtual bool equals(const CSSCalcExpressionNode& exp) const OVERRIDE
 489     {
 490         if (type() != exp.type())
 491             return false;
 492
 493         const CSSCalcBinaryOperation& other = static_cast<const CSSCalcBinaryOperation&>(exp);
 494         return compareCSSValuePtr(m_leftSide, other.m_leftSide)
 495             && compareCSSValuePtr(m_rightSide, other.m_rightSide)
 496             && m_operator == other.m_operator;
 497     }
 498
 499     virtual Type type() const OVERRIDE { return CssCalcBinaryOperation; }
 500
 501     virtual CSSPrimitiveValue::UnitType primitiveType() const OVERRIDE
 502     {
 503         switch (m_category) {
 504         case CalcNumber:
 505             ASSERT(m_leftSide->category() == CalcNumber && m_rightSide->category() == CalcNumber);
 506             if (m_isInteger)
 507                 return CSSPrimitiveValue::CSS_PARSER_INTEGER;
 508             return CSSPrimitiveValue::CSS_NUMBER;
 509         case CalcLength:
 510         case CalcPercent: {
 511             if (m_leftSide->category() == CalcNumber)
 512                 return m_rightSide->primitiveType();
 513             if (m_rightSide->category() == CalcNumber)
 514                 return m_leftSide->primitiveType();
 515             CSSPrimitiveValue::UnitType leftType = m_leftSide->primitiveType();
 516             if (leftType == m_rightSide->primitiveType())
 517                 return leftType;
 518             return CSSPrimitiveValue::CSS_UNKNOWN;
 519         }
 520         case CalcPercentLength:
 521         case CalcPercentNumber:
 522         case CalcOther:
 523             return CSSPrimitiveValue::CSS_UNKNOWN;
 524         }
 525         ASSERT_NOT_REACHED();
 526         return CSSPrimitiveValue::CSS_UNKNOWN;
 527     }
 528
 529     virtual void trace(Visitor* visitor)
 530     {
 531         visitor->trace(m_leftSide);
 532         visitor->trace(m_rightSide);
 533         CSSCalcExpressionNode::trace(visitor);
 534     }
 535
 536 private:
 537     CSSCalcBinaryOperation(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op, CalculationCategory category)
 538         : CSSCalcExpressionNode(category, isIntegerResult(leftSide.get(), rightSide.get(), op))
 539         , m_leftSide(leftSide)
 540         , m_rightSide(rightSide)
 541         , m_operator(op)
 542     {
 543     }
 544
 545     static CSSCalcExpressionNode* getNumberSide(CSSCalcExpressionNode* leftSide, CSSCalcExpressionNode* rightSide)
 546     {
 547         if (leftSide->category() == CalcNumber)
 548             return leftSide;
 549         if (rightSide->category() == CalcNumber)
 550             return rightSide;
 551         return 0;
 552     }
 553
 554     double evaluate(double leftSide, double rightSide) const
 555     {
 556         return evaluateOperator(leftSide, rightSide, m_operator);
 557     }
 558
 559     static double evaluateOperator(double leftValue, double rightValue, CalcOperator op)
 560     {
 561         switch (op) {
 562         case CalcAdd:
 563             return leftValue + rightValue;
 564         case CalcSubtract:
 565             return leftValue - rightValue;
 566         case CalcMultiply:
 567             return leftValue * rightValue;
 568         case CalcDivide:
 569             if (rightValue)
 570                 return leftValue / rightValue;
 571             return std::numeric_limits<double>::quiet_NaN();
 572         }
 573         return 0;
 574     }
 575
 576     const RefPtrWillBeMember<CSSCalcExpressionNode> m_leftSide;
 577     const RefPtrWillBeMember<CSSCalcExpressionNode> m_rightSide;
 578     const CalcOperator m_operator;
 579 };
 580
 581 static ParseState checkDepthAndIndex(int* depth, unsigned index, CSSParserValueList* tokens)
 582 {
 583     (*depth)++;
 584     if (*depth > maxExpressionDepth)
 585         return TooDeep;
 586     if (index >= tokens->size())
 587         return NoMoreTokens;
 588     return OK;
 589 }
 590
 591 class CSSCalcExpressionNodeParser {
 592     STACK_ALLOCATED();
 593 public:
 594     PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> parseCalc(CSSParserValueList* tokens)
 595     {
 596         unsigned index = 0;
 597         Value result;
 598         bool ok = parseValueExpression(tokens, 0, &index, &result);
 599         ASSERT_WITH_SECURITY_IMPLICATION(index <= tokens->size());
 600         if (!ok || index != tokens->size())
 601             return nullptr;
 602         return result.value;
 603     }
 604
 605 private:
 606     struct Value {
 607         STACK_ALLOCATED();
 608     public:
 609         RefPtrWillBeMember<CSSCalcExpressionNode> value;
 610     };
 611
 612     char operatorValue(CSSParserValueList* tokens, unsigned index)
 613     {
 614         if (index >= tokens->size())
 615             return 0;
 616         CSSParserValue* value = tokens->valueAt(index);
 617         if (value->unit != CSSParserValue::Operator)
 618             return 0;
 619
 620         return value->iValue;
 621     }
 622
 623     bool parseValue(CSSParserValueList* tokens, unsigned* index, Value* result)
 624     {
 625         CSSParserValue* parserValue = tokens->valueAt(*index);
 626         if (parserValue->unit == CSSParserValue::Operator)
 627             return false;
 628
 629         RefPtrWillBeRawPtr<CSSValue> value = parserValue->createCSSValue();
 630         if (!value || !value->isPrimitiveValue())
 631             return false;
 632
 633         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value.get());
 634         if (unitCategory(primitiveValue->primitiveType()) == CalcOther)
 635             return false;
 636
 637         result->value = CSSCalcPrimitiveValue::create(primitiveValue, parserValue->isInt);
 638
 639         ++*index;
 640         return true;
 641     }
 642
 643     bool parseValueTerm(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
 644     {
 645         if (checkDepthAndIndex(&depth, *index, tokens) != OK)
 646             return false;
 647
 648         if (operatorValue(tokens, *index) == '(') {
 649             unsigned currentIndex = *index + 1;
 650             if (!parseValueExpression(tokens, depth, &currentIndex, result))
 651                 return false;
 652
 653             if (operatorValue(tokens, currentIndex) != ')')
 654                 return false;
 655             *index = currentIndex + 1;
 656             return true;
 657         }
 658
 659         return parseValue(tokens, index, result);
 660     }
 661
 662     bool parseValueMultiplicativeExpression(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
 663     {
 664         if (checkDepthAndIndex(&depth, *index, tokens) != OK)
 665             return false;
 666
 667         if (!parseValueTerm(tokens, depth, index, result))
 668             return false;
 669
 670         while (*index < tokens->size() - 1) {
 671             char operatorCharacter = operatorValue(tokens, *index);
 672             if (operatorCharacter != CalcMultiply && operatorCharacter != CalcDivide)
 673                 break;
 674             ++*index;
 675
 676             Value rhs;
 677             if (!parseValueTerm(tokens, depth, index, &rhs))
 678                 return false;
 679
 680             result->value = CSSCalcBinaryOperation::createSimplified(result->value, rhs.value, static_cast<CalcOperator>(operatorCharacter));
 681             if (!result->value)
 682                 return false;
 683         }
 684
 685         ASSERT_WITH_SECURITY_IMPLICATION(*index <= tokens->size());
 686         return true;
 687     }
 688
 689     bool parseAdditiveValueExpression(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
 690     {
 691         if (checkDepthAndIndex(&depth, *index, tokens) != OK)
 692             return false;
 693
 694         if (!parseValueMultiplicativeExpression(tokens, depth, index, result))
 695             return false;
 696
 697         while (*index < tokens->size() - 1) {
 698             char operatorCharacter = operatorValue(tokens, *index);
 699             if (operatorCharacter != CalcAdd && operatorCharacter != CalcSubtract)
 700                 break;
 701             ++*index;
 702
 703             Value rhs;
 704             if (!parseValueMultiplicativeExpression(tokens, depth, index, &rhs))
 705                 return false;
 706
 707             result->value = CSSCalcBinaryOperation::createSimplified(result->value, rhs.value, static_cast<CalcOperator>(operatorCharacter));
 708             if (!result->value)
 709                 return false;
 710         }
 711
 712         ASSERT_WITH_SECURITY_IMPLICATION(*index <= tokens->size());
 713         return true;
 714     }
 715
 716     bool parseValueExpression(CSSParserValueList* tokens, int depth, unsigned* index, Value* result)
 717     {
 718         return parseAdditiveValueExpression(tokens, depth, index, result);
 719     }
 720 };
 721
 722 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value, bool isInteger)
 723 {
 724     return CSSCalcPrimitiveValue::create(value, isInteger);
 725 }
 726
 727 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide, PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide, CalcOperator op)
 728 {
 729     return CSSCalcBinaryOperation::create(leftSide, rightSide, op);
 730 }
 731
 732 PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode(double pixels, double percent)
 733 {
 734     return createExpressionNode(
 735         createExpressionNode(CSSPrimitiveValue::create(pixels, CSSPrimitiveValue::CSS_PX), pixels == trunc(pixels)),
 736         createExpressionNode(CSSPrimitiveValue::create(percent, CSSPrimitiveValue::CSS_PERCENTAGE), percent == trunc(percent)),
 737         CalcAdd);
 738 }
 739
 740 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(CSSParserString name, CSSParserValueList* parserValueList, ValueRange range)
 741 {
 742     CSSCalcExpressionNodeParser parser;
 743     RefPtrWillBeRawPtr<CSSCalcExpressionNode> expression = nullptr;
 744
 745     if (equalIgnoringCase(name, "calc(") || equalIgnoringCase(name, "-webkit-calc("))
 746         expression = parser.parseCalc(parserValueList);
 747     // FIXME calc (http://webkit.org/b/16662) Add parsing for min and max here
 748
 749     return expression ? adoptRefWillBeNoop(new CSSCalcValue(expression, range)) : nullptr;
 750 }
 751
 752 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> expression, ValueRange range)
 753 {
 754     return adoptRefWillBeNoop(new CSSCalcValue(expression, range));
 755 }
 756
 757 void CSSCalcValue::traceAfterDispatch(Visitor* visitor)
 758 {
 759     visitor->trace(m_expression);
 760     CSSValue::traceAfterDispatch(visitor);
 761 }
 762
 763 } // namespace WebCore