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

third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 192 matching lines @@
         convertGenericFamily(toCSSIdentifierValue(value).getValueID());
     familyName = state.fontBuilder().genericFontFamilyName(genericFamily);
   }
 
   return !familyName.isEmpty();
 }
 
 FontDescription::FamilyDescription StyleBuilderConverter::convertFontFamily(
     StyleResolverState& state,
     const CSSValue& value) {
-  ASSERT(value.isValueList());
+  DCHECK(value.isValueList());
 
   FontDescription::FamilyDescription desc(FontDescription::NoFamily);
   FontFamily* currFamily = nullptr;
 
   for (auto& family : toCSSValueList(value)) {
     FontDescription::GenericFamilyType genericFamily =
         FontDescription::NoFamily;
     AtomicString familyName;
 
     if (!convertFontFamilyName(state, *family, genericFamily, familyName))
@@ skipping 54 matching lines @@
 static float computeFontSize(StyleResolverState& state,
                              const CSSPrimitiveValue& primitiveValue,
                              const FontDescription::Size& parentSize) {
   if (primitiveValue.isLength())
     return primitiveValue.computeLength<float>(state.fontSizeConversionData());
   if (primitiveValue.isCalculatedPercentageWithLength())
     return primitiveValue.cssCalcValue()
         ->toCalcValue(state.fontSizeConversionData())
         ->evaluate(parentSize.value);
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return 0;
 }
 
 FontDescription::Size StyleBuilderConverter::convertFontSize(
     StyleResolverState& state,
     const CSSValue& value) {
   FontDescription::Size parentSize(0, 0.0f, false);
 
   // FIXME: Find out when parentStyle could be 0?
   if (state.parentStyle())
     parentSize = state.parentFontDescription().getSize();
 
   if (value.isIdentifierValue()) {
     CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
     if (FontSize::isValidValueID(valueID))
       return FontDescription::Size(FontSize::keywordSize(valueID), 0.0f, false);
     if (valueID == CSSValueSmaller)
       return FontDescription::smallerSize(parentSize);
     if (valueID == CSSValueLarger)
       return FontDescription::largerSize(parentSize);
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return FontBuilder::initialSize();
   }
 
   bool parentIsAbsoluteSize = state.parentFontDescription().isAbsoluteSize();
 
   const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
   if (primitiveValue.isPercentage())
     return FontDescription::Size(
         0, (primitiveValue.getFloatValue() * parentSize.value / 100.0f),
         parentIsAbsoluteSize);
 
   return FontDescription::Size(
       0, computeFontSize(state, primitiveValue, parentSize),
       parentIsAbsoluteSize || !primitiveValue.isFontRelativeLength());
 }
 
 float StyleBuilderConverter::convertFontSizeAdjust(StyleResolverState& state,
                                                    const CSSValue& value) {
   if (value.isIdentifierValue() &&
       toCSSIdentifierValue(value).getValueID() == CSSValueNone)
     return FontBuilder::initialSizeAdjust();
 
   const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-  ASSERT(primitiveValue.isNumber());
+  DCHECK(primitiveValue.isNumber());
   return primitiveValue.getFloatValue();
 }
 
 double StyleBuilderConverter::convertValueToNumber(
     const CSSFunctionValue* filter,
     const CSSPrimitiveValue* value) {
   switch (filter->functionType()) {
     case CSSValueGrayscale:
     case CSSValueSepia:
     case CSSValueSaturate:
@@ skipping 87 matching lines @@
         case CSSValueHistoricalLigatures:
           ligatures.historical = FontDescription::EnabledLigaturesState;
           break;
         case CSSValueNoContextual:
           ligatures.contextual = FontDescription::DisabledLigaturesState;
           break;
         case CSSValueContextual:
           ligatures.contextual = FontDescription::EnabledLigaturesState;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
           break;
       }
     }
     return ligatures;
   }
 
   SECURITY_DCHECK(value.isIdentifierValue());
   if (toCSSIdentifierValue(value).getValueID() == CSSValueNone) {
     return FontDescription::VariantLigatures(
         FontDescription::DisabledLigaturesState);
@@ skipping 33 matching lines @@
       case CSSValueStackedFractions:
         variantNumeric.setNumericFraction(FontVariantNumeric::StackedFractions);
         break;
       case CSSValueOrdinal:
         variantNumeric.setOrdinal(FontVariantNumeric::OrdinalOn);
         break;
       case CSSValueSlashedZero:
         variantNumeric.setSlashedZero(FontVariantNumeric::SlashedZeroOn);
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
   }
   return variantNumeric;
 }
 
 StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(
     StyleResolverState&,
     const CSSValue& value) {
   StyleSelfAlignmentData alignmentData = ComputedStyle::initialSelfAlignment();
@@ skipping 35 matching lines @@
       case CSSValueSpaceAround:
         alignmentData.setDistribution(
             identifierValue.convertTo<ContentDistributionType>());
         break;
       case CSSValueFlexStart:
       case CSSValueFlexEnd:
       case CSSValueCenter:
         alignmentData.setPosition(identifierValue.convertTo<ContentPosition>());
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     return alignmentData;
   }
   const CSSContentDistributionValue& contentValue =
       toCSSContentDistributionValue(value);
   if (contentValue.distribution()->getValueID() != CSSValueInvalid)
     alignmentData.setDistribution(
         contentValue.distribution()->convertTo<ContentDistributionType>());
   if (contentValue.position()->getValueID() != CSSValueInvalid)
     alignmentData.setPosition(
         contentValue.position()->convertTo<ContentPosition>());
   if (contentValue.overflow()->getValueID() != CSSValueInvalid)
     alignmentData.setOverflow(
         contentValue.overflow()->convertTo<OverflowAlignment>());
 
   return alignmentData;
 }
 
 GridAutoFlow StyleBuilderConverter::convertGridAutoFlow(StyleResolverState&,
                                                         const CSSValue& value) {
   const CSSValueList& list = toCSSValueList(value);
 
-  ASSERT(list.length() >= 1);
+  DCHECK_GE(list.length(), 1u);
   const CSSIdentifierValue& first = toCSSIdentifierValue(list.item(0));
   const CSSIdentifierValue* second =
       list.length() == 2 ? &toCSSIdentifierValue(list.item(1)) : nullptr;
 
   switch (first.getValueID()) {
     case CSSValueRow:
       if (second && second->getValueID() == CSSValueDense)
         return AutoFlowRowDense;
       return AutoFlowRow;
     case CSSValueColumn:
       if (second && second->getValueID() == CSSValueDense)
         return AutoFlowColumnDense;
       return AutoFlowColumn;
     case CSSValueDense:
       if (second && second->getValueID() == CSSValueColumn)
         return AutoFlowColumnDense;
       return AutoFlowRowDense;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return ComputedStyle::initialGridAutoFlow();
   }
 }
 
 GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&,
                                                         const CSSValue& value) {
   // We accept the specification's grammar:
   // 'auto' | [ <integer> || <custom-ident> ] |
   // [ span && [ <integer> || <custom-ident> ] ] | <custom-ident>
 
   GridPosition position;
 
   if (value.isCustomIdentValue()) {
     position.setNamedGridArea(toCSSCustomIdentValue(value).value());
     return position;
   }
 
   if (value.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
     return position;
   }
 
   const CSSValueList& values = toCSSValueList(value);
-  ASSERT(values.length());
+  DCHECK(values.length());
 
   bool isSpanPosition = false;
   // The specification makes the <integer> optional, in which case it default to
   // '1'.
   int gridLineNumber = 1;
   AtomicString gridLineName;
 
   auto it = values.begin();
   const CSSValue* currentValue = it->get();
   if (currentValue->isIdentifierValue() &&
       toCSSIdentifierValue(currentValue)->getValueID() == CSSValueSpan) {
     isSpanPosition = true;
     ++it;
     currentValue = it != values.end() ? it->get() : nullptr;
   }
 
   if (currentValue && currentValue->isPrimitiveValue() &&
       toCSSPrimitiveValue(currentValue)->isNumber()) {
     gridLineNumber = toCSSPrimitiveValue(currentValue)->getIntValue();
     ++it;
     currentValue = it != values.end() ? it->get() : nullptr;
   }
 
   if (currentValue && currentValue->isCustomIdentValue()) {
     gridLineName = toCSSCustomIdentValue(currentValue)->value();
     ++it;
   }
 
-  ASSERT(it == values.end());
+  DCHECK_EQ(it, values.end());
   if (isSpanPosition)
     position.setSpanPosition(gridLineNumber, gridLineName);
   else
     position.setExplicitPosition(gridLineNumber, gridLineName);
 
   return position;
 }
 
 GridTrackSize StyleBuilderConverter::convertGridTrackSize(
     StyleResolverState& state,
@@ skipping 12 matching lines @@
   GridLength minTrackBreadth(convertGridTrackBreadth(state, function.item(0)));
   GridLength maxTrackBreadth(convertGridTrackBreadth(state, function.item(1)));
   return GridTrackSize(minTrackBreadth, maxTrackBreadth);
 }
 
 static void convertGridLineNamesList(
     const CSSValue& value,
     size_t currentNamedGridLine,
     NamedGridLinesMap& namedGridLines,
     OrderedNamedGridLines& orderedNamedGridLines) {
-  ASSERT(value.isGridLineNamesValue());
+  DCHECK(value.isGridLineNamesValue());
 
   for (auto& namedGridLineValue : toCSSValueList(value)) {
     String namedGridLine = toCSSCustomIdentValue(*namedGridLineValue).value();
     NamedGridLinesMap::AddResult result =
         namedGridLines.insert(namedGridLine, Vector<size_t>());
     result.storedValue->value.push_back(currentNamedGridLine);
     OrderedNamedGridLines::AddResult orderedInsertionResult =
         orderedNamedGridLines.insert(currentNamedGridLine, Vector<String>());
     orderedInsertionResult.storedValue->value.push_back(namedGridLine);
   }
@@ skipping 30 matching lines @@
 
   size_t currentNamedGridLine = 0;
   for (auto currValue : toCSSValueList(value)) {
     if (currValue->isGridLineNamesValue()) {
       convertGridLineNamesList(*currValue, currentNamedGridLine, namedGridLines,
                                orderedNamedGridLines);
       continue;
     }
 
     if (currValue->isGridAutoRepeatValue()) {
-      ASSERT(autoRepeatTrackSizes.isEmpty());
+      DCHECK(autoRepeatTrackSizes.isEmpty());
       size_t autoRepeatIndex = 0;
       CSSValueID autoRepeatID =
           toCSSGridAutoRepeatValue(currValue.get())->autoRepeatID();
-      ASSERT(autoRepeatID == CSSValueAutoFill ||
+      DCHECK(autoRepeatID == CSSValueAutoFill ||
              autoRepeatID == CSSValueAutoFit);
       autoRepeatType = autoRepeatID == CSSValueAutoFill ? AutoFill : AutoFit;
       for (auto autoRepeatValue : toCSSValueList(*currValue)) {
         if (autoRepeatValue->isGridLineNamesValue()) {
           convertGridLineNamesList(*autoRepeatValue, autoRepeatIndex,
                                    autoRepeatNamedGridLines,
                                    autoRepeatOrderedNamedGridLines);
           continue;
         }
         ++autoRepeatIndex;
         autoRepeatTrackSizes.push_back(
             convertGridTrackSize(state, *autoRepeatValue));
       }
       autoRepeatInsertionPoint = currentNamedGridLine++;
       continue;
     }
 
     ++currentNamedGridLine;
     trackSizes.push_back(convertGridTrackSize(state, *currValue));
   }
 
   // The parser should have rejected any <track-list> without any <track-size>
   // as this is not conformant to the syntax.
-  ASSERT(!trackSizes.isEmpty() || !autoRepeatTrackSizes.isEmpty());
+  DCHECK(!trackSizes.isEmpty() || !autoRepeatTrackSizes.isEmpty());
 }
 
 void StyleBuilderConverter::convertOrderedNamedGridLinesMapToNamedGridLinesMap(
     const OrderedNamedGridLines& orderedNamedGridLines,
     NamedGridLinesMap& namedGridLines) {
-  ASSERT(namedGridLines.size() == 0);
+  DCHECK_EQ(namedGridLines.size(), 0u);
 
   if (orderedNamedGridLines.size() == 0)
     return;
 
   for (auto& orderedNamedGridLine : orderedNamedGridLines) {
     for (auto& lineName : orderedNamedGridLine.value) {
       NamedGridLinesMap::AddResult startResult =
           namedGridLines.insert(lineName, Vector<size_t>());
       startResult.storedValue->value.push_back(orderedNamedGridLine.key);
     }
@@ skipping 66 matching lines @@
     case CSSValueWebkitMaxContent:
       return Length(MaxContent);
     case CSSValueWebkitFillAvailable:
       return Length(FillAvailable);
     case CSSValueWebkitFitContent:
     case CSSValueFitContent:
       return Length(FitContent);
     case CSSValueAuto:
       return Length(Auto);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return Length();
   }
 }
 
 Length StyleBuilderConverter::convertLengthMaxSizing(StyleResolverState& state,
                                                      const CSSValue& value) {
   if (value.isIdentifierValue() &&
       toCSSIdentifierValue(value).getValueID() == CSSValueNone)
     return Length(MaxSizeNone);
   return convertLengthSizing(state, value);
@@ skipping 46 matching lines @@
   }
 
   DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNormal);
   return ComputedStyle::initialLineHeight();
 }
 
 float StyleBuilderConverter::convertNumberOrPercentage(
     StyleResolverState& state,
     const CSSValue& value) {
   const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-  ASSERT(primitiveValue.isNumber() || primitiveValue.isPercentage());
+  DCHECK(primitiveValue.isNumber() || primitiveValue.isPercentage());
   if (primitiveValue.isNumber())
     return primitiveValue.getFloatValue();
   return primitiveValue.getFloatValue() / 100.0f;
 }
 
 StyleOffsetRotation StyleBuilderConverter::convertOffsetRotate(
     StyleResolverState&,
     const CSSValue& value) {
   return convertOffsetRotate(value);
 }
 
 StyleOffsetRotation StyleBuilderConverter::convertOffsetRotate(
     const CSSValue& value) {
   StyleOffsetRotation result(0, OffsetRotationFixed);
 
   const CSSValueList& list = toCSSValueList(value);
-  ASSERT(list.length() == 1 || list.length() == 2);
+  DCHECK(list.length() == 1 || list.length() == 2);
   for (const auto& item : list) {
     if (item->isIdentifierValue() &&
         toCSSIdentifierValue(*item).getValueID() == CSSValueAuto) {
       result.type = OffsetRotationAuto;
     } else if (item->isIdentifierValue() &&
                toCSSIdentifierValue(*item).getValueID() == CSSValueReverse) {
       result.type = OffsetRotationAuto;
       result.angle = clampTo<float>(result.angle + 180);
     } else {
       const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(*item);
@@ skipping 46 matching lines @@
       case CSSValueFill:
         return orderTypeList.length() > 1 ? PaintOrderFillMarkersStroke
                                           : PaintOrderFillStrokeMarkers;
       case CSSValueStroke:
         return orderTypeList.length() > 1 ? PaintOrderStrokeMarkersFill
                                           : PaintOrderStrokeFillMarkers;
       case CSSValueMarkers:
         return orderTypeList.length() > 1 ? PaintOrderMarkersStrokeFill
                                           : PaintOrderMarkersFillStroke;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return PaintOrderNormal;
     }
   }
 
   return PaintOrderNormal;
 }
 
 Length StyleBuilderConverter::convertQuirkyLength(StyleResolverState& state,
                                                   const CSSValue& value) {
   Length length = convertLengthOrAuto(state, value);
@@ skipping 112 matching lines @@
     if (value.isBasicShapeValue()) {
       shape = basicShapeForValue(state, value);
     } else {
       cssBox = toCSSIdentifierValue(value).convertTo<CSSBoxType>();
     }
   }
 
   if (shape)
     return ShapeValue::createShapeValue(shape.release(), cssBox);
 
-  ASSERT(cssBox != BoxMissing);
+  DCHECK_NE(cssBox, BoxMissing);
   return ShapeValue::createBoxShapeValue(cssBox);
 }
 
 float StyleBuilderConverter::convertSpacing(StyleResolverState& state,
                                             const CSSValue& value) {
   if (value.isIdentifierValue() &&
       toCSSIdentifierValue(value).getValueID() == CSSValueNormal)
     return 0;
   return toCSSPrimitiveValue(value).computeLength<float>(
       state.cssToLengthConversionData());
@@ skipping 126 matching lines @@
 }
 
 PassRefPtr<TranslateTransformOperation> StyleBuilderConverter::convertTranslate(
     StyleResolverState& state,
     const CSSValue& value) {
   if (value.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return nullptr;
   }
   const CSSValueList& list = toCSSValueList(value);
-  ASSERT(list.length() <= 3);
+  DCHECK_LE(list.length(), 3u);
   Length tx = convertLength(state, list.item(0));
   Length ty(0, Fixed);
   double tz = 0;
   if (list.length() >= 2)
     ty = convertLength(state, list.item(1));
   if (list.length() == 3)
     tz = toCSSPrimitiveValue(list.item(2))
              .computeLength<double>(state.cssToLengthConversionData());
 
   return TranslateTransformOperation::create(tx, ty, tz,
                                              TransformOperation::Translate3D);
 }
 
 Rotation StyleBuilderConverter::convertRotation(const CSSValue& value) {
   if (value.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return Rotation(FloatPoint3D(0, 0, 1), 0);
   }
 
   const CSSValueList& list = toCSSValueList(value);
-  ASSERT(list.length() == 1 || list.length() == 4);
+  DCHECK(list.length() == 1 || list.length() == 4);
   double x = 0;
   double y = 0;
   double z = 1;
   if (list.length() == 4) {
     x = toCSSPrimitiveValue(list.item(0)).getDoubleValue();
     y = toCSSPrimitiveValue(list.item(1)).getDoubleValue();
     z = toCSSPrimitiveValue(list.item(2)).getDoubleValue();
   }
   double angle =
       toCSSPrimitiveValue(list.item(list.length() - 1)).computeDegrees();
@@ skipping 14 matching lines @@
 
 PassRefPtr<ScaleTransformOperation> StyleBuilderConverter::convertScale(
     StyleResolverState& state,
     const CSSValue& value) {
   if (value.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return nullptr;
   }
 
   const CSSValueList& list = toCSSValueList(value);
-  ASSERT(list.length() <= 3);
+  DCHECK_LE(list.length(), 3u);
   double sx = toCSSPrimitiveValue(list.item(0)).getDoubleValue();
   double sy = 1;
   double sz = 1;
   if (list.length() >= 2)
     sy = toCSSPrimitiveValue(list.item(1)).getDoubleValue();
   if (list.length() == 3)
     sz = toCSSPrimitiveValue(list.item(2)).getDoubleValue();
 
   return ScaleTransformOperation::create(sx, sy, sz,
                                          TransformOperation::Scale3D);
@@ skipping 53 matching lines @@
 }
 
 const CSSValue& StyleBuilderConverter::convertRegisteredPropertyValue(
     const StyleResolverState& state,
     const CSSValue& value) {
   return computeRegisteredPropertyValue(state.cssToLengthConversionData(),
                                         value);
 }
 
 }  // namespace blink