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

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

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 56 matching lines @@
                                             const BasicShapeRadius& radius) {
   switch (radius.type()) {
     case BasicShapeRadius::Value:
       return CSSValue::create(radius.value(), style.effectiveZoom());
     case BasicShapeRadius::ClosestSide:
       return CSSIdentifierValue::create(CSSValueClosestSide);
     case BasicShapeRadius::FarthestSide:
       return CSSIdentifierValue::create(CSSValueFarthestSide);
   }
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return nullptr;
 }
 
 CSSValue* valueForBasicShape(const ComputedStyle& style,
                              const BasicShape* basicShape) {
   switch (basicShape->type()) {
     case BasicShape::BasicShapeCircleType: {
       const BasicShapeCircle* circle = toBasicShapeCircle(basicShape);
       CSSBasicShapeCircleValue* circleValue =
           CSSBasicShapeCircleValue::create();
@@ skipping 107 matching lines @@
       break;
     case CSSValueRight:
     case CSSValueBottom:
       direction = BasicShapeCenterCoordinate::BottomRight;
       break;
     case CSSValueCenter:
       direction = BasicShapeCenterCoordinate::TopLeft;
       offset = Length(50, Percent);
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       direction = BasicShapeCenterCoordinate::TopLeft;
       break;
   }
 
   return BasicShapeCenterCoordinate(direction, offset);
 }
 
 static BasicShapeRadius cssValueToBasicShapeRadius(
     const StyleResolverState& state,
     const CSSValue* radius) {
   if (!radius)
     return BasicShapeRadius(BasicShapeRadius::ClosestSide);
 
   if (radius->isIdentifierValue()) {
     switch (toCSSIdentifierValue(radius)->getValueID()) {
       case CSSValueClosestSide:
         return BasicShapeRadius(BasicShapeRadius::ClosestSide);
       case CSSValueFarthestSide:
         return BasicShapeRadius(BasicShapeRadius::FarthestSide);
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     }
   }
 
   return BasicShapeRadius(convertToLength(state, toCSSPrimitiveValue(radius)));
 }
 
 PassRefPtr<BasicShape> basicShapeForValue(const StyleResolverState& state,
                                           const CSSValue& basicShapeValue) {
   RefPtr<BasicShape> basicShape;
@@ skipping 49 matching lines @@
         convertToLengthSize(state, rectValue.topLeftRadius()));
     rect->setTopRightRadius(
         convertToLengthSize(state, rectValue.topRightRadius()));
     rect->setBottomRightRadius(
         convertToLengthSize(state, rectValue.bottomRightRadius()));
     rect->setBottomLeftRadius(
         convertToLengthSize(state, rectValue.bottomLeftRadius()));
 
     basicShape = std::move(rect);
   } else {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
   }
 
   return basicShape.release();
 }
 
 FloatPoint floatPointForCenterCoordinate(
     const BasicShapeCenterCoordinate& centerX,
     const BasicShapeCenterCoordinate& centerY,
     FloatSize boxSize) {
   float x = floatValueForLength(centerX.computedLength(), boxSize.width());
   float y = floatValueForLength(centerY.computedLength(), boxSize.height());
   return FloatPoint(x, y);
 }
 
 }  // namespace blink