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

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

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2015 Google Inc. 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 133 matching lines @@
 
   int indexOffset = 0;
 
   // The first and the last color stops cannot be color hints.
   for (size_t i = 1; i < cssGradientStops.size() - 1; ++i) {
     if (!cssGradientStops[i].isHint())
       continue;
 
     // The current index of the stops vector.
     size_t x = i + indexOffset;
-    ASSERT(x >= 1);
+    DCHECK(x >=
+           1);  ////DCHECK_GE giving error for const unsigned int and const int

[Srirama, 2017/03/16 14:22:23]

remove this comment and add review comment.

 
     // offsetLeft          offset                            offsetRight
     //   |-------------------|---------------------------------|
     //          leftDist                 rightDist
 
     float offsetLeft = stops[x - 1].offset;
     float offsetRight = stops[x + 1].offset;
     float offset = stops[x].offset;
     float leftDist = offset - offsetLeft;
     float rightDist = offsetRight - offset;
     float totalDist = offsetRight - offsetLeft;
 
     Color leftColor = stops[x - 1].color;
     Color rightColor = stops[x + 1].color;
 
-    ASSERT(offsetLeft <= offset && offset <= offsetRight);
+    DCHECK_LE(offsetLeft, offset);
+    DCHECK_LE(offset, offsetRight);
 
     if (WebCoreFloatNearlyEqual(leftDist, rightDist)) {
       stops.remove(x);
       --indexOffset;
       continue;
     }
 
     if (WebCoreFloatNearlyEqual(leftDist, .0f)) {
       stops[x].color = rightColor;
       continue;
@@ skipping 37 matching lines @@
 }
 
 static Color resolveStopColor(const CSSValue& stopColor,
                               const LayoutObject& object) {
   return object.document().textLinkColors().colorFromCSSValue(
       stopColor, object.resolveColor(CSSPropertyColor));
 }
 
 void CSSGradientValue::addDeprecatedStops(Gradient* gradient,
                                           const LayoutObject& object) {
-  ASSERT(m_gradientType == CSSDeprecatedLinearGradient ||
+  DCHECK(m_gradientType == CSSDeprecatedLinearGradient ||
          m_gradientType == CSSDeprecatedRadialGradient);
 
   if (!m_stopsSorted) {
     if (m_stops.size())
       std::stable_sort(m_stops.begin(), m_stops.end(), compareStops);
     m_stopsSorted = true;
   }
 
   for (const auto& stop : m_stops) {
     float offset;
@@ skipping 21 matching lines @@
   if (stops.front().offset < 0 || stops.back().offset > 1)
     return true;
 
   return false;
 }
 
 // Redistribute the stops such that they fully cover [0 , 1] and add them to the
 // gradient.
 static bool normalizeAndAddStops(const Vector<GradientStop>& stops,
                                  Gradient* gradient) {
-  ASSERT(stops.size() > 1);
+  DCHECK(stops.size() >
+         1);  ////DCHECK_GT giving error for const unsigned int and const int

[Srirama, 2017/03/16 14:22:24]

ditto

 
   const float firstOffset = stops.front().offset;
   const float lastOffset = stops.back().offset;
   const float span = lastOffset - firstOffset;
 
   if (fabs(span) < std::numeric_limits<float>::epsilon()) {
     // All stops are coincident -> use a single clamped offset value.
     const float clampedOffset = std::min(std::max(firstOffset, 0.f), 1.f);
 
     // For repeating gradients, a coincident stop set defines a solid-color
     // image with the color of the last color-stop in the rule.
     // For non-repeating gradients, both the first color and the last color can
     // be significant (padding on both sides of the offset).
     if (gradient->spreadMethod() != SpreadMethodRepeat)
       gradient->addColorStop(clampedOffset, stops.front().color);
     gradient->addColorStop(clampedOffset, stops.back().color);
 
     return false;
   }
 
-  ASSERT(span > 0);
+  DCHECK_GT(span, 0);
 
   for (size_t i = 0; i < stops.size(); ++i) {
     const float normalizedOffset = (stops[i].offset - firstOffset) / span;
 
     // stop offsets should be monotonically increasing in [0 , 1]
-    ASSERT(normalizedOffset >= 0 && normalizedOffset <= 1);
-    ASSERT(i == 0 ||
+    DCHECK_GE(normalizedOffset, 0);
+    DCHECK_LE(normalizedOffset, 1);
+    DCHECK(i == 0 ||
            normalizedOffset >= (stops[i - 1].offset - firstOffset) / span);
 
     gradient->addColorStop(normalizedOffset, stops[i].color);
   }
 
   return true;
 }
 
 // Collapse all negative-offset stops to 0 and compute an interpolated color
 // value for that point.
 static void clampNegativeOffsets(Vector<GradientStop>& stops) {
   float lastNegativeOffset = 0;
 
   for (size_t i = 0; i < stops.size(); ++i) {
     const float currentOffset = stops[i].offset;
     if (currentOffset >= 0) {
       if (i > 0) {
         // We found the negative -> positive offset transition: compute an
         // interpolated color value for 0 and use it with the last clamped stop.
-        ASSERT(lastNegativeOffset < 0);
+        DCHECK_LT(lastNegativeOffset, 0);
         float lerpRatio =
             -lastNegativeOffset / (currentOffset - lastNegativeOffset);
         stops[i - 1].color =
             blend(stops[i - 1].color, stops[i].color, lerpRatio);
       }
 
       break;
     }
 
     // Clamp all negative stops to 0.
     stops[i].offset = 0;
     lastNegativeOffset = currentOffset;
   }
 }
 
 // Update the linear gradient points to align with the given offset range.
 static void adjustGradientPointsForOffsetRange(Gradient* gradient,
                                                float firstOffset,
                                                float lastOffset) {
-  ASSERT(!gradient->isRadial());
-  ASSERT(firstOffset <= lastOffset);
+  DCHECK(!gradient->isRadial());
+  DCHECK(firstOffset <= lastOffset);
 
   const FloatPoint p0 = gradient->p0();
   const FloatPoint p1 = gradient->p1();
   const FloatSize d(p1 - p0);
 
   // Linear offsets are relative to the [p0 , p1] segment.
   gradient->setP0(p0 + d * firstOffset);
   gradient->setP1(p0 + d * lastOffset);
 }
 
 // Update the radial gradient radii to align with the given offset range.
 static void adjustGradientRadiiForOffsetRange(Gradient* gradient,
                                               float firstOffset,
                                               float lastOffset) {
-  ASSERT(gradient->isRadial());
-  ASSERT(firstOffset <= lastOffset);
+  DCHECK(gradient->isRadial());
+  DCHECK_LE(firstOffset, lastOffset);
 
   // Radial offsets are relative to the [0 , endRadius] segment.
   float adjustedR0 = gradient->endRadius() * firstOffset;
   float adjustedR1 = gradient->endRadius() * lastOffset;
-  ASSERT(adjustedR0 <= adjustedR1);
+  DCHECK_LE(adjustedR0, adjustedR1);
 
   // Unlike linear gradients (where we can adjust the points arbitrarily),
   // we cannot let our radii turn negative here.
   if (adjustedR0 < 0) {
     // For the non-repeat case, this can never happen: clampNegativeOffsets()
     // ensures we don't have to deal with negative offsets at this point.
-    ASSERT(gradient->spreadMethod() == SpreadMethodRepeat);
+    DCHECK_EQ(gradient->spreadMethod(), SpreadMethodRepeat);
 
     // When in repeat mode, we deal with it by repositioning both radii in the
     // positive domain - shifting them by a multiple of the radius span (which
     // is the period of our repeating gradient -> hence no visible side
     // effects).
     const float radiusSpan = adjustedR1 - adjustedR0;
     const float shiftToPositive = radiusSpan * ceilf(-adjustedR0 / radiusSpan);
     adjustedR0 += shiftToPositive;
     adjustedR1 += shiftToPositive;
   }
-  ASSERT(adjustedR0 >= 0);
-  ASSERT(adjustedR1 >= adjustedR0);
+  DCHECK_GE(adjustedR0, 0);
+  DCHECK_GE(adjustedR1, adjustedR0);
 
   gradient->setStartRadius(adjustedR0);
   gradient->setEndRadius(adjustedR1);
 }
 
 void CSSGradientValue::addStops(Gradient* gradient,
                                 const CSSToLengthConversionData& conversionData,
                                 const LayoutObject& object) {
   if (m_gradientType == CSSDeprecatedLinearGradient ||
       m_gradientType == CSSDeprecatedRadialGradient) {
@@ skipping 31 matching lines @@
                stop.m_position->isCalculatedPercentageWithLength()) {
         float length;
         if (stop.m_position->isLength())
           length = stop.m_position->computeLength<float>(conversionData);
         else
           length = stop.m_position->cssCalcValue()
                        ->toCalcValue(conversionData)
                        ->evaluate(gradientLength);
         stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
       } else {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         stops[i].offset = 0;
       }
       stops[i].specified = true;
     } else {
       // If the first color-stop does not have a position, its position defaults
       // to 0%. If the last color-stop does not have a position, its position
       // defaults to 100%.
       if (!i) {
         stops[i].offset = 0;
         stops[i].specified = true;
@@ skipping 12 matching lines @@
            --prevSpecifiedIndex) {
         if (stops[prevSpecifiedIndex].specified)
           break;
       }
 
       if (stops[i].offset < stops[prevSpecifiedIndex].offset)
         stops[i].offset = stops[prevSpecifiedIndex].offset;
     }
   }
 
-  ASSERT(stops.front().specified && stops.back().specified);
+  DCHECK(stops.front().specified);
+  DCHECK(stops.back().specified);
 
   // If any color-stop still does not have a position, then, for each run of
   // adjacent color-stops without positions, set their positions so that they
   // are evenly spaced between the preceding and following color-stops with
   // positions.
   if (numStops > 2) {
     size_t unspecifiedRunStart = 0;
     bool inUnspecifiedRun = false;
 
     for (size_t i = 0; i < numStops; ++i) {
@@ skipping 12 matching lines @@
           for (size_t j = unspecifiedRunStart; j < unspecifiedRunEnd; ++j)
             stops[j].offset =
                 lastSpecifiedOffset + (j - unspecifiedRunStart + 1) * delta;
         }
 
         inUnspecifiedRun = false;
       }
     }
   }
 
-  ASSERT(stops.size() == m_stops.size());
+  DCHECK_EQ(stops.size(), m_stops.size());
   if (hasHints) {
     replaceColorHintsWithColorStops(stops, m_stops);
   }
 
   // At this point we have a fully resolved set of stops. Time to perform
   // adjustments for repeat gradients and degenerate values if needed.
   if (requiresStopsNormalization(stops, gradient)) {
     // Negative offsets are only an issue for non-repeating radial gradients:
     // linear gradient points can be repositioned arbitrarily, and for repeating
     // radial gradients we shift the radii into equivalent positive values.
@@ skipping 301 matching lines @@
   // moved origin and the fact that we're in drawing space (+y = down).
   secondPoint.set(halfWidth + endX, halfHeight - endY);
   // Reflect around the center for the start point.
   firstPoint.set(halfWidth - endX, halfHeight + endY);
 }
 
 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(
     const CSSToLengthConversionData& conversionData,
     const IntSize& size,
     const LayoutObject& object) {
-  ASSERT(!size.isEmpty());
+  DCHECK(!size.isEmpty());
 
   FloatPoint firstPoint;
   FloatPoint secondPoint;
   if (m_angle) {
     float angle = m_angle->computeDegrees();
     endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
   } else {
     switch (m_gradientType) {
       case CSSDeprecatedLinearGradient:
         firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(),
@@ skipping 37 matching lines @@
           secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(),
                                         conversionData, size);
           if (m_firstX)
             firstPoint.setX(size.width() - secondPoint.x());
           if (m_firstY)
             firstPoint.setY(size.height() - secondPoint.y());
         } else
           secondPoint.setY(size.height());
         break;
       default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
   }
 
   RefPtr<Gradient> gradient = Gradient::create(firstPoint, secondPoint);
 
   gradient->setSpreadMethod(m_repeating ? SpreadMethodRepeat : SpreadMethodPad);
   gradient->setDrawsInPMColorSpace(true);
 
   // Now add the stops.
   addStops(gradient.get(), conversionData, object);
@@ skipping 223 matching lines @@
   float dy1 = clampTo<float>(fabs(point.y()));
   float dx2 = clampTo<float>(fabs(point.x() - size.width()));
   float dy2 = clampTo<float>(fabs(point.y() - size.height()));
 
   float dx = compare(dx1, dx2) ? dx1 : dx2;
   float dy = compare(dy1, dy2) ? dy1 : dy2;
 
   if (shape == CircleEndShape)
     return compare(dx, dy) ? FloatSize(dx, dx) : FloatSize(dy, dy);
 
-  ASSERT(shape == EllipseEndShape);
+  DCHECK_EQ(shape, EllipseEndShape);
   return FloatSize(dx, dy);
 }
 
 // Compute the radius of an ellipse with center at 0,0 which passes through p,
 // and has width/height given by aspectRatio.
 inline FloatSize ellipseRadius(const FloatPoint& p, float aspectRatio) {
   // If the aspectRatio is 0 or infinite, the ellipse is completely flat.
   // TODO(sashab): Implement Degenerate Radial Gradients, see crbug.com/635727.
   if (aspectRatio == 0 || std::isinf(aspectRatio))
     return FloatSize(0, 0);
@@ skipping 21 matching lines @@
     float newDistance = (point - corners[i]).diagonalLength();
     if (compare(newDistance, distance)) {
       cornerIndex = i;
       distance = newDistance;
     }
   }
 
   if (shape == CircleEndShape)
     return FloatSize(distance, distance);
 
-  ASSERT(shape == EllipseEndShape);
+  DCHECK_EQ(shape, EllipseEndShape);
   // If the end shape is an ellipse, the gradient-shape has the same ratio of
   // width to height that it would if closest-side or farthest-side were
   // specified, as appropriate.
   const FloatSize sideRadius =
       radiusToSide(point, size, EllipseEndShape, compare);
 
   return ellipseRadius(FloatPoint(corners[cornerIndex] - point),
                        sideRadius.aspectRatio());
 }
 
 }  // anonymous namespace
 
 PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(
     const CSSToLengthConversionData& conversionData,
     const IntSize& size,
     const LayoutObject& object) {
-  ASSERT(!size.isEmpty());
+  DCHECK(!size.isEmpty());
 
   FloatPoint firstPoint =
       computeEndPoint(m_firstX.get(), m_firstY.get(), conversionData, size);
   if (!m_firstX)
     firstPoint.setX(size.width() / 2);
   if (!m_firstY)
     firstPoint.setY(size.height() / 2);
 
   FloatPoint secondPoint =
       computeEndPoint(m_secondX.get(), m_secondY.get(), conversionData, size);
@@ skipping 123 matching lines @@
   visitor->trace(m_firstRadius);
   visitor->trace(m_secondRadius);
   visitor->trace(m_shape);
   visitor->trace(m_sizingBehavior);
   visitor->trace(m_endHorizontalSize);
   visitor->trace(m_endVerticalSize);
   CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 }  // namespace blink