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

third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h

 /*
  * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 39 matching lines @@
 #include "platform/text/TextRun.h"
 #include "platform/text/WritingMode.h"
 #include "public/platform/WebBlendMode.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 // TODO(sashab): Move these to CSSPrimitiveValue.h.
 template <>
 inline short CSSPrimitiveValue::convertTo() const {
-  ASSERT(isNumber());
+  DCHECK(isNumber());
   return clampTo<short>(getDoubleValue());
 }
 
 template <>
 inline unsigned short CSSPrimitiveValue::convertTo() const {
-  ASSERT(isNumber());
+  DCHECK(isNumber());
   return clampTo<unsigned short>(getDoubleValue());
 }
 
 template <>
 inline int CSSPrimitiveValue::convertTo() const {
-  ASSERT(isNumber());
+  DCHECK(isNumber());
   return clampTo<int>(getDoubleValue());
 }
 
 template <>
 inline unsigned CSSPrimitiveValue::convertTo() const {
-  ASSERT(isNumber());
+  DCHECK(isNumber());
   return clampTo<unsigned>(getDoubleValue());
 }
 
 template <>
 inline float CSSPrimitiveValue::convertTo() const {
-  ASSERT(isNumber());
+  DCHECK(isNumber());
   return clampTo<float>(getDoubleValue());
 }
 
 template <>
 inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
     : CSSValue(PrimitiveClass) {
   init(i.isPercentage() ? UnitType::Percentage : UnitType::Integer);
   m_value.num = static_cast<double>(i.value());
 }
 
 template <>
 inline LineClampValue CSSPrimitiveValue::convertTo() const {
   if (type() == UnitType::Integer)
     return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount);
 
   if (type() == UnitType::Percentage)
     return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage);
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return LineClampValue();
 }
 
 // TODO(sashab): Move these to CSSIdentifierValueMappings.h, and update to use
 // the CSSValuePool.
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(CSSReflectionDirection e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case ReflectionAbove:
@@ skipping 18 matching lines @@
     case CSSValueBelow:
       return ReflectionBelow;
     case CSSValueLeft:
       return ReflectionLeft;
     case CSSValueRight:
       return ReflectionRight;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ReflectionBelow;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ColumnFill columnFill)
     : CSSValue(IdentifierClass) {
   switch (columnFill) {
     case ColumnFillAuto:
       m_valueID = CSSValueAuto;
       break;
     case ColumnFillBalance:
       m_valueID = CSSValueBalance;
       break;
   }
 }
 
 template <>
 inline ColumnFill CSSIdentifierValue::convertTo() const {
   if (m_valueID == CSSValueBalance)
     return ColumnFillBalance;
   if (m_valueID == CSSValueAuto)
     return ColumnFillAuto;
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ColumnFillBalance;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ColumnSpan columnSpan)
     : CSSValue(IdentifierClass) {
   switch (columnSpan) {
     case ColumnSpanAll:
       m_valueID = CSSValueAll;
       break;
     case ColumnSpanNone:
       m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
 inline ColumnSpan CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueAll:
       return ColumnSpanAll;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
     // fall-through
     case CSSValueNone:
       return ColumnSpanNone;
   }
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBorderStyle e)
     : CSSValue(IdentifierClass) {
   switch (e) {
@@ skipping 78 matching lines @@
     case CompositeDestinationAtop:
       m_valueID = CSSValueDestinationAtop;
       break;
     case CompositeXOR:
       m_valueID = CSSValueXor;
       break;
     case CompositePlusLighter:
       m_valueID = CSSValuePlusLighter;
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
 }
 
 template <>
 inline CompositeOperator CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueClear:
       return CompositeClear;
     case CSSValueCopy:
@@ skipping 15 matching lines @@
     case CSSValueDestinationAtop:
       return CompositeDestinationAtop;
     case CSSValueXor:
       return CompositeXOR;
     case CSSValuePlusLighter:
       return CompositePlusLighter;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return CompositeClear;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ControlPart e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case NoControlPart:
       m_valueID = CSSValueNone;
       break;
@@ skipping 174 matching lines @@
 inline EBackfaceVisibility CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueVisible:
       return BackfaceVisibilityVisible;
     case CSSValueHidden:
       return BackfaceVisibilityHidden;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return BackfaceVisibilityHidden;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case ScrollBackgroundAttachment:
       m_valueID = CSSValueScroll;
       break;
@@ skipping 12 matching lines @@
     case CSSValueScroll:
       return ScrollBackgroundAttachment;
     case CSSValueLocal:
       return LocalBackgroundAttachment;
     case CSSValueFixed:
       return FixedBackgroundAttachment;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ScrollBackgroundAttachment;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case BorderFillBox:
       m_valueID = CSSValueBorderBox;
       break;
@@ skipping 20 matching lines @@
       return PaddingFillBox;
     case CSSValueContent:
     case CSSValueContentBox:
       return ContentFillBox;
     case CSSValueText:
       return TextFillBox;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return BorderFillBox;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case RepeatFill:
       m_valueID = CSSValueRepeat;
       break;
@@ skipping 17 matching lines @@
     case CSSValueNoRepeat:
       return NoRepeatFill;
     case CSSValueRound:
       return RoundFill;
     case CSSValueSpace:
       return SpaceFill;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return RepeatFill;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case BoxPackStart:
       m_valueID = CSSValueStart;
       break;
@@ skipping 17 matching lines @@
     case CSSValueEnd:
       return BoxPackEnd;
     case CSSValueCenter:
       return BoxPackCenter;
     case CSSValueJustify:
       return BoxPackJustify;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return BoxPackJustify;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case BSTRETCH:
       m_valueID = CSSValueStretch;
       break;
@@ skipping 22 matching lines @@
     case CSSValueEnd:
       return BEND;
     case CSSValueCenter:
       return BCENTER;
     case CSSValueBaseline:
       return BBASELINE;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return BSTRETCH;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case BoxDecorationBreakSlice:
       m_valueID = CSSValueSlice;
       break;
     case BoxDecorationBreakClone:
       m_valueID = CSSValueClone;
       break;
   }
 }
 
 template <>
 inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueSlice:
       return BoxDecorationBreakSlice;
     case CSSValueClone:
       return BoxDecorationBreakClone;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return BoxDecorationBreakSlice;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TopEdge:
       m_valueID = CSSValueTop;
       break;
@@ skipping 17 matching lines @@
     case CSSValueRight:
       return RightEdge;
     case CSSValueBottom:
       return BottomEdge;
     case CSSValueLeft:
       return LeftEdge;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TopEdge;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case EBoxSizing::kBorderBox:
       m_valueID = CSSValueBorderBox;
       break;
     case EBoxSizing::kContentBox:
       m_valueID = CSSValueContentBox;
       break;
   }
 }
 
 template <>
 inline EBoxSizing CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueBorderBox:
       return EBoxSizing::kBorderBox;
     case CSSValueContentBox:
       return EBoxSizing::kContentBox;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return EBoxSizing::kBorderBox;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case SINGLE:
       m_valueID = CSSValueSingle;
       break;
     case MULTIPLE:
       m_valueID = CSSValueMultiple;
       break;
   }
 }
 
 template <>
 inline EBoxLines CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueSingle:
       return SINGLE;
     case CSSValueMultiple:
       return MULTIPLE;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SINGLE;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case HORIZONTAL:
       m_valueID = CSSValueHorizontal;
       break;
     case VERTICAL:
       m_valueID = CSSValueVertical;
       break;
   }
 }
 
 template <>
 inline EBoxOrient CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueHorizontal:
     case CSSValueInlineAxis:
       return HORIZONTAL;
     case CSSValueVertical:
     case CSSValueBlockAxis:
       return VERTICAL;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return HORIZONTAL;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ECursor e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case ECursor::kAuto:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 349 matching lines @@
     case CSSValueRowReverse:
       return FlowRowReverse;
     case CSSValueColumn:
       return FlowColumn;
     case CSSValueColumnReverse:
       return FlowColumnReverse;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FlowRow;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case FlexNoWrap:
       m_valueID = CSSValueNowrap;
       break;
@@ skipping 12 matching lines @@
     case CSSValueNowrap:
       return FlexNoWrap;
     case CSSValueWrap:
       return FlexWrap;
     case CSSValueWrapReverse:
       return FlexWrapReverse;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FlexNoWrap;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EFloat e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case EFloat::kNone:
       m_valueID = CSSValueNone;
       break;
@@ skipping 12 matching lines @@
     case CSSValueLeft:
       return EFloat::kLeft;
     case CSSValueRight:
       return EFloat::kRight;
     case CSSValueNone:
       return EFloat::kNone;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return EFloat::kNone;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case HyphensAuto:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 55 matching lines @@
     case CSSValueNormal:
       return LineBreakNormal;
     case CSSValueStrict:
       return LineBreakStrict;
     case CSSValueAfterWhiteSpace:
       return LineBreakAfterWhiteSpace;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return LineBreakAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case MarginCollapseCollapse:
       m_valueID = CSSValueCollapse;
       break;
@@ skipping 55 matching lines @@
     case CSSValueAbsolute:
       return EPosition::kAbsolute;
     case CSSValueFixed:
       return EPosition::kFixed;
     case CSSValueSticky:
       return EPosition::kSticky;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return EPosition::kStatic;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EResize e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case RESIZE_BOTH:
       m_valueID = CSSValueBoth;
       break;
@@ skipping 21 matching lines @@
     case CSSValueAuto:
       // Depends on settings, thus should be handled by the caller.
       NOTREACHED();
       return RESIZE_NONE;
     case CSSValueNone:
       return RESIZE_NONE;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return RESIZE_NONE;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case ETableLayout::kAuto:
       m_valueID = CSSValueAuto;
       break;
     case ETableLayout::kFixed:
       m_valueID = CSSValueFixed;
       break;
   }
 }
 
 template <>
 inline ETableLayout CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueFixed:
       return ETableLayout::kFixed;
     case CSSValueAuto:
       return ETableLayout::kAuto;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ETableLayout::kAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TextAlignLastStart:
       m_valueID = CSSValueStart;
       break;
@@ skipping 32 matching lines @@
     case CSSValueRight:
       return TextAlignLastRight;
     case CSSValueCenter:
       return TextAlignLastCenter;
     case CSSValueJustify:
       return TextAlignLastJustify;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextAlignLastAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TextJustifyAuto:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 17 matching lines @@
     case CSSValueNone:
       return TextJustifyNone;
     case CSSValueInterWord:
       return TextJustifyInterWord;
     case CSSValueDistribute:
       return TextJustifyDistribute;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextJustifyAuto;
 }
 
 template <>
 inline TextDecoration CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueNone:
       return TextDecorationNone;
     case CSSValueUnderline:
       return TextDecorationUnderline;
     case CSSValueOverline:
       return TextDecorationOverline;
     case CSSValueLineThrough:
       return TextDecorationLineThrough;
     case CSSValueBlink:
       return TextDecorationBlink;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextDecorationNone;
 }
 
 template <>
 inline TextDecorationStyle CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueSolid:
       return TextDecorationStyleSolid;
     case CSSValueDouble:
       return TextDecorationStyleDouble;
     case CSSValueDotted:
       return TextDecorationStyleDotted;
     case CSSValueDashed:
       return TextDecorationStyleDashed;
     case CSSValueWavy:
       return TextDecorationStyleWavy;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextDecorationStyleSolid;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TextUnderlinePositionAuto:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 11 matching lines @@
     case CSSValueAuto:
       return TextUnderlinePositionAuto;
     case CSSValueUnder:
       return TextUnderlinePositionUnder;
     default:
       break;
   }
 
   // FIXME: Implement support for 'under left' and 'under right' values.
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextUnderlinePositionAuto;
 }
 
 template <>
 inline TextDecorationSkip CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueObjects:
       return TextDecorationSkipObjects;
     case CSSValueInk:
       return TextDecorationSkipInk;
@@ skipping 32 matching lines @@
     case CSSValueDisc:
       return TSDISC;
     case CSSValueCircle:
       return TSCIRCLE;
     case CSSValueSquare:
       return TSSQUARE;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TSNONE;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case DRAG_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 14 matching lines @@
     case CSSValueAuto:
       return DRAG_AUTO;
     case CSSValueNone:
       return DRAG_NONE;
     case CSSValueElement:
       return DRAG_ELEMENT;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return DRAG_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case READ_ONLY:
       m_valueID = CSSValueReadOnly;
       break;
@@ skipping 12 matching lines @@
     case CSSValueReadOnly:
       return READ_ONLY;
     case CSSValueReadWrite:
       return READ_WRITE;
     case CSSValueReadWritePlaintextOnly:
       return READ_WRITE_PLAINTEXT_ONLY;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return READ_ONLY;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case SELECT_NONE:
       m_valueID = CSSValueNone;
       break;
@@ skipping 14 matching lines @@
     case CSSValueNone:
       return SELECT_NONE;
     case CSSValueText:
       return SELECT_TEXT;
     case CSSValueAll:
       return SELECT_ALL;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SELECT_TEXT;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a)
     : CSSValue(IdentifierClass) {
   switch (a) {
     case EVerticalAlign::kTop:
       m_valueID = CSSValueTop;
       break;
@@ skipping 44 matching lines @@
     case CSSValueSub:
       return EVerticalAlign::kSub;
     case CSSValueSuper:
       return EVerticalAlign::kSuper;
     case CSSValueWebkitBaselineMiddle:
       return EVerticalAlign::kBaselineMiddle;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return EVerticalAlign::kTop;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case NormalWordBreak:
       m_valueID = CSSValueNormal;
       break;
@@ skipping 17 matching lines @@
     case CSSValueBreakWord:
       return BreakWordBreak;
     case CSSValueNormal:
       return NormalWordBreak;
     case CSSValueKeepAll:
       return KeepAllWordBreak;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return NormalWordBreak;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case NormalOverflowWrap:
       m_valueID = CSSValueNormal;
       break;
     case BreakOverflowWrap:
       m_valueID = CSSValueBreakWord;
       break;
   }
 }
 
 template <>
 inline EOverflowWrap CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueBreakWord:
       return BreakOverflowWrap;
     case CSSValueNormal:
       return NormalOverflowWrap;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return NormalOverflowWrap;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TextCombineNone:
       m_valueID = CSSValueNone;
       break;
     case TextCombineAll:
       m_valueID = CSSValueAll;
       break;
   }
 }
 
 template <>
 inline TextCombine CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueNone:
       return TextCombineNone;
     case CSSValueAll:
     case CSSValueHorizontal:  // -webkit-text-combine
       return TextCombineAll;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextCombineNone;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position)
     : CSSValue(IdentifierClass) {
   switch (position) {
     case RubyPositionBefore:
       m_valueID = CSSValueBefore;
       break;
     case RubyPositionAfter:
       m_valueID = CSSValueAfter;
       break;
   }
 }
 
 template <>
 inline RubyPosition CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueBefore:
       return RubyPositionBefore;
     case CSSValueAfter:
       return RubyPositionAfter;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return RubyPositionBefore;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position)
     : CSSValue(IdentifierClass) {
   switch (position) {
     case TextEmphasisPositionOver:
       m_valueID = CSSValueOver;
       break;
     case TextEmphasisPositionUnder:
       m_valueID = CSSValueUnder;
       break;
   }
 }
 
 template <>
 inline TextEmphasisPosition CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueOver:
       return TextEmphasisPositionOver;
     case CSSValueUnder:
       return TextEmphasisPositionUnder;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextEmphasisPositionOver;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow)
     : CSSValue(IdentifierClass) {
   switch (overflow) {
     case TextOverflowClip:
       m_valueID = CSSValueClip;
       break;
     case TextOverflowEllipsis:
       m_valueID = CSSValueEllipsis;
       break;
   }
 }
 
 template <>
 inline TextOverflow CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueClip:
       return TextOverflowClip;
     case CSSValueEllipsis:
       return TextOverflowEllipsis;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextOverflowClip;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill)
     : CSSValue(IdentifierClass) {
   switch (fill) {
     case TextEmphasisFillFilled:
       m_valueID = CSSValueFilled;
       break;
     case TextEmphasisFillOpen:
       m_valueID = CSSValueOpen;
       break;
   }
 }
 
 template <>
 inline TextEmphasisFill CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueFilled:
       return TextEmphasisFillFilled;
     case CSSValueOpen:
       return TextEmphasisFillOpen;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextEmphasisFillFilled;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark)
     : CSSValue(IdentifierClass) {
   switch (mark) {
     case TextEmphasisMarkDot:
       m_valueID = CSSValueDot;
       break;
     case TextEmphasisMarkCircle:
       m_valueID = CSSValueCircle;
       break;
     case TextEmphasisMarkDoubleCircle:
       m_valueID = CSSValueDoubleCircle;
       break;
     case TextEmphasisMarkTriangle:
       m_valueID = CSSValueTriangle;
       break;
     case TextEmphasisMarkSesame:
       m_valueID = CSSValueSesame;
       break;
     case TextEmphasisMarkNone:
     case TextEmphasisMarkAuto:
     case TextEmphasisMarkCustom:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
 inline TextEmphasisMark CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueNone:
       return TextEmphasisMarkNone;
     case CSSValueDot:
       return TextEmphasisMarkDot;
     case CSSValueCircle:
       return TextEmphasisMarkCircle;
     case CSSValueDoubleCircle:
       return TextEmphasisMarkDoubleCircle;
     case CSSValueTriangle:
       return TextEmphasisMarkTriangle;
     case CSSValueSesame:
       return TextEmphasisMarkSesame;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextEmphasisMarkNone;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TextOrientationSideways:
       m_valueID = CSSValueSideways;
       break;
@@ skipping 14 matching lines @@
       return TextOrientationSideways;
     case CSSValueMixed:
     case CSSValueVerticalRight:  // -webkit-text-orientation
       return TextOrientationMixed;
     case CSSValueUpright:
       return TextOrientationUpright;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TextOrientationMixed;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning)
     : CSSValue(IdentifierClass) {
   switch (kerning) {
     case FontDescription::AutoKerning:
       m_valueID = CSSValueAuto;
       return;
     case FontDescription::NormalKerning:
       m_valueID = CSSValueNormal;
       return;
     case FontDescription::NoneKerning:
       m_valueID = CSSValueNone;
       return;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   m_valueID = CSSValueAuto;
 }
 
 template <>
 inline FontDescription::Kerning CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueAuto:
       return FontDescription::AutoKerning;
     case CSSValueNormal:
       return FontDescription::NormalKerning;
     case CSSValueNone:
       return FontDescription::NoneKerning;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FontDescription::AutoKerning;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit)
     : CSSValue(IdentifierClass) {
   switch (fit) {
     case ObjectFitFill:
       m_valueID = CSSValueFill;
       break;
@@ skipping 19 matching lines @@
       return ObjectFitFill;
     case CSSValueContain:
       return ObjectFitContain;
     case CSSValueCover:
       return ObjectFitCover;
     case CSSValueNone:
       return ObjectFitNone;
     case CSSValueScaleDown:
       return ObjectFitScaleDown;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       return ObjectFitFill;
   }
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize)
     : CSSValue(IdentifierClass) {
   switch (fillSize) {
     case Contain:
       m_valueID = CSSValueContain;
       break;
     case Cover:
       m_valueID = CSSValueCover;
       break;
     case SizeNone:
       m_valueID = CSSValueNone;
       break;
     case SizeLength:
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing)
     : CSSValue(IdentifierClass) {
   switch (smoothing) {
     case AutoSmoothing:
       m_valueID = CSSValueAuto;
       return;
     case NoSmoothing:
       m_valueID = CSSValueNone;
       return;
     case Antialiased:
       m_valueID = CSSValueAntialiased;
       return;
     case SubpixelAntialiased:
       m_valueID = CSSValueSubpixelAntialiased;
       return;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   m_valueID = CSSValueAuto;
 }
 
 template <>
 inline FontSmoothingMode CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueAuto:
       return AutoSmoothing;
     case CSSValueNone:
       return NoSmoothing;
     case CSSValueAntialiased:
       return Antialiased;
     case CSSValueSubpixelAntialiased:
       return SubpixelAntialiased;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return AutoSmoothing;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight)
     : CSSValue(IdentifierClass) {
   switch (weight) {
     case FontWeight900:
       m_valueID = CSSValue900;
       return;
@@ skipping 16 matching lines @@
       m_valueID = CSSValue300;
       return;
     case FontWeight200:
       m_valueID = CSSValue200;
       return;
     case FontWeight100:
       m_valueID = CSSValue100;
       return;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   m_valueID = CSSValueNormal;
 }
 
 template <>
 inline FontWeight CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueBold:
       return FontWeightBold;
     case CSSValueNormal:
       return FontWeightNormal;
@@ skipping 12 matching lines @@
     case CSSValue300:
       return FontWeight300;
     case CSSValue200:
       return FontWeight200;
     case CSSValue100:
       return FontWeight100;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FontWeightNormal;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic)
     : CSSValue(IdentifierClass) {
   switch (italic) {
     case FontStyleNormal:
       m_valueID = CSSValueNormal;
       return;
     case FontStyleOblique:
       m_valueID = CSSValueOblique;
       return;
     case FontStyleItalic:
       m_valueID = CSSValueItalic;
       return;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   m_valueID = CSSValueNormal;
 }
 
 template <>
 inline FontStyle CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueOblique:
       return FontStyleOblique;
     case CSSValueItalic:
       return FontStyleItalic;
     case CSSValueNormal:
       return FontStyleNormal;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FontStyleNormal;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch)
     : CSSValue(IdentifierClass) {
   switch (stretch) {
     case FontStretchUltraCondensed:
       m_valueID = CSSValueUltraCondensed;
       return;
@@ skipping 16 matching lines @@
       m_valueID = CSSValueExpanded;
       return;
     case FontStretchExtraExpanded:
       m_valueID = CSSValueExtraExpanded;
       return;
     case FontStretchUltraExpanded:
       m_valueID = CSSValueUltraExpanded;
       return;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   m_valueID = CSSValueNormal;
 }
 
 template <>
 inline FontStretch CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueUltraCondensed:
       return FontStretchUltraCondensed;
     case CSSValueExtraCondensed:
       return FontStretchExtraCondensed;
     case CSSValueCondensed:
       return FontStretchCondensed;
     case CSSValueSemiCondensed:
       return FontStretchSemiCondensed;
     case CSSValueNormal:
       return FontStretchNormal;
     case CSSValueSemiExpanded:
       return FontStretchSemiExpanded;
     case CSSValueExpanded:
       return FontStretchExpanded;
     case CSSValueExtraExpanded:
       return FontStretchExtraExpanded;
     case CSSValueUltraExpanded:
       return FontStretchUltraExpanded;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FontStretchNormal;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case AutoTextRendering:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 17 matching lines @@
     case CSSValueOptimizeSpeed:
       return OptimizeSpeed;
     case CSSValueOptimizeLegibility:
       return OptimizeLegibility;
     case CSSValueGeometricPrecision:
       return GeometricPrecision;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return AutoTextRendering;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case SpeakNone:
       m_valueID = CSSValueNone;
       break;
@@ skipping 19 matching lines @@
 inline EOrder CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueLogical:
       return EOrder::kLogical;
     case CSSValueVisual:
       return EOrder::kVisual;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return EOrder::kLogical;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EOrder e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case EOrder::kLogical:
       m_valueID = CSSValueLogical;
       break;
@@ skipping 15 matching lines @@
     case CSSValueDigits:
       return SpeakDigits;
     case CSSValueLiteralPunctuation:
       return SpeakLiteralPunctuation;
     case CSSValueNoPunctuation:
       return SpeakNoPunctuation;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SpeakNormal;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode)
     : CSSValue(IdentifierClass) {
   switch (blendMode) {
     case WebBlendModeNormal:
       m_valueID = CSSValueNormal;
       break;
@@ skipping 77 matching lines @@
     case CSSValueSaturation:
       return WebBlendModeSaturation;
     case CSSValueColor:
       return WebBlendModeColor;
     case CSSValueLuminosity:
       return WebBlendModeLuminosity;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return WebBlendModeNormal;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(LineCap e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case ButtCap:
       m_valueID = CSSValueButt;
       break;
@@ skipping 12 matching lines @@
     case CSSValueButt:
       return ButtCap;
     case CSSValueRound:
       return RoundCap;
     case CSSValueSquare:
       return SquareCap;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ButtCap;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case MiterJoin:
       m_valueID = CSSValueMiter;
       break;
@@ skipping 12 matching lines @@
     case CSSValueMiter:
       return MiterJoin;
     case CSSValueRound:
       return RoundJoin;
     case CSSValueBevel:
       return BevelJoin;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return MiterJoin;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(WindRule e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case RULE_NONZERO:
       m_valueID = CSSValueNonzero;
       break;
     case RULE_EVENODD:
       m_valueID = CSSValueEvenodd;
       break;
   }
 }
 
 template <>
 inline WindRule CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueNonzero:
       return RULE_NONZERO;
     case CSSValueEvenodd:
       return RULE_EVENODD;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return RULE_NONZERO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case AB_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 57 matching lines @@
     case CSSValueAlphabetic:
       return AB_ALPHABETIC;
     case CSSValueHanging:
       return AB_HANGING;
     case CSSValueMathematical:
       return AB_MATHEMATICAL;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return AB_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case ImageRenderingAuto:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 22 matching lines @@
     case CSSValueOptimizeQuality:
       return ImageRenderingOptimizeQuality;
     case CSSValuePixelated:
       return ImageRenderingPixelated;
     case CSSValueWebkitOptimizeContrast:
       return ImageRenderingOptimizeContrast;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ImageRenderingAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TransformStyle3DFlat:
       m_valueID = CSSValueFlat;
       break;
     case TransformStyle3DPreserve3D:
       m_valueID = CSSValuePreserve3d;
       break;
   }
 }
 
 template <>
 inline ETransformStyle3D CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueFlat:
       return TransformStyle3DFlat;
     case CSSValuePreserve3d:
       return TransformStyle3DPreserve3D;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TransformStyle3DFlat;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case BR_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 12 matching lines @@
     case CSSValueAuto:
       return BR_AUTO;
     case CSSValueDynamic:
       return BR_DYNAMIC;
     case CSSValueStatic:
       return BR_STATIC;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return BR_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case CI_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 12 matching lines @@
     case CSSValueSRGB:
       return CI_SRGB;
     case CSSValueLinearRGB:
       return CI_LINEARRGB;
     case CSSValueAuto:
       return CI_AUTO;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return CI_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case CR_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 12 matching lines @@
     case CSSValueOptimizeSpeed:
       return CR_OPTIMIZESPEED;
     case CSSValueOptimizeQuality:
       return CR_OPTIMIZEQUALITY;
     case CSSValueAuto:
       return CR_AUTO;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return CR_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case DB_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 57 matching lines @@
     case CSSValueMiddle:
       return DB_MIDDLE;
     case CSSValueTextAfterEdge:
       return DB_TEXT_AFTER_EDGE;
     case CSSValueTextBeforeEdge:
       return DB_TEXT_BEFORE_EDGE;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return DB_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case SR_AUTO:
       m_valueID = CSSValueAuto;
       break;
@@ skipping 17 matching lines @@
     case CSSValueOptimizeSpeed:
       return SR_OPTIMIZESPEED;
     case CSSValueCrispEdges:
       return SR_CRISPEDGES;
     case CSSValueGeometricPrecision:
       return SR_GEOMETRICPRECISION;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SR_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TA_START:
       m_valueID = CSSValueStart;
       break;
@@ skipping 12 matching lines @@
     case CSSValueStart:
       return TA_START;
     case CSSValueMiddle:
       return TA_MIDDLE;
     case CSSValueEnd:
       return TA_END;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TA_START;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case VE_NONE:
       m_valueID = CSSValueNone;
       break;
     case VE_NON_SCALING_STROKE:
       m_valueID = CSSValueNonScalingStroke;
       break;
   }
 }
 
 template <>
 inline EVectorEffect CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueNone:
       return VE_NONE;
     case CSSValueNonScalingStroke:
       return VE_NON_SCALING_STROKE;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return VE_NONE;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case PT_FILL:
       m_valueID = CSSValueFill;
       break;
     case PT_STROKE:
       m_valueID = CSSValueStroke;
       break;
     case PT_MARKERS:
       m_valueID = CSSValueMarkers;
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       m_valueID = CSSValueFill;
       break;
   }
 }
 
 template <>
 inline EPaintOrderType CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueFill:
       return PT_FILL;
     case CSSValueStroke:
       return PT_STROKE;
     case CSSValueMarkers:
       return PT_MARKERS;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return PT_NONE;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case MT_LUMINANCE:
       m_valueID = CSSValueLuminance;
       break;
     case MT_ALPHA:
       m_valueID = CSSValueAlpha;
       break;
   }
 }
 
 template <>
 inline EMaskType CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueLuminance:
       return MT_LUMINANCE;
     case CSSValueAlpha:
       return MT_ALPHA;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return MT_LUMINANCE;
 }
 
 template <>
 inline TouchAction CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueNone:
       return TouchActionNone;
     case CSSValueAuto:
       return TouchActionAuto;
@@ skipping 10 matching lines @@
     case CSSValuePanY:
       return TouchActionPanY;
     case CSSValueManipulation:
       return TouchActionManipulation;
     case CSSValuePinchZoom:
       return TouchActionPinchZoom;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return TouchActionNone;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i)
     : CSSValue(IdentifierClass) {
   switch (i) {
     case IsolationAuto:
       m_valueID = CSSValueAuto;
       break;
     case IsolationIsolate:
       m_valueID = CSSValueIsolate;
       break;
   }
 }
 
 template <>
 inline EIsolation CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueAuto:
       return IsolationAuto;
     case CSSValueIsolate:
       return IsolationIsolate;
     default:
       break;
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return IsolationAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox)
     : CSSValue(IdentifierClass) {
   switch (cssBox) {
     case MarginBox:
       m_valueID = CSSValueMarginBox;
       break;
     case BorderBox:
       m_valueID = CSSValueBorderBox;
       break;
     case PaddingBox:
       m_valueID = CSSValuePaddingBox;
       break;
     case ContentBox:
       m_valueID = CSSValueContentBox;
       break;
     case BoxMissing:
       // The missing box should convert to a null primitive value.
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 template <>
 inline CSSBoxType CSSIdentifierValue::convertTo() const {
   switch (getValueID()) {
     case CSSValueMarginBox:
       return MarginBox;
     case CSSValueBorderBox:
       return BorderBox;
     case CSSValuePaddingBox:
       return PaddingBox;
     case CSSValueContentBox:
       return ContentBox;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ContentBox;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition)
     : CSSValue(IdentifierClass) {
   switch (itemPosition) {
     case ItemPositionAuto:
       // The 'auto' values might have been already resolved.
       NOTREACHED();
@@ skipping 68 matching lines @@
       return ItemPositionFlexStart;
     case CSSValueFlexEnd:
       return ItemPositionFlexEnd;
     case CSSValueLeft:
       return ItemPositionLeft;
     case CSSValueRight:
       return ItemPositionRight;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ItemPositionAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition)
     : CSSValue(IdentifierClass) {
   switch (contentPosition) {
     case ContentPositionNormal:
       m_valueID = CSSValueNormal;
       break;
@@ skipping 46 matching lines @@
       return ContentPositionFlexStart;
     case CSSValueFlexEnd:
       return ContentPositionFlexEnd;
     case CSSValueLeft:
       return ContentPositionLeft;
     case CSSValueRight:
       return ContentPositionRight;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ContentPositionNormal;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(
     ContentDistributionType contentDistribution)
     : CSSValue(IdentifierClass) {
   switch (contentDistribution) {
     case ContentDistributionDefault:
       m_valueID = CSSValueDefault;
@@ skipping 20 matching lines @@
       return ContentDistributionSpaceBetween;
     case CSSValueSpaceAround:
       return ContentDistributionSpaceAround;
     case CSSValueSpaceEvenly:
       return ContentDistributionSpaceEvenly;
     case CSSValueStretch:
       return ContentDistributionStretch;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ContentDistributionStretch;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(
     OverflowAlignment overflowAlignment)
     : CSSValue(IdentifierClass) {
   switch (overflowAlignment) {
     case OverflowAlignmentDefault:
       m_valueID = CSSValueDefault;
@@ skipping 10 matching lines @@
 template <>
 inline OverflowAlignment CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
     case CSSValueUnsafe:
       return OverflowAlignmentUnsafe;
     case CSSValueSafe:
       return OverflowAlignmentSafe;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return OverflowAlignmentUnsafe;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior)
     : CSSValue(IdentifierClass) {
   switch (behavior) {
     case ScrollBehaviorAuto:
       m_valueID = CSSValueAuto;
       break;
     case ScrollBehaviorSmooth:
       m_valueID = CSSValueSmooth;
       break;
     case ScrollBehaviorInstant:
       // Behavior 'instant' is only allowed in ScrollOptions arguments passed to
       // CSSOM scroll APIs.
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 template <>
 inline ScrollBehavior CSSIdentifierValue::convertTo() const {
   switch (getValueID()) {
     case CSSValueAuto:
       return ScrollBehaviorAuto;
     case CSSValueSmooth:
       return ScrollBehaviorSmooth;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ScrollBehaviorAuto;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType)
     : CSSValue(IdentifierClass) {
   switch (snapType) {
     case ScrollSnapTypeNone:
       m_valueID = CSSValueNone;
       break;
@@ skipping 11 matching lines @@
   switch (getValueID()) {
     case CSSValueNone:
       return ScrollSnapTypeNone;
     case CSSValueMandatory:
       return ScrollSnapTypeMandatory;
     case CSSValueProximity:
       return ScrollSnapTypeProximity;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ScrollSnapTypeNone;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType)
     : CSSValue(IdentifierClass) {
   switch (snapType) {
     case ContainsNone:
       m_valueID = CSSValueNone;
       break;
@@ skipping 31 matching lines @@
       return ContainsPaint;
     case CSSValueStyle:
       return ContainsStyle;
     case CSSValueLayout:
       return ContainsLayout;
     case CSSValueSize:
       return ContainsSize;
     default:
       break;
   }
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return ContainsNone;
 }
 
 }  // namespace blink
 
 #endif