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

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 151 matching lines @@
       return UnitType::Milliseconds;
     case CalcOther:
       return UnitType::Unknown;
   }
   return UnitType::Unknown;
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitType type)
     : CSSValue(PrimitiveClass) {
   init(type);
-  ASSERT(std::isfinite(num));
+  DCHECK(std::isfinite(num));
   m_value.num = num;
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(const Length& length, float zoom)
     : CSSValue(PrimitiveClass) {
   switch (length.type()) {
     case Percent:
       init(UnitType::Percentage);
-      ASSERT(std::isfinite(length.percent()));
+      DCHECK(std::isfinite(length.percent()));
       m_value.num = length.percent();
       break;
     case Fixed:
       init(UnitType::Pixels);
       m_value.num = length.value() / zoom;
       break;
     case Calculated: {
       const CalculationValue& calc = length.getCalculationValue();
       if (calc.pixels() && calc.percent()) {
         init(CSSCalcValue::create(CSSCalcValue::createExpressionNode(
@@ skipping 14 matching lines @@
     }
     case Auto:
     case MinContent:
     case MaxContent:
     case FillAvailable:
     case FitContent:
     case ExtendToZoom:
     case DeviceWidth:
     case DeviceHeight:
     case MaxSizeNone:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
 }
 
 void CSSPrimitiveValue::init(UnitType type) {
   m_primitiveUnitType = static_cast<unsigned>(type);
 }
 
 void CSSPrimitiveValue::init(CSSCalcValue* c) {
   init(UnitType::Calc);
   m_hasCachedCSSText = false;
   m_value.calc = c;
 }
 
 CSSPrimitiveValue::~CSSPrimitiveValue() {}
 
 double CSSPrimitiveValue::computeSeconds() const {
-  ASSERT(isTime() ||
+  DCHECK(isTime() ||
          (isCalculated() && cssCalcValue()->category() == CalcTime));
   UnitType currentType =
       isCalculated() ? cssCalcValue()->expressionNode()->typeWithCalcResolved()
                      : type();
   if (currentType == UnitType::Seconds)
     return getDoubleValue();
   if (currentType == UnitType::Milliseconds)
     return getDoubleValue() / 1000;
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return 0;
 }
 
 double CSSPrimitiveValue::computeDegrees() const {
-  ASSERT(isAngle() ||
+  DCHECK(isAngle() ||
          (isCalculated() && cssCalcValue()->category() == CalcAngle));
   UnitType currentType =
       isCalculated() ? cssCalcValue()->expressionNode()->typeWithCalcResolved()
                      : type();
   switch (currentType) {
     case UnitType::Degrees:
       return getDoubleValue();
     case UnitType::Radians:
       return rad2deg(getDoubleValue());
     case UnitType::Gradians:
       return grad2deg(getDoubleValue());
     case UnitType::Turns:
       return turn2deg(getDoubleValue());
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return 0;
   }
 }
 
 template <>
 int CSSPrimitiveValue::computeLength(
     const CSSToLengthConversionData& conversionData) const {
   return roundForImpreciseConversion<int>(computeLengthDouble(conversionData));
 }
 
@@ skipping 46 matching lines @@
 
 double CSSPrimitiveValue::computeLengthDouble(
     const CSSToLengthConversionData& conversionData) const {
   if (type() == UnitType::Calc)
     return m_value.calc->computeLengthPx(conversionData);
   return conversionData.zoomedComputedPixels(getDoubleValue(), type());
 }
 
 void CSSPrimitiveValue::accumulateLengthArray(CSSLengthArray& lengthArray,
                                               double multiplier) const {
-  ASSERT(lengthArray.values.size() == LengthUnitTypeCount);
+  DCHECK_EQ(lengthArray.values.size(),
+            static_cast<unsigned>(LengthUnitTypeCount));
 
   if (type() == UnitType::Calc) {
     cssCalcValue()->accumulateLengthArray(lengthArray, multiplier);
     return;
   }
 
   LengthUnitType lengthType;
   bool conversionSuccess = unitTypeToLengthUnitType(type(), lengthType);
   DCHECK(conversionSuccess);
   lengthArray.values[lengthType] +=
@@ skipping 53 matching lines @@
 
   return factor;
 }
 
 Length CSSPrimitiveValue::convertToLength(
     const CSSToLengthConversionData& conversionData) const {
   if (isLength())
     return computeLength<Length>(conversionData);
   if (isPercentage())
     return Length(getDoubleValue(), Percent);
-  ASSERT(isCalculated());
+  DCHECK(isCalculated());
   return Length(cssCalcValue()->toCalcValue(conversionData));
 }
 
 double CSSPrimitiveValue::getDoubleValue() const {
   return type() != UnitType::Calc ? m_value.num : m_value.calc->doubleValue();
 }
 
 CSSPrimitiveValue::UnitType CSSPrimitiveValue::canonicalUnitTypeForCategory(
     UnitCategory category) {
   // The canonical unit type is chosen according to the way
@@ skipping 83 matching lines @@
       return CSSPrimitiveValue::UnitType::ViewportWidth;
     case UnitTypeViewportHeight:
       return CSSPrimitiveValue::UnitType::ViewportHeight;
     case UnitTypeViewportMin:
       return CSSPrimitiveValue::UnitType::ViewportMin;
     case UnitTypeViewportMax:
       return CSSPrimitiveValue::UnitType::ViewportMax;
     case LengthUnitTypeCount:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return CSSPrimitiveValue::UnitType::Unknown;
 }
 
 static String formatNumber(double number, const StringView& suffix) {
 #if OS(WIN) && _MSC_VER < 1900
   unsigned oldFormat = _set_output_format(_TWO_DIGIT_EXPONENT);
 #endif
   String result = String::format("%.6g", number);
 #if OS(WIN) && _MSC_VER < 1900
   _set_output_format(oldFormat);
@@ skipping 64 matching lines @@
     case UnitType::ViewportMax:
       return "vmax";
     case UnitType::Unknown:
     case UnitType::Calc:
     case UnitType::CalcPercentageWithNumber:
     case UnitType::CalcPercentageWithLength:
     case UnitType::CalcLengthWithNumber:
     case UnitType::CalcPercentageWithLengthAndNumber:
       break;
   };
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return "";
 }
 
 String CSSPrimitiveValue::customCSSText() const {
   if (m_hasCachedCSSText) {
-    ASSERT(cssTextCache().contains(this));
+    DCHECK(cssTextCache().contains(this));
     return cssTextCache().at(this);
   }
 
   String text;
   switch (type()) {
     case UnitType::Unknown:
       // FIXME
       break;
     case UnitType::Integer:
       text = String::format("%d", getIntValue());
@@ skipping 30 matching lines @@
     case UnitType::ViewportMax:
       text = formatNumber(m_value.num, unitTypeToString(type()));
       break;
     case UnitType::Calc:
       text = m_value.calc->customCSSText();
       break;
     case UnitType::CalcPercentageWithNumber:
     case UnitType::CalcPercentageWithLength:
     case UnitType::CalcLengthWithNumber:
     case UnitType::CalcPercentageWithLengthAndNumber:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
 
-  ASSERT(!cssTextCache().contains(this));
+  DCHECK(!cssTextCache().contains(this));
   cssTextCache().set(this, text);
   m_hasCachedCSSText = true;
   return text;
 }
 
 bool CSSPrimitiveValue::equals(const CSSPrimitiveValue& other) const {
   if (type() != other.type())
     return false;
 
   switch (type()) {
@@ skipping 48 matching lines @@
     case UnitType::Calc:
       visitor->trace(m_value.calc);
       break;
     default:
       break;
   }
   CSSValue::traceAfterDispatch(visitor);
 }
 
 }  // namespace blink