Reflow comments 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 60 matching lines @@
 PassRefPtr<Image> CSSGradientValue::image(const LayoutObject& layoutObject,
                                           const IntSize& size) {
   if (size.isEmpty())
     return nullptr;
 
   bool cacheable = isCacheable();
   if (cacheable) {
     if (!clients().contains(&layoutObject))
       return nullptr;
 
-    // Need to look up our size.  Create a string of width*height to use as a hash key.
+    // Need to look up our size.  Create a string of width*height to use as a
+    // hash key.
     Image* result = getImage(&layoutObject, size);
     if (result)
       return result;
   }
 
   // We need to create an image.
   RefPtr<Gradient> gradient;
 
   const ComputedStyle* rootStyle =
       layoutObject.document().documentElement()->computedStyle();
@@ skipping 31 matching lines @@
   GradientStop() : offset(0), specified(false) {}
 };
 
 static void replaceColorHintsWithColorStops(
     Vector<GradientStop>& stops,
     const HeapVector<CSSGradientColorStop, 2>& cssGradientStops) {
   // This algorithm will replace each color interpolation hint with 9 regular
   // color stops. The color values for the new color stops will be calculated
   // using the color weighting formula defined in the spec. The new color
   // stops will be positioned in such a way that all the pixels between the two
-  // user defined color stops have color values close to the interpolation curve.
+  // user defined color stops have color values close to the interpolation
+  // curve.
   // If the hint is closer to the left color stop, add 2 stops to the left and
   // 6 to the right, else add 6 stops to the left and 2 to the right.
   // The color stops on the side with more space start midway because
   // the curve approximates a line in that region.
   // Using this aproximation, it is possible to discern the color steps when
   // the gradient is large. If this becomes an issue, we can consider improving
-  // the algorithm, or adding support for color interpolation hints to skia shaders.
+  // the algorithm, or adding support for color interpolation hints to skia
+  // shaders.
 
   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;
@@ skipping 39 matching lines @@
       newStops[7].offset = offset + rightDist / 3;
       newStops[8].offset = offset + rightDist * 2 / 3;
     } else {
       newStops[0].offset = offsetLeft + leftDist / 3;
       newStops[1].offset = offsetLeft + leftDist * 2 / 3;
       for (size_t y = 0; y < 7; ++y)
         newStops[y + 2].offset = offset + rightDist * y / 13;
     }
 
     // calculate colors for the new color hints.
-    // The color weighting for the new color stops will be pointRelativeOffset^(ln(0.5)/ln(hintRelativeOffset)).
+    // The color weighting for the new color stops will be
+    // pointRelativeOffset^(ln(0.5)/ln(hintRelativeOffset)).
     float hintRelativeOffset = leftDist / totalDist;
     for (size_t y = 0; y < 9; ++y) {
       float pointRelativeOffset = (newStops[y].offset - offsetLeft) / totalDist;
       float weighting =
           powf(pointRelativeOffset, logf(.5f) / logf(hintRelativeOffset));
       newStops[y].color = blend(leftColor, rightColor, weighting);
     }
 
     // Replace the color hint with the new color stops.
     stops.remove(x);
@@ skipping 41 matching lines @@
   if (gradient->spreadMethod() == SpreadMethodRepeat)
     return true;
 
   // Degenerate stops
   if (stops.first().offset < 0 || stops.last().offset > 1)
     return true;
 
   return false;
 }
 
-// Redistribute the stops such that they fully cover [0 , 1] and add them to the gradient.
+// 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);
 
   const float firstOffset = stops.first().offset;
   const float lastOffset = stops.last().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).
+    // 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.first().color);
     gradient->addColorStop(clampedOffset, stops.last().color);
 
     return false;
   }
 
   ASSERT(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 ||
            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.
+// 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.
+        // 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);
         float lerpRatio =
             -lastNegativeOffset / (currentOffset - lastNegativeOffset);
         stops[i - 1].color =
             blend(stops[i - 1].color, stops[i].color, lerpRatio);
       }
 
       break;
     }
 
@@ skipping 27 matching lines @@
   ASSERT(firstOffset <= lastOffset);
 
   // Radial offsets are relative to the [0 , endRadius] segment.
   float adjustedR0 = gradient->endRadius() * firstOffset;
   float adjustedR1 = gradient->endRadius() * lastOffset;
   ASSERT(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.
+    // 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);
 
-    // 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).
+    // 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);
 
   gradient->setStartRadius(adjustedR0);
   gradient->setEndRadius(adjustedR1);
@@ skipping 43 matching lines @@
           length = stop.m_position->cssCalcValue()
                        ->toCalcValue(conversionData)
                        ->evaluate(gradientLength);
         stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
       } else {
         ASSERT_NOT_REACHED();
         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 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;
       } else if (numStops > 1 && i == numStops - 1) {
         stops[i].offset = 1;
         stops[i].specified = true;
       }
     }
 
-    // If a color-stop has a position that is less than the specified position of any
-    // color-stop before it in the list, its position is changed to be equal to the
-    // largest specified position of any color-stop before it.
+    // If a color-stop has a position that is less than the specified position
+    // of any color-stop before it in the list, its position is changed to be
+    // equal to the largest specified position of any color-stop before it.
     if (stops[i].specified && i > 0) {
       size_t prevSpecifiedIndex;
       for (prevSpecifiedIndex = i - 1; prevSpecifiedIndex;
            --prevSpecifiedIndex) {
         if (stops[prevSpecifiedIndex].specified)
           break;
       }
 
       if (stops[i].offset < stops[prevSpecifiedIndex].offset)
         stops[i].offset = stops[prevSpecifiedIndex].offset;
     }
   }
 
   ASSERT(stops.first().specified && stops.last().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 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) {
       if (!stops[i].specified && !inUnspecifiedRun) {
         unspecifiedRunStart = i;
         inUnspecifiedRun = true;
       } else if (stops[i].specified && inUnspecifiedRun) {
         size_t unspecifiedRunEnd = i;
@@ skipping 12 matching lines @@
         inUnspecifiedRun = false;
       }
     }
   }
 
   ASSERT(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.
+  // 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.
+    // 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.
     if (isRadialGradientValue() && !m_repeating)
       clampNegativeOffsets(stops);
 
     if (normalizeAndAddStops(stops, gradient)) {
       if (isLinearGradientValue()) {
         adjustGradientPointsForOffsetRange(gradient, stops.first().offset,
                                            stops.last().offset);
       } else {
         adjustGradientRadiiForOffsetRange(gradient, stops.first().offset,
                                           stops.last().offset);
       }
     } else {
       // Normalization failed because the stop set is coincident.
     }
   } else {
     // No normalization required, just add the current stops.
     for (const auto& stop : stops)
       gradient->addColorStop(stop.offset, stop.color);
   }
 }
 
 static float positionFromValue(const CSSValue* value,
                                const CSSToLengthConversionData& conversionData,
                                const IntSize& size,
                                bool isHorizontal) {
   int origin = 0;
   int sign = 1;
   int edgeDistance = isHorizontal ? size.width() : size.height();
 
-  // In this case the center of the gradient is given relative to an edge in the form of:
-  // [ top | bottom | right | left ] [ <percentage> | <length> ].
+  // In this case the center of the gradient is given relative to an edge in the
+  // form of: [ top | bottom | right | left ] [ <percentage> | <length> ].
   if (value->isValuePair()) {
     const CSSValuePair& pair = toCSSValuePair(*value);
     CSSValueID originID = toCSSIdentifierValue(pair.first()).getValueID();
     value = &pair.second();
 
     if (originID == CSSValueRight || originID == CSSValueBottom) {
       // For right/bottom, the offset is relative to the far edge.
       origin = edgeDistance;
       sign = -1;
     }
@@ skipping 183 matching lines @@
         result.append(' ');
       if (stop.m_position)
         result.append(stop.m_position->cssText());
     }
   }
 
   result.append(')');
   return result.toString();
 }
 
-// Compute the endpoints so that a gradient of the given angle covers a box of the given size.
+// Compute the endpoints so that a gradient of the given angle covers a box of
+// the given size.
 static void endPointsFromAngle(float angleDeg,
                                const IntSize& size,
                                FloatPoint& firstPoint,
                                FloatPoint& secondPoint,
                                CSSGradientType type) {
-  // Prefixed gradients use "polar coordinate" angles, rather than "bearing" angles.
+  // Prefixed gradients use "polar coordinate" angles, rather than "bearing"
+  // angles.
   if (type == CSSPrefixedLinearGradient)
     angleDeg = 90 - angleDeg;
 
   angleDeg = fmodf(angleDeg, 360);
   if (angleDeg < 0)
     angleDeg += 360;
 
   if (!angleDeg) {
     firstPoint.set(0, size.height());
     secondPoint.set(0, 0);
@@ skipping 15 matching lines @@
   if (angleDeg == 270) {
     firstPoint.set(size.width(), 0);
     secondPoint.set(0, 0);
     return;
   }
 
   // angleDeg is a "bearing angle" (0deg = N, 90deg = E),
   // but tan expects 0deg = E, 90deg = N.
   float slope = tan(deg2rad(90 - angleDeg));
 
-  // We find the endpoint by computing the intersection of the line formed by the slope,
-  // and a line perpendicular to it that intersects the corner.
+  // We find the endpoint by computing the intersection of the line formed by
+  // the slope, and a line perpendicular to it that intersects the corner.
   float perpendicularSlope = -1 / slope;
 
   // Compute start corner relative to center, in Cartesian space (+y = up).
   float halfHeight = size.height() / 2;
   float halfWidth = size.width() / 2;
   FloatPoint endCorner;
   if (angleDeg < 90)
     endCorner.set(halfWidth, halfHeight);
   else if (angleDeg < 180)
     endCorner.set(halfWidth, -halfHeight);
   else if (angleDeg < 270)
     endCorner.set(-halfWidth, -halfHeight);
   else
     endCorner.set(-halfWidth, halfHeight);
 
   // Compute c (of y = mx + c) using the corner point.
   float c = endCorner.y() - perpendicularSlope * endCorner.x();
   float endX = c / (slope - perpendicularSlope);
   float endY = perpendicularSlope * endX + c;
 
-  // We computed the end point, so set the second point,
-  // taking into account the moved origin and the fact that we're in drawing space (+y = down).
+  // We computed the end point, so set the second point, taking into account the
+  // 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());
@@ skipping 276 matching lines @@
   else
     result = radius->computeLength<float>(conversionData);
 
   return clampTo<float>(std::max(result, 0.0f));
 }
 
 namespace {
 
 enum EndShapeType { CircleEndShape, EllipseEndShape };
 
-// Compute the radius to the closest/farthest side (depending on the compare functor).
+// Compute the radius to the closest/farthest side (depending on the compare
+// functor).
 FloatSize radiusToSide(const FloatPoint& point,
                        const FloatSize& size,
                        EndShapeType shape,
                        bool (*compare)(float, float)) {
   float dx1 = clampTo<float>(fabs(point.x()));
   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);
   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.
+// 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);
 
   // x^2/a^2 + y^2/b^2 = 1
   // a/b = aspectRatio, b = a/aspectRatio
   // a = sqrt(x^2 + y^2/(1/r^2))
   float a = sqrtf(p.x() * p.x() + p.y() * p.y() * aspectRatio * aspectRatio);
   return FloatSize(clampTo<float>(a), clampTo<float>(a / aspectRatio));
 }
 
-// Compute the radius to the closest/farthest corner (depending on the compare functor).
+// Compute the radius to the closest/farthest corner (depending on the compare
+// functor).
 FloatSize radiusToCorner(const FloatPoint& point,
                          const FloatSize& size,
                          EndShapeType shape,
                          bool (*compare)(float, float)) {
   const FloatRect rect(FloatPoint(), size);
   const FloatPoint corners[] = {rect.minXMinYCorner(), rect.maxXMinYCorner(),
                                 rect.maxXMaxYCorner(), rect.minXMaxYCorner()};
 
   unsigned cornerIndex = 0;
   float distance = (point - corners[cornerIndex]).diagonalLength();
   for (unsigned i = 1; i < WTF_ARRAY_LENGTH(corners); ++i) {
     float newDistance = (point - corners[i]).diagonalLength();
     if (compare(newDistance, distance)) {
       cornerIndex = i;
       distance = newDistance;
     }
   }
 
   if (shape == CircleEndShape)
     return FloatSize(distance, distance);
 
   ASSERT(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.
+  // 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(
@@ skipping 138 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