Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/css/

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

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 104 matching lines @@
       return true;
     case CSSPrimitiveValue::UnitType::Unknown:
     case CSSPrimitiveValue::UnitType::Calc:
     case CSSPrimitiveValue::UnitType::CalcPercentageWithNumber:
     case CSSPrimitiveValue::UnitType::CalcPercentageWithLength:
     case CSSPrimitiveValue::UnitType::CalcLengthWithNumber:
     case CSSPrimitiveValue::UnitType::CalcPercentageWithLengthAndNumber:
     case CSSPrimitiveValue::UnitType::QuirkyEms:
       return false;
   };
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return false;
 }
 
 static String buildCSSText(const String& expression) {
   StringBuilder result;
   result.append("calc");
   bool expressionHasSingleTerm = expression[0] != '(';
   if (expressionHasSingleTerm)
     result.append('(');
   result.append(expression);
@@ skipping 47 matching lines @@
       const CSSToLengthConversionData& conversionData,
       PixelsAndPercent& value,
       float multiplier) const override {
     switch (m_category) {
       case CalcLength:
         value.pixels = clampTo<float>(
             value.pixels +
             m_value->computeLength<double>(conversionData) * multiplier);
         break;
       case CalcPercent:
-        ASSERT(m_value->isPercentage());
+        DCHECK(m_value->isPercentage());
         value.percent = clampTo<float>(value.percent +
                                        m_value->getDoubleValue() * multiplier);
         break;
       case CalcNumber:
         // TODO(alancutter): Stop treating numbers like pixels unconditionally
         // in calcs to be able to accomodate border-image-width
         // https://drafts.csswg.org/css-backgrounds-3/#the-border-image-width
         value.pixels = clampTo<float>(value.pixels +
                                       m_value->getDoubleValue() *
                                           conversionData.zoom() * multiplier);
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
   }
 
   double doubleValue() const override {
     if (hasDoubleValue(typeWithCalcResolved()))
       return m_value->getDoubleValue();
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return 0;
   }
 
   double computeLengthPx(
       const CSSToLengthConversionData& conversionData) const override {
     switch (m_category) {
       case CalcLength:
         return m_value->computeLength<double>(conversionData);
       case CalcNumber:
       case CalcPercent:
         return m_value->getDoubleValue();
       case CalcAngle:
       case CalcFrequency:
       case CalcPercentLength:
       case CalcPercentNumber:
       case CalcTime:
       case CalcLengthNumber:
       case CalcPercentLengthNumber:
       case CalcOther:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return 0;
   }
 
   void accumulateLengthArray(CSSLengthArray& lengthArray,
                              double multiplier) const override {
-    ASSERT(category() != CalcNumber);
+    DCHECK_NE(category(), CalcNumber);
     m_value->accumulateLengthArray(lengthArray, multiplier);
   }
 
   bool operator==(const CSSCalcExpressionNode& other) const override {
     if (getType() != other.getType())
       return false;
 
     return dataEquivalent(
         m_value, static_cast<const CSSCalcPrimitiveValue&>(other).m_value);
   }
@@ skipping 85 matching lines @@
     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();
+  NOTREACHED();
   return CalcOther;
 }
 
 static bool isIntegerResult(const CSSCalcExpressionNode* leftSide,
                             const CSSCalcExpressionNode* rightSide,
                             CalcOperator op) {
   // Not testing for actual integer values.
   // Performs W3C spec's type checking for calc integers.
   // http://www.w3.org/TR/css3-values/#calc-type-checking
   return op != CalcDivide && leftSide->isInteger() && rightSide->isInteger();
 }
 
 class CSSCalcBinaryOperation final : public CSSCalcExpressionNode {
  public:
   static CSSCalcExpressionNode* create(CSSCalcExpressionNode* leftSide,
                                        CSSCalcExpressionNode* rightSide,
                                        CalcOperator op) {
-    ASSERT(leftSide->category() != CalcOther &&
-           rightSide->category() != CalcOther);
+    DCHECK_NE(leftSide->category(), CalcOther);
+    DCHECK_NE(rightSide->category(), CalcOther);
 
     CalculationCategory newCategory =
         determineCategory(*leftSide, *rightSide, op);
     if (newCategory == CalcOther)
       return nullptr;
 
     return new CSSCalcBinaryOperation(leftSide, rightSide, op, newCategory);
   }
 
   static CSSCalcExpressionNode* createSimplified(
       CSSCalcExpressionNode* leftSide,
       CSSCalcExpressionNode* rightSide,
       CalcOperator op) {
     CalculationCategory leftCategory = leftSide->category();
     CalculationCategory rightCategory = rightSide->category();
-    ASSERT(leftCategory != CalcOther && rightCategory != CalcOther);
+    DCHECK_NE(leftCategory, CalcOther);
+    DCHECK_NE(rightCategory, CalcOther);
 
     bool isInteger = isIntegerResult(leftSide, rightSide, op);
 
     // Simplify numbers.
     if (leftCategory == CalcNumber && rightCategory == CalcNumber) {
       return CSSCalcPrimitiveValue::create(
           evaluateOperator(leftSide->doubleValue(), rightSide->doubleValue(),
                            op),
           CSSPrimitiveValue::UnitType::Number, isInteger);
     }
@@ skipping 29 matching lines @@
                       rightType));
               return CSSCalcPrimitiveValue::create(
                   evaluateOperator(leftValue, rightValue, op), canonicalType,
                   isInteger);
             }
           }
         }
       }
     } else {
       // Simplify multiplying or dividing by a number for simplifiable types.
-      ASSERT(op == CalcMultiply || op == CalcDivide);
+      DCHECK(op == CalcMultiply || op == CalcDivide);
       CSSCalcExpressionNode* numberSide = getNumberSide(leftSide, rightSide);
       if (!numberSide)
         return create(leftSide, rightSide, op);
       if (numberSide == leftSide && op == CalcDivide)
         return nullptr;
       CSSCalcExpressionNode* otherSide =
           leftSide == numberSide ? rightSide : leftSide;
 
       double number = numberSide->doubleValue();
       if (std::isnan(number) || std::isinf(number))
@@ skipping 24 matching lines @@
         m_rightSide->accumulatePixelsAndPercent(conversionData, value,
                                                 multiplier);
         break;
       case CalcSubtract:
         m_leftSide->accumulatePixelsAndPercent(conversionData, value,
                                                multiplier);
         m_rightSide->accumulatePixelsAndPercent(conversionData, value,
                                                 -multiplier);
         break;
       case CalcMultiply:
-        ASSERT((m_leftSide->category() == CalcNumber) !=
-               (m_rightSide->category() == CalcNumber));
+        DCHECK_NE((m_leftSide->category() == CalcNumber),
+                  (m_rightSide->category() == CalcNumber));
         if (m_leftSide->category() == CalcNumber)
           m_rightSide->accumulatePixelsAndPercent(
               conversionData, value, multiplier * m_leftSide->doubleValue());
         else
           m_leftSide->accumulatePixelsAndPercent(
               conversionData, value, multiplier * m_rightSide->doubleValue());
         break;
       case CalcDivide:
-        ASSERT(m_rightSide->category() == CalcNumber);
+        DCHECK_EQ(m_rightSide->category(), CalcNumber);
         m_leftSide->accumulatePixelsAndPercent(
             conversionData, value, multiplier / m_rightSide->doubleValue());
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
   }
 
   double doubleValue() const override {
     return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());
   }
 
   double computeLengthPx(
       const CSSToLengthConversionData& conversionData) const override {
     const double leftValue = m_leftSide->computeLengthPx(conversionData);
     const double rightValue = m_rightSide->computeLengthPx(conversionData);
     return evaluate(leftValue, rightValue);
   }
 
   void accumulateLengthArray(CSSLengthArray& lengthArray,
                              double multiplier) const override {
     switch (m_operator) {
       case CalcAdd:
         m_leftSide->accumulateLengthArray(lengthArray, multiplier);
         m_rightSide->accumulateLengthArray(lengthArray, multiplier);
         break;
       case CalcSubtract:
         m_leftSide->accumulateLengthArray(lengthArray, multiplier);
         m_rightSide->accumulateLengthArray(lengthArray, -multiplier);
         break;
       case CalcMultiply:
-        ASSERT((m_leftSide->category() == CalcNumber) !=
-               (m_rightSide->category() == CalcNumber));
+        DCHECK_NE((m_leftSide->category() == CalcNumber),
+                  (m_rightSide->category() == CalcNumber));
         if (m_leftSide->category() == CalcNumber)
           m_rightSide->accumulateLengthArray(
               lengthArray, multiplier * m_leftSide->doubleValue());
         else
           m_leftSide->accumulateLengthArray(
               lengthArray, multiplier * m_rightSide->doubleValue());
         break;
       case CalcDivide:
-        ASSERT(m_rightSide->category() == CalcNumber);
+        DCHECK_EQ(m_rightSide->category(), CalcNumber);
         m_leftSide->accumulateLengthArray(
             lengthArray, multiplier / m_rightSide->doubleValue());
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
   }
 
   static String buildCSSText(const String& leftExpression,
                              const String& rightExpression,
                              CalcOperator op) {
     StringBuilder result;
     result.append('(');
     result.append(leftExpression);
     result.append(' ');
@@ skipping 26 matching lines @@
 
   const CSSCalcExpressionNode* rightExpressionNode() const {
     return m_rightSide;
   }
 
   CalcOperator operatorType() const { return m_operator; }
 
   CSSPrimitiveValue::UnitType typeWithCalcResolved() const override {
     switch (m_category) {
       case CalcNumber:
-        ASSERT(m_leftSide->category() == CalcNumber &&
-               m_rightSide->category() == CalcNumber);
+        DCHECK_EQ(m_leftSide->category(), CalcNumber);
+        DCHECK_EQ(m_rightSide->category(), CalcNumber);
         return CSSPrimitiveValue::UnitType::Number;
       case CalcLength:
       case CalcPercent: {
         if (m_leftSide->category() == CalcNumber)
           return m_rightSide->typeWithCalcResolved();
         if (m_rightSide->category() == CalcNumber)
           return m_leftSide->typeWithCalcResolved();
         CSSPrimitiveValue::UnitType leftType =
             m_leftSide->typeWithCalcResolved();
         if (leftType == m_rightSide->typeWithCalcResolved())
           return leftType;
         return CSSPrimitiveValue::UnitType::Unknown;
       }
       case CalcAngle:
         return CSSPrimitiveValue::UnitType::Degrees;
       case CalcTime:
         return CSSPrimitiveValue::UnitType::Milliseconds;
       case CalcFrequency:
         return CSSPrimitiveValue::UnitType::Hertz;
       case CalcPercentLength:
       case CalcPercentNumber:
       case CalcLengthNumber:
       case CalcPercentLengthNumber:
       case CalcOther:
         return CSSPrimitiveValue::UnitType::Unknown;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return CSSPrimitiveValue::UnitType::Unknown;
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_leftSide);
     visitor->trace(m_rightSide);
     CSSCalcExpressionNode::trace(visitor);
   }
 
  private:
@@ skipping 215 matching lines @@
 
   return expression ? new CSSCalcValue(expression, range) : nullptr;
 }
 
 CSSCalcValue* CSSCalcValue::create(CSSCalcExpressionNode* expression,
                                    ValueRange range) {
   return new CSSCalcValue(expression, range);
 }
 
 }  // namespace blink