Replace ASSERT and ASSERT_NOT_REACHED in core/style/

third_party/WebKit/Source/core/style/BasicShapes.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 78 matching lines @@
   if (m_radius.type() == BasicShapeRadius::ClosestSide)
     return std::min(std::min(std::abs(center.x()), widthDelta),
                     std::min(std::abs(center.y()), heightDelta));
 
   // If radius.type() == BasicShapeRadius::FarthestSide.
   return std::max(std::max(center.x(), widthDelta),
                   std::max(center.y(), heightDelta));
 }
 
 void BasicShapeCircle::path(Path& path, const FloatRect& boundingBox) {
-  ASSERT(path.isEmpty());
+  DCHECK(path.isEmpty());
   FloatPoint center =
       floatPointForCenterCoordinate(m_centerX, m_centerY, boundingBox.size());
   float radius = floatValueForRadiusInBox(boundingBox.size());
   path.addEllipse(FloatRect(center.x() - radius + boundingBox.x(),
                             center.y() - radius + boundingBox.y(), radius * 2,
                             radius * 2));
 }
 
 PassRefPtr<BasicShape> BasicShapeCircle::blend(const BasicShape* other,
                                                double progress) const {
-  ASSERT(type() == other->type());
+  DCHECK_EQ(type(), other->type());
   const BasicShapeCircle* o = toBasicShapeCircle(other);
   RefPtr<BasicShapeCircle> result = BasicShapeCircle::create();
 
   result->setCenterX(m_centerX.blend(o->centerX(), progress));
   result->setCenterY(m_centerY.blend(o->centerY(), progress));
   result->setRadius(m_radius.blend(o->radius(), progress));
   return result.release();
 }
 
 bool BasicShapeEllipse::operator==(const BasicShape& o) const {
   if (!isSameType(o))
     return false;
   const BasicShapeEllipse& other = toBasicShapeEllipse(o);
   return m_centerX == other.m_centerX && m_centerY == other.m_centerY &&
          m_radiusX == other.m_radiusX && m_radiusY == other.m_radiusY;
 }
 
 float BasicShapeEllipse::floatValueForRadiusInBox(
     const BasicShapeRadius& radius,
     float center,
     float boxWidthOrHeight) const {
   if (radius.type() == BasicShapeRadius::Value)
     return floatValueForLength(radius.value(), boxWidthOrHeight);
 
   float widthOrHeightDelta = std::abs(boxWidthOrHeight - center);
   if (radius.type() == BasicShapeRadius::ClosestSide)
     return std::min(std::abs(center), widthOrHeightDelta);
 
-  ASSERT(radius.type() == BasicShapeRadius::FarthestSide);
+  DCHECK_EQ(radius.type(), BasicShapeRadius::FarthestSide);
   return std::max(center, widthOrHeightDelta);
 }
 
 void BasicShapeEllipse::path(Path& path, const FloatRect& boundingBox) {
-  ASSERT(path.isEmpty());
+  DCHECK(path.isEmpty());
   FloatPoint center =
       floatPointForCenterCoordinate(m_centerX, m_centerY, boundingBox.size());
   float radiusX =
       floatValueForRadiusInBox(m_radiusX, center.x(), boundingBox.width());
   float radiusY =
       floatValueForRadiusInBox(m_radiusY, center.y(), boundingBox.height());
   path.addEllipse(FloatRect(center.x() - radiusX + boundingBox.x(),
                             center.y() - radiusY + boundingBox.y(), radiusX * 2,
                             radiusY * 2));
 }
 
 PassRefPtr<BasicShape> BasicShapeEllipse::blend(const BasicShape* other,
                                                 double progress) const {
-  ASSERT(type() == other->type());
+  DCHECK_EQ(type(), other->type());
   const BasicShapeEllipse* o = toBasicShapeEllipse(other);
   RefPtr<BasicShapeEllipse> result = BasicShapeEllipse::create();
 
   if (m_radiusX.type() != BasicShapeRadius::Value ||
       o->radiusX().type() != BasicShapeRadius::Value ||
       m_radiusY.type() != BasicShapeRadius::Value ||
       o->radiusY().type() != BasicShapeRadius::Value) {
     result->setCenterX(o->centerX());
     result->setCenterY(o->centerY());
     result->setRadiusX(o->radiusX());
     result->setRadiusY(o->radiusY());
     return result;
   }
 
   result->setCenterX(m_centerX.blend(o->centerX(), progress));
   result->setCenterY(m_centerY.blend(o->centerY(), progress));
   result->setRadiusX(m_radiusX.blend(o->radiusX(), progress));
   result->setRadiusY(m_radiusY.blend(o->radiusY(), progress));
   return result.release();
 }
 
 void BasicShapePolygon::path(Path& path, const FloatRect& boundingBox) {
-  ASSERT(path.isEmpty());
-  ASSERT(!(m_values.size() % 2));
+  DCHECK(path.isEmpty());
+  DCHECK(!(m_values.size() % 2));
   size_t length = m_values.size();
 
   if (!length)
     return;
 
   path.moveTo(
       FloatPoint(floatValueForLength(m_values.at(0), boundingBox.width()) +
                      boundingBox.x(),
                  floatValueForLength(m_values.at(1), boundingBox.height()) +
                      boundingBox.y()));
   for (size_t i = 2; i < length; i = i + 2) {
     path.addLineTo(FloatPoint(
         floatValueForLength(m_values.at(i), boundingBox.width()) +
             boundingBox.x(),
         floatValueForLength(m_values.at(i + 1), boundingBox.height()) +
             boundingBox.y()));
   }
   path.closeSubpath();
 }
 
 PassRefPtr<BasicShape> BasicShapePolygon::blend(const BasicShape* other,
                                                 double progress) const {
-  ASSERT(other && isSameType(*other));
+  DCHECK(other);
+  DCHECK(isSameType(*other));
 
   const BasicShapePolygon* o = toBasicShapePolygon(other);
-  ASSERT(m_values.size() == o->values().size());
-  ASSERT(!(m_values.size() % 2));
+  DCHECK_EQ(m_values.size(), o->values().size());
+  DCHECK(!(m_values.size() % 2));
 
   size_t length = m_values.size();
   RefPtr<BasicShapePolygon> result = BasicShapePolygon::create();
   if (!length)
     return result.release();
 
   result->setWindRule(o->getWindRule());
 
   for (size_t i = 0; i < length; i = i + 2) {
     result->appendPoint(
@@ skipping 13 matching lines @@
 }
 
 static FloatSize floatSizeForLengthSize(const LengthSize& lengthSize,
                                         const FloatRect& boundingBox) {
   return FloatSize(
       floatValueForLength(lengthSize.width(), boundingBox.width()),
       floatValueForLength(lengthSize.height(), boundingBox.height()));
 }
 
 void BasicShapeInset::path(Path& path, const FloatRect& boundingBox) {
-  ASSERT(path.isEmpty());
+  DCHECK(path.isEmpty());
   float left = floatValueForLength(m_left, boundingBox.width());
   float top = floatValueForLength(m_top, boundingBox.height());
   FloatRect rect(
       left + boundingBox.x(), top + boundingBox.y(),
       std::max<float>(boundingBox.width() - left -
                           floatValueForLength(m_right, boundingBox.width()),
                       0),
       std::max<float>(boundingBox.height() - top -
                           floatValueForLength(m_bottom, boundingBox.height()),
                       0));
@@ skipping 11 matching lines @@
 static inline LengthSize blendLengthSize(const LengthSize& to,
                                          const LengthSize& from,
                                          double progress) {
   return LengthSize(
       to.width().blend(from.width(), progress, ValueRangeNonNegative),
       to.height().blend(from.height(), progress, ValueRangeNonNegative));
 }
 
 PassRefPtr<BasicShape> BasicShapeInset::blend(const BasicShape* other,
                                               double progress) const {
-  ASSERT(other && isSameType(*other));
+  DCHECK(other);
+  DCHECK(isSameType(*other));
 
   const BasicShapeInset& otherInset = toBasicShapeInset(*other);
   RefPtr<BasicShapeInset> result = BasicShapeInset::create();
   result->setTop(m_top.blend(otherInset.top(), progress, ValueRangeAll));
   result->setRight(m_right.blend(otherInset.right(), progress, ValueRangeAll));
   result->setBottom(
       m_bottom.blend(otherInset.bottom(), progress, ValueRangeAll));
   result->setLeft(m_left.blend(otherInset.left(), progress, ValueRangeAll));
 
   result->setTopLeftRadius(
@@ skipping 14 matching lines @@
   const BasicShapeInset& other = toBasicShapeInset(o);
   return m_right == other.m_right && m_top == other.m_top &&
          m_bottom == other.m_bottom && m_left == other.m_left &&
          m_topLeftRadius == other.m_topLeftRadius &&
          m_topRightRadius == other.m_topRightRadius &&
          m_bottomRightRadius == other.m_bottomRightRadius &&
          m_bottomLeftRadius == other.m_bottomLeftRadius;
 }
 
 }  // namespace blink