Remove Gradient point/radius setters

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 106 matching lines @@
 }
 
 struct GradientStop {
   Color color;
   float offset;
   bool specified;
 
   GradientStop() : offset(0), specified(false) {}
 };
 
+struct CSSGradientValue::GradientDesc {
+  STACK_ALLOCATED();
+
+  GradientDesc(const FloatPoint& p0,
+               const FloatPoint& p1,
+               GradientSpreadMethod spreadMethod)
+      : p0(p0), p1(p1), spreadMethod(spreadMethod) {}
+  GradientDesc(const FloatPoint& p0,
+               const FloatPoint& p1,
+               float r0,
+               float r1,
+               GradientSpreadMethod spreadMethod)
+      : p0(p0), p1(p1), r0(r0), r1(r1), spreadMethod(spreadMethod) {}
+
+  Vector<Gradient::ColorStop> stops;
+  FloatPoint p0, p1;
+  float r0 = 0, r1 = 0;
+  GradientSpreadMethod spreadMethod = SpreadMethodPad;
+};
+
 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.
   // If the hint is closer to the left color stop, add 2 stops to the left and
@@ skipping 79 matching lines @@
     indexOffset += 8;
   }
 }
 
 static Color resolveStopColor(const CSSValue& stopColor,
                               const LayoutObject& object) {
   return object.document().textLinkColors().colorFromCSSValue(
       stopColor, object.resolveColor(CSSPropertyColor));
 }
 
-void CSSGradientValue::addDeprecatedStops(Gradient* gradient,
+void CSSGradientValue::addDeprecatedStops(GradientDesc& desc,
                                           const LayoutObject& object) {
   ASSERT(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;
     if (stop.m_position->isPercentage())
       offset = stop.m_position->getFloatValue() / 100;
     else
       offset = stop.m_position->getFloatValue();
 
-    gradient->addColorStop(offset, resolveStopColor(*stop.m_color, object));
+    desc.stops.emplace_back(offset, resolveStopColor(*stop.m_color, object));
   }
 }
 
 static bool requiresStopsNormalization(const Vector<GradientStop>& stops,
-                                       const Gradient* gradient) {
+                                       CSSGradientValue::GradientDesc& desc) {
   // We need at least two stops to normalize
   if (stops.size() < 2)
     return false;
 
   // Repeating gradients are implemented using a normalized stop offset range
   // with the point/radius pairs aligned on the interval endpoints.
-  if (gradient->spreadMethod() == SpreadMethodRepeat)
+  if (desc.spreadMethod == SpreadMethodRepeat)
     return true;
 
   // Degenerate stops
   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) {
+                                 CSSGradientValue::GradientDesc& desc) {
   ASSERT(stops.size() > 1);
 
   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);
+    if (desc.spreadMethod != SpreadMethodRepeat)
+      desc.stops.emplace_back(clampedOffset, stops.front().color);
+    desc.stops.emplace_back(clampedOffset, stops.back().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);
+    desc.stops.emplace_back(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;
 
@@ skipping 13 matching lines @@
       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());
+static void adjustGradientPointsForOffsetRange(
+    CSSGradientValue::GradientDesc& desc,
+    float firstOffset,
+    float lastOffset) {
   ASSERT(firstOffset <= lastOffset);
 
-  const FloatPoint p0 = gradient->p0();
-  const FloatPoint p1 = gradient->p1();
+  const FloatPoint p0 = desc.p0;
+  const FloatPoint p1 = desc.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);
+  desc.p0 = p0 + d * firstOffset;
+  desc.p1 = 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());
+static void adjustGradientRadiiForOffsetRange(
+    CSSGradientValue::GradientDesc& desc,
+    float firstOffset,
+    float lastOffset) {
   ASSERT(firstOffset <= lastOffset);
 
   // Radial offsets are relative to the [0 , endRadius] segment.
-  float adjustedR0 = gradient->endRadius() * firstOffset;
-  float adjustedR1 = gradient->endRadius() * lastOffset;
+  float adjustedR0 = desc.r1 * firstOffset;
+  float adjustedR1 = desc.r1 * 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.
-    ASSERT(gradient->spreadMethod() == SpreadMethodRepeat);
+    DCHECK_EQ(desc.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);
 
-  gradient->setStartRadius(adjustedR0);
-  gradient->setEndRadius(adjustedR1);
+  desc.r0 = adjustedR0;
+  desc.r1 = adjustedR1;
 }
 
-void CSSGradientValue::addStops(Gradient* gradient,
+void CSSGradientValue::addStops(CSSGradientValue::GradientDesc& desc,
                                 const CSSToLengthConversionData& conversionData,
                                 const LayoutObject& object) {
   if (m_gradientType == CSSDeprecatedLinearGradient ||
       m_gradientType == CSSDeprecatedRadialGradient) {
-    addDeprecatedStops(gradient, object);
+    addDeprecatedStops(desc, object);
     return;
   }
 
   size_t numStops = m_stops.size();
 
   Vector<GradientStop> stops(numStops);
 
   bool hasHints = false;
 
-  FloatPoint gradientStart = gradient->p0();
+  FloatPoint gradientStart = desc.p0;
   FloatPoint gradientEnd;
   if (isLinearGradientValue())
-    gradientEnd = gradient->p1();
+    gradientEnd = desc.p1;
   else if (isRadialGradientValue())
-    gradientEnd = gradientStart + FloatSize(gradient->endRadius(), 0);
+    gradientEnd = gradientStart + FloatSize(desc.r1, 0);
   float gradientLength =
       FloatSize(gradientStart - gradientEnd).diagonalLength();
 
   for (size_t i = 0; i < numStops; ++i) {
     const CSSGradientColorStop& stop = m_stops[i];
 
     if (stop.isHint())
       hasHints = true;
     else
       stops[i].color = resolveStopColor(*stop.m_color, object);
@@ skipping 78 matching lines @@
     }
   }
 
   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.
-  if (requiresStopsNormalization(stops, gradient)) {
+  if (requiresStopsNormalization(stops, desc)) {
     // 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 (normalizeAndAddStops(stops, desc)) {
       if (isLinearGradientValue()) {
-        adjustGradientPointsForOffsetRange(gradient, stops.front().offset,
+        adjustGradientPointsForOffsetRange(desc, stops.front().offset,
                                            stops.back().offset);
       } else {
-        adjustGradientRadiiForOffsetRange(gradient, stops.front().offset,
+        adjustGradientRadiiForOffsetRange(desc, stops.front().offset,
                                           stops.back().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);
+      desc.stops.emplace_back(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();
@@ skipping 335 matching lines @@
           if (m_firstY)
             firstPoint.setY(size.height() - secondPoint.y());
         } else
           secondPoint.setY(size.height());
         break;
       default:
         ASSERT_NOT_REACHED();
     }
   }
 
+  GradientDesc desc(firstPoint, secondPoint,
+                    m_repeating ? SpreadMethodRepeat : SpreadMethodPad);
+  addStops(desc, conversionData, object);
+
   RefPtr<Gradient> gradient =
-      Gradient::create(firstPoint, secondPoint,
-                       m_repeating ? SpreadMethodRepeat : SpreadMethodPad,
+      Gradient::create(desc.p0, desc.p1, desc.spreadMethod,
                        Gradient::ColorInterpolation::Premultiplied);
 
   // Now add the stops.
-  addStops(gradient.get(), conversionData, object);
+  gradient->addColorStops(desc.stops);
 
   return gradient.release();
 }
 
 bool CSSLinearGradientValue::equals(const CSSLinearGradientValue& other) const {
   if (m_gradientType == CSSDeprecatedLinearGradient)
     return other.m_gradientType == m_gradientType &&
            dataEquivalent(m_firstX, other.m_firstX) &&
            dataEquivalent(m_firstY, other.m_firstY) &&
            dataEquivalent(m_secondX, other.m_secondX) &&
@@ skipping 339 matching lines @@
                                       [](float a, float b) { return a > b; });
         break;
     }
   }
 
   DCHECK(std::isfinite(firstRadius));
   DCHECK(std::isfinite(secondRadius.width()));
   DCHECK(std::isfinite(secondRadius.height()));
 
   bool isDegenerate = !secondRadius.width() || !secondRadius.height();
-  RefPtr<Gradient> gradient =
-      Gradient::create(firstPoint, firstRadius, secondPoint,
-                       isDegenerate ? 0 : secondRadius.width(),
-                       isDegenerate ? 1 : secondRadius.aspectRatio(),
-                       m_repeating ? SpreadMethodRepeat : SpreadMethodPad,
-                       Gradient::ColorInterpolation::Premultiplied);
+  GradientDesc desc(firstPoint, secondPoint, firstRadius,
+                    isDegenerate ? 0 : secondRadius.width(),
+                    m_repeating ? SpreadMethodRepeat : SpreadMethodPad);
+  addStops(desc, conversionData, object);
+
+  RefPtr<Gradient> gradient = Gradient::create(
+      desc.p0, desc.r0, desc.p1, desc.r1,
+      isDegenerate ? 1 : secondRadius.aspectRatio(), desc.spreadMethod,
+      Gradient::ColorInterpolation::Premultiplied);
 
   // Now add the stops.
-  addStops(gradient.get(), conversionData, object);
+  gradient->addColorStops(desc.stops);
 
   return gradient.release();
 }
 
 bool CSSRadialGradientValue::equals(const CSSRadialGradientValue& other) const {
   if (m_gradientType == CSSDeprecatedRadialGradient)
     return other.m_gradientType == m_gradientType &&
            dataEquivalent(m_firstX, other.m_firstX) &&
            dataEquivalent(m_firstY, other.m_firstY) &&
            dataEquivalent(m_secondX, other.m_secondX) &&
@@ skipping 47 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