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

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

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 103 matching lines @@
   CSSValueList* positionList = CSSValueList::createSpaceSeparated();
   if (layer.isBackgroundXOriginSet()) {
     DCHECK(propertyID == CSSPropertyBackgroundPosition ||
            propertyID == CSSPropertyWebkitMaskPosition);
     positionList->append(
         *CSSIdentifierValue::create(layer.backgroundXOrigin()));
   }
   positionList->append(
       *zoomAdjustedPixelValueForLength(layer.xPosition(), style));
   if (layer.isBackgroundYOriginSet()) {
-    ASSERT(propertyID == CSSPropertyBackgroundPosition ||
+    DCHECK(propertyID == CSSPropertyBackgroundPosition ||
            propertyID == CSSPropertyWebkitMaskPosition);
     positionList->append(
         *CSSIdentifierValue::create(layer.backgroundYOrigin()));
   }
   positionList->append(
       *zoomAdjustedPixelValueForLength(layer.yPosition(), style));
   return positionList;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::currentColorOrValidColor(
@@ skipping 377 matching lines @@
     result->append(
         *CSSValuePair::create(CSSIdentifierValue::create(CSSValueLast),
                               CSSIdentifierValue::create(CSSValueBaseline),
                               CSSValuePair::DropIdenticalValues));
   } else {
     result->append(*CSSIdentifierValue::create(data.position()));
   }
   if (data.position() >= ItemPositionCenter &&
       data.overflow() != OverflowAlignmentDefault)
     result->append(*CSSIdentifierValue::create(data.overflow()));
-  ASSERT(result->length() <= 2);
+  DCHECK_LE(result->length(), 2u);
   return result;
 }
 
 static CSSValueList* valuesForGridShorthand(
     const StylePropertyShorthand& shorthand,
     const ComputedStyle& style,
     const LayoutObject* layoutObject,
     Node* styledNode,
     bool allowVisitedStyle) {
   CSSValueList* list = CSSValueList::createSlashSeparated();
   for (size_t i = 0; i < shorthand.length(); ++i) {
     const CSSValue* value = ComputedStyleCSSValueMapping::get(
         shorthand.properties()[i], style, layoutObject, styledNode,
         allowVisitedStyle);
-    ASSERT(value);
+    DCHECK(value);
     list->append(*value);
   }
   return list;
 }
 
 static CSSValueList* valuesForShorthandProperty(
     const StylePropertyShorthand& shorthand,
     const ComputedStyle& style,
     const LayoutObject* layoutObject,
     Node* styledNode,
     bool allowVisitedStyle) {
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   for (size_t i = 0; i < shorthand.length(); ++i) {
     const CSSValue* value = ComputedStyleCSSValueMapping::get(
         shorthand.properties()[i], style, layoutObject, styledNode,
         allowVisitedStyle);
-    ASSERT(value);
+    DCHECK(value);
     list->append(*value);
   }
   return list;
 }
 
 static CSSValue* expandNoneLigaturesValue() {
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(*CSSIdentifierValue::create(CSSValueNoCommonLigatures));
   list->append(*CSSIdentifierValue::create(CSSValueNoDiscretionaryLigatures));
   list->append(*CSSIdentifierValue::create(CSSValueNoHistoricalLigatures));
@@ skipping 28 matching lines @@
     case AllNormal:
       return CSSIdentifierValue::create(CSSValueNormal);
     case NoneLigatures:
       return CSSIdentifierValue::create(CSSValueNone);
     case ConcatenateNonNormal: {
       CSSValueList* list = CSSValueList::createSpaceSeparated();
       for (size_t i = 0; i < fontVariantShorthand().length(); ++i) {
         const CSSValue* value = ComputedStyleCSSValueMapping::get(
             fontVariantShorthand().properties()[i], style, layoutObject,
             styledNode, allowVisitedStyle);
-        ASSERT(value);
+        DCHECK(value);
         if (value->isIdentifierValue() &&
             toCSSIdentifierValue(value)->getValueID() == CSSValueNone) {
           list->append(*expandNoneLigaturesValue());
         } else if (!(value->isIdentifierValue() &&
                      toCSSIdentifierValue(value)->getValueID() ==
                          CSSValueNormal)) {
           list->append(*value);
         }
       }
       return list;
@@ skipping 11 matching lines @@
     bool allowVisitedStyle) {
   CSSValueList* ret = CSSValueList::createCommaSeparated();
   const FillLayer* currLayer = &style.backgroundLayers();
   for (; currLayer; currLayer = currLayer->next()) {
     CSSValueList* list = CSSValueList::createSlashSeparated();
     CSSValueList* beforeSlash = CSSValueList::createSpaceSeparated();
     if (!currLayer->next()) {  // color only for final layer
       const CSSValue* value = ComputedStyleCSSValueMapping::get(
           CSSPropertyBackgroundColor, style, layoutObject, styledNode,
           allowVisitedStyle);
-      ASSERT(value);
+      DCHECK(value);
       beforeSlash->append(*value);
     }
     beforeSlash->append(currLayer->image()
                             ? *currLayer->image()->computedCSSValue()
                             : *CSSIdentifierValue::create(CSSValueNone));
     beforeSlash->append(
         *valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
     beforeSlash->append(*CSSIdentifierValue::create(currLayer->attachment()));
     beforeSlash->append(*createPositionListForLayer(
         CSSPropertyBackgroundPosition, *currLayer, style));
@@ skipping 36 matching lines @@
       break;
     default:
       result->append(*CSSIdentifierValue::create(data.position()));
   }
 
   // Handle overflow-alignment (only allowed for content-position values)
   if ((data.position() >= ContentPositionCenter ||
        data.distribution() != ContentDistributionDefault) &&
       data.overflow() != OverflowAlignmentDefault)
     result->append(*CSSIdentifierValue::create(data.overflow()));
-  ASSERT(result->length() > 0);
-  ASSERT(result->length() <= 3);
+  DCHECK_GT(result->length(), 0u);
+  DCHECK_LE(result->length(), 3u);
   return result;
 }
 
 static CSSValue* valueForLineHeight(const ComputedStyle& style) {
   Length length = style.lineHeight();
   if (length.isNegative())
     return CSSIdentifierValue::create(CSSValueNormal);
 
   return zoomAdjustedPixelValue(
       floatValueForLength(length, style.getFontDescription().computedSize()),
@@ skipping 197 matching lines @@
       return minMaxTrackBreadths;
     }
     case FitContentTrackSizing: {
       auto* fitContentTrackBreadth =
           CSSFunctionValue::create(CSSValueFitContent);
       fitContentTrackBreadth->append(*specifiedValueForGridTrackBreadth(
           trackSize.fitContentTrackBreadth(), style));
       return fitContentTrackBreadth;
     }
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return nullptr;
 }
 
 class OrderedNamedLinesCollector {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(OrderedNamedLinesCollector);
 
  public:
   OrderedNamedLinesCollector(const ComputedStyle& style,
                              bool isRowAxis,
@@ skipping 216 matching lines @@
     case TextDecorationStyleDouble:
       return CSSIdentifierValue::create(CSSValueDouble);
     case TextDecorationStyleDotted:
       return CSSIdentifierValue::create(CSSValueDotted);
     case TextDecorationStyleDashed:
       return CSSIdentifierValue::create(CSSValueDashed);
     case TextDecorationStyleWavy:
       return CSSIdentifierValue::create(CSSValueWavy);
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return CSSInitialValue::create();
 }
 
 static CSSValue* valueForTextDecorationSkip(
     TextDecorationSkip textDecorationSkip) {
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   if (textDecorationSkip & TextDecorationSkipObjects)
     list->append(*CSSIdentifierValue::create(CSSValueObjects));
   if (textDecorationSkip & TextDecorationSkipInk)
     list->append(*CSSIdentifierValue::create(CSSValueInk));
@@ skipping 21 matching lines @@
       list->append(*CSSIdentifierValue::create(CSSValuePanY));
     else if (touchAction & TouchActionPanUp)
       list->append(*CSSIdentifierValue::create(CSSValuePanUp));
     else if (touchAction & TouchActionPanDown)
       list->append(*CSSIdentifierValue::create(CSSValuePanDown));
 
     if ((touchAction & TouchActionPinchZoom) == TouchActionPinchZoom)
       list->append(*CSSIdentifierValue::create(CSSValuePinchZoom));
   }
 
-  ASSERT(list->length());
+  DCHECK(list->length());
   return list;
 }
 
 static CSSValue* valueForWillChange(
     const Vector<CSSPropertyID>& willChangeProperties,
     bool willChangeContents,
     bool willChangeScrollPosition) {
   CSSValueList* list = CSSValueList::createCommaSeparated();
   if (willChangeContents)
     list->append(*CSSIdentifierValue::create(CSSValueContents));
@@ skipping 24 matching lines @@
   switch (direction) {
     case Timing::PlaybackDirection::NORMAL:
       return CSSIdentifierValue::create(CSSValueNormal);
     case Timing::PlaybackDirection::ALTERNATE_NORMAL:
       return CSSIdentifierValue::create(CSSValueAlternate);
     case Timing::PlaybackDirection::REVERSE:
       return CSSIdentifierValue::create(CSSValueReverse);
     case Timing::PlaybackDirection::ALTERNATE_REVERSE:
       return CSSIdentifierValue::create(CSSValueAlternateReverse);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
   }
 }
 
 static CSSValue* valueForAnimationDuration(const CSSTimingData* timingData) {
   CSSValueList* list = CSSValueList::createCommaSeparated();
   if (timingData) {
     for (size_t i = 0; i < timingData->durationList().size(); ++i)
       list->append(*CSSPrimitiveValue::create(
           timingData->durationList()[i], CSSPrimitiveValue::UnitType::Seconds));
   } else {
     list->append(
         *CSSPrimitiveValue::create(CSSTimingData::initialDuration(),
                                    CSSPrimitiveValue::UnitType::Seconds));
   }
   return list;
 }
 
 static CSSValue* valueForAnimationFillMode(Timing::FillMode fillMode) {
   switch (fillMode) {
     case Timing::FillMode::NONE:
       return CSSIdentifierValue::create(CSSValueNone);
     case Timing::FillMode::FORWARDS:
       return CSSIdentifierValue::create(CSSValueForwards);
     case Timing::FillMode::BACKWARDS:
       return CSSIdentifierValue::create(CSSValueBackwards);
     case Timing::FillMode::BOTH:
       return CSSIdentifierValue::create(CSSValueBoth);
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
   }
 }
 
 static CSSValue* valueForAnimationIterationCount(double iterationCount) {
   if (iterationCount == std::numeric_limits<double>::infinity())
     return CSSIdentifierValue::create(CSSValueInfinite);
   return CSSPrimitiveValue::create(iterationCount,
                                    CSSPrimitiveValue::UnitType::Number);
 }
 
 static CSSValue* valueForAnimationPlayState(EAnimPlayState playState) {
   if (playState == AnimPlayStatePlaying)
     return CSSIdentifierValue::create(CSSValueRunning);
-  ASSERT(playState == AnimPlayStatePaused);
+  DCHECK_EQ(playState, AnimPlayStatePaused);
   return CSSIdentifierValue::create(CSSValuePaused);
 }
 
 static CSSValue* createTimingFunctionValue(
     const TimingFunction* timingFunction) {
   switch (timingFunction->getType()) {
     case TimingFunction::Type::CUBIC_BEZIER: {
       const CubicBezierTimingFunction* bezierTimingFunction =
           toCubicBezierTimingFunction(timingFunction);
       if (bezierTimingFunction->getEaseType() !=
           CubicBezierTimingFunction::EaseType::CUSTOM) {
         CSSValueID valueId = CSSValueInvalid;
         switch (bezierTimingFunction->getEaseType()) {
           case CubicBezierTimingFunction::EaseType::EASE:
             valueId = CSSValueEase;
             break;
           case CubicBezierTimingFunction::EaseType::EASE_IN:
             valueId = CSSValueEaseIn;
             break;
           case CubicBezierTimingFunction::EaseType::EASE_OUT:
             valueId = CSSValueEaseOut;
             break;
           case CubicBezierTimingFunction::EaseType::EASE_IN_OUT:
             valueId = CSSValueEaseInOut;
             break;
           default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
             return nullptr;
         }
         return CSSIdentifierValue::create(valueId);
       }
       return CSSCubicBezierTimingFunctionValue::create(
           bezierTimingFunction->x1(), bezierTimingFunction->y1(),
           bezierTimingFunction->x2(), bezierTimingFunction->y2());
     }
 
     case TimingFunction::Type::STEPS: {
@@ skipping 140 matching lines @@
 
   return list;
 }
 
 static CSSValue* createTransitionPropertyValue(
     const CSSTransitionData::TransitionProperty& property) {
   if (property.propertyType == CSSTransitionData::TransitionNone)
     return CSSIdentifierValue::create(CSSValueNone);
   if (property.propertyType == CSSTransitionData::TransitionUnknownProperty)
     return CSSCustomIdentValue::create(property.propertyString);
-  ASSERT(property.propertyType == CSSTransitionData::TransitionKnownProperty);
+  DCHECK_EQ(property.propertyType, CSSTransitionData::TransitionKnownProperty);
   return CSSCustomIdentValue::create(
       getPropertyNameAtomicString(property.unresolvedProperty));
 }
 
 static CSSValue* valueForTransitionProperty(
     const CSSTransitionData* transitionData) {
   CSSValueList* list = CSSValueList::createCommaSeparated();
   if (transitionData) {
     for (size_t i = 0; i < transitionData->propertyList().size(); ++i)
       list->append(
           *createTransitionPropertyValue(transitionData->propertyList()[i]));
   } else {
     list->append(*CSSIdentifierValue::create(CSSValueAll));
   }
   return list;
 }
 
 CSSValueID valueForQuoteType(const QuoteType quoteType) {
   switch (quoteType) {
     case NO_OPEN_QUOTE:
       return CSSValueNoOpenQuote;
     case NO_CLOSE_QUOTE:
       return CSSValueNoCloseQuote;
     case CLOSE_QUOTE:
       return CSSValueCloseQuote;
     case OPEN_QUOTE:
       return CSSValueOpenQuote;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return CSSValueInvalid;
 }
 
 static CSSValue* valueForContentData(const ComputedStyle& style) {
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   for (const ContentData* contentData = style.contentData(); contentData;
        contentData = contentData->next()) {
     if (contentData->isCounter()) {
       const CounterContent* counter =
           toCounterContentData(contentData)->counter();
-      ASSERT(counter);
+      DCHECK(counter);
       CSSCustomIdentValue* identifier =
           CSSCustomIdentValue::create(counter->identifier());
       CSSStringValue* separator = CSSStringValue::create(counter->separator());
       CSSValueID listStyleIdent = CSSValueNone;
       if (counter->listStyle() != EListStyleType::kNone) {
         // TODO(sashab): Change this to use a converter instead of
         // CSSPrimitiveValueMappings.
         listStyleIdent =
             CSSIdentifierValue::create(counter->listStyle())->getValueID();
       }
       CSSIdentifierValue* listStyle =
           CSSIdentifierValue::create(listStyleIdent);
       list->append(*CSSCounterValue::create(identifier, listStyle, separator));
     } else if (contentData->isImage()) {
       const StyleImage* image = toImageContentData(contentData)->image();
-      ASSERT(image);
+      DCHECK(image);
       list->append(*image->computedCSSValue());
     } else if (contentData->isText()) {
       list->append(
           *CSSStringValue::create(toTextContentData(contentData)->text()));
     } else if (contentData->isQuote()) {
       const QuoteType quoteType = toQuoteContentData(contentData)->quote();
       list->append(*CSSIdentifierValue::create(valueForQuoteType(quoteType)));
     } else {
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
     }
   }
   return list;
 }
 
 static CSSValue* valueForCounterDirectives(const ComputedStyle& style,
                                            CSSPropertyID propertyID) {
   const CounterDirectiveMap* map = style.counterDirectives();
   if (!map)
     return CSSIdentifierValue::create(CSSValueNone);
@@ skipping 25 matching lines @@
   if (!shapeValue)
     return CSSIdentifierValue::create(CSSValueNone);
   if (shapeValue->type() == ShapeValue::Box)
     return CSSIdentifierValue::create(shapeValue->cssBox());
   if (shapeValue->type() == ShapeValue::Image) {
     if (shapeValue->image())
       return shapeValue->image()->computedCSSValue();
     return CSSIdentifierValue::create(CSSValueNone);
   }
 
-  ASSERT(shapeValue->type() == ShapeValue::Shape);
+  DCHECK_EQ(shapeValue->type(), ShapeValue::Shape);
 
   CSSValueList* list = CSSValueList::createSpaceSeparated();
   list->append(*valueForBasicShape(style, shapeValue->shape()));
   if (shapeValue->cssBox() != BoxMissing)
     list->append(*CSSIdentifierValue::create(shapeValue->cssBox()));
   return list;
 }
 
 static CSSValueList* valuesForSidesShorthand(
     const StylePropertyShorthand& shorthand,
@@ skipping 108 matching lines @@
   for (int i = 0; i < 3; i++) {
     EPaintOrderType paintOrderType = svgStyle.paintOrderType(i);
     switch (paintOrderType) {
       case PT_FILL:
       case PT_STROKE:
       case PT_MARKERS:
         list->append(*CSSIdentifierValue::create(paintOrderType));
         break;
       case PT_NONE:
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
   }
 
   return list;
 }
 
 static CSSValue* adjustSVGPaintForCurrentColor(SVGPaintType paintType,
                                                const String& url,
                                                const Color& color,
@@ skipping 129 matching lines @@
         const auto& dropShadowOperation =
             toDropShadowFilterOperation(*filterOperation);
         filterValue = CSSFunctionValue::create(CSSValueDropShadow);
         // We want our computed style to look like that of a text shadow (has
         // neither spread nor inset style).
         filterValue->append(
             *valueForShadowData(dropShadowOperation.shadow(), style, false));
         break;
       }
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
     list->append(*filterValue);
   }
 
   return list;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::valueForFont(
     const ComputedStyle& style) {
@@ skipping 572 matching lines @@
       switch (style.getGridAutoFlow()) {
         case AutoFlowRow:
         case AutoFlowRowDense:
           list->append(*CSSIdentifierValue::create(CSSValueRow));
           break;
         case AutoFlowColumn:
         case AutoFlowColumnDense:
           list->append(*CSSIdentifierValue::create(CSSValueColumn));
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
 
       switch (style.getGridAutoFlow()) {
         case AutoFlowRowDense:
         case AutoFlowColumnDense:
           list->append(*CSSIdentifierValue::create(CSSValueDense));
           break;
         default:
           // Do nothing.
           break;
@@ skipping 37 matching lines @@
                                     styledNode, allowVisitedStyle);
     case CSSPropertyGridTemplate:
       return valuesForGridShorthand(gridTemplateShorthand(), style,
                                     layoutObject, styledNode,
                                     allowVisitedStyle);
     case CSSPropertyGrid:
       return valuesForGridShorthand(gridShorthand(), style, layoutObject,
                                     styledNode, allowVisitedStyle);
     case CSSPropertyGridTemplateAreas:
       if (!style.namedGridAreaRowCount()) {
-        ASSERT(!style.namedGridAreaColumnCount());
+        DCHECK(!style.namedGridAreaColumnCount());
         return CSSIdentifierValue::create(CSSValueNone);
       }
 
       return CSSGridTemplateAreasValue::create(
           style.namedGridArea(), style.namedGridAreaRowCount(),
           style.namedGridAreaColumnCount());
     case CSSPropertyGridColumnGap:
       return zoomAdjustedPixelValueForLength(style.gridColumnGap(), style);
     case CSSPropertyGridRowGap:
       return zoomAdjustedPixelValueForLength(style.gridRowGap(), style);
@@ skipping 271 matching lines @@
       return currentColorOrValidColor(style, style.textEmphasisColor());
     case CSSPropertyWebkitTextEmphasisPosition:
       return CSSIdentifierValue::create(style.getTextEmphasisPosition());
     case CSSPropertyWebkitTextEmphasisStyle:
       switch (style.getTextEmphasisMark()) {
         case TextEmphasisMarkNone:
           return CSSIdentifierValue::create(CSSValueNone);
         case TextEmphasisMarkCustom:
           return CSSStringValue::create(style.textEmphasisCustomMark());
         case TextEmphasisMarkAuto:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
         // Fall through
         case TextEmphasisMarkDot:
         case TextEmphasisMarkCircle:
         case TextEmphasisMarkDoubleCircle:
         case TextEmphasisMarkTriangle:
         case TextEmphasisMarkSesame: {
           CSSValueList* list = CSSValueList::createSpaceSeparated();
           list->append(
               *CSSIdentifierValue::create(style.getTextEmphasisFill()));
           list->append(
@@ skipping 54 matching lines @@
         case EVerticalAlign::kTop:
           return CSSIdentifierValue::create(CSSValueTop);
         case EVerticalAlign::kBottom:
           return CSSIdentifierValue::create(CSSValueBottom);
         case EVerticalAlign::kBaselineMiddle:
           return CSSIdentifierValue::create(CSSValueWebkitBaselineMiddle);
         case EVerticalAlign::kLength:
           return zoomAdjustedPixelValueForLength(style.getVerticalAlignLength(),
                                                  style);
       }
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
     case CSSPropertyVisibility:
       return CSSIdentifierValue::create(style.visibility());
     case CSSPropertyWhiteSpace:
       return CSSIdentifierValue::create(style.whiteSpace());
     case CSSPropertyWidows:
       return CSSPrimitiveValue::create(style.widows(),
                                        CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyWidth:
       if (layoutObject) {
@@ skipping 541 matching lines @@
     case CSSPropertyWebkitPaddingEnd:
     case CSSPropertyWebkitPaddingStart:
     case CSSPropertyWebkitPaddingAfter:
     case CSSPropertyWebkitPaddingBefore:
     case CSSPropertyWebkitLogicalWidth:
     case CSSPropertyWebkitLogicalHeight:
     case CSSPropertyWebkitMinLogicalWidth:
     case CSSPropertyWebkitMinLogicalHeight:
     case CSSPropertyWebkitMaxLogicalWidth:
     case CSSPropertyWebkitMaxLogicalHeight:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
 
     // Unimplemented @font-face properties.
     case CSSPropertySrc:
     case CSSPropertyUnicodeRange:
       return nullptr;
 
     // Other unimplemented properties.
     case CSSPropertyPage:  // for @page
     case CSSPropertySize:  // for @page
@@ skipping 101 matching lines @@
     case CSSPropertyBaselineShift: {
       switch (svgStyle.baselineShift()) {
         case BS_SUPER:
           return CSSIdentifierValue::create(CSSValueSuper);
         case BS_SUB:
           return CSSIdentifierValue::create(CSSValueSub);
         case BS_LENGTH:
           return zoomAdjustedPixelValueForLength(svgStyle.baselineShiftValue(),
                                                  style);
       }
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
     }
     case CSSPropertyBufferedRendering:
       return CSSIdentifierValue::create(svgStyle.bufferedRendering());
     case CSSPropertyPaintOrder:
       return paintOrderToCSSValueList(svgStyle);
     case CSSPropertyVectorEffect:
       return CSSIdentifierValue::create(svgStyle.vectorEffect());
     case CSSPropertyMaskType:
       return CSSIdentifierValue::create(svgStyle.maskType());
@@ skipping 104 matching lines @@
 
       CSSValueList* list = CSSValueList::createSpaceSeparated();
       if (style.containsStyle())
         list->append(*CSSIdentifierValue::create(CSSValueStyle));
       if (style.contain() & ContainsLayout)
         list->append(*CSSIdentifierValue::create(CSSValueLayout));
       if (style.containsPaint())
         list->append(*CSSIdentifierValue::create(CSSValuePaint));
       if (style.containsSize())
         list->append(*CSSIdentifierValue::create(CSSValueSize));
-      ASSERT(list->length());
+      DCHECK(list->length());
       return list;
     }
     case CSSPropertyVariable:
       // Variables are retrieved via get(AtomicString).
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return nullptr;
     case CSSPropertyAll:
       return nullptr;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return nullptr;
 }
 
 }  // namespace blink