Add support for repeating-conic-gradient()

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 291 matching lines @@
     float offset;
     if (stop.m_offset->isPercentage())
       offset = stop.m_offset->getFloatValue() / 100;
     else
       offset = stop.m_offset->getFloatValue();
 
     desc.stops.emplace_back(offset, resolveStopColor(*stop.m_color, object));
   }
 }
 
-static bool requiresStopsNormalization(const Vector<GradientStop>& stops,
-                                       CSSGradientValue::GradientDesc& desc) {
+namespace {
+
+bool requiresStopsNormalization(const Vector<GradientStop>& stops,
+                                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 (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,
-                                 CSSGradientValue::GradientDesc& desc) {
+bool normalizeAndAddStops(const Vector<GradientStop>& stops,
+                          CSSGradientValue::GradientDesc& desc) {
   DCHECK_GT(stops.size(), 1u);
 
   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);
 
@@ skipping 20 matching lines @@
            normalizedOffset >= (stops[i - 1].offset - firstOffset) / span);
 
     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) {
+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.
         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(
-    CSSGradientValue::GradientDesc& desc,
-    float firstOffset,
-    float lastOffset) {
+void adjustGradientPointsForOffsetRange(CSSGradientValue::GradientDesc& desc,
+                                        float firstOffset,
+                                        float lastOffset) {
   DCHECK_LE(firstOffset, lastOffset);
 
   const FloatPoint p0 = desc.p0;
   const FloatPoint p1 = desc.p1;
   const FloatSize d(p1 - p0);
 
   // Linear offsets are relative to the [p0 , p1] segment.
   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(
-    CSSGradientValue::GradientDesc& desc,
-    float firstOffset,
-    float lastOffset) {
+void adjustGradientRadiiForOffsetRange(CSSGradientValue::GradientDesc& desc,
+                                       float firstOffset,
+                                       float lastOffset) {
   DCHECK_LE(firstOffset, lastOffset);
 
   // Radial offsets are relative to the [0 , endRadius] segment.
   float adjustedR0 = desc.r1 * firstOffset;
   float adjustedR1 = desc.r1 * lastOffset;
   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()
@@ skipping 10 matching lines @@
     adjustedR0 += shiftToPositive;
     adjustedR1 += shiftToPositive;
   }
   DCHECK_GE(adjustedR0, 0);
   DCHECK_GE(adjustedR1, adjustedR0);
 
   desc.r0 = adjustedR0;
   desc.r1 = adjustedR1;
 }
 
+// Helper for performing on-the-fly out of range color stop interpolation.
+class ConicClamper {
+  STACK_ALLOCATED();
+
+ public:
+  ConicClamper(CSSGradientValue::GradientDesc& desc) : m_desc(desc) {}
+
+  void add(float offset, const Color& color) {
+    addInternal(offset, color);
+    m_prevOffset = offset;
+    m_prevColor = color;
+  }
+
+ private:
+  void addUnique(float offset, const Color& color) {
+    // Skip duplicates.
+    if (m_desc.stops.isEmpty() || offset != m_desc.stops.back().stop ||
+        color != m_desc.stops.back().color) {
+      m_desc.stops.emplace_back(offset, color);
+    }
+  }
+
+  void addInternal(float offset, const Color& color) {
+    if (offset < 0)
+      return;
+
+    if (m_prevOffset < 0 && offset > 0) {
+      addUnique(0, blend(m_prevColor, color,
+                         -m_prevOffset / (offset - m_prevOffset)));
+    }
+
+    if (offset <= 1) {
+      addUnique(offset, color);
+      return;
+    }
+
+    if (m_prevOffset < 1) {
+      addUnique(1, blend(m_prevColor, color,
+                         (1 - m_prevOffset) / (offset - m_prevOffset)));
+    }
+  }
+
+  CSSGradientValue::GradientDesc& m_desc;
+
+  float m_prevOffset = 0;
+  Color m_prevColor;
+};
+
+void normalizeAndAddConicStops(const Vector<GradientStop>& stops,
+                               CSSGradientValue::GradientDesc& desc) {
+  DCHECK(!stops.isEmpty());
+  ConicClamper clamper(desc);
+
+  if (desc.spreadMethod == SpreadMethodPad) {
+    for (const auto& stop : stops)
+      clamper.add(stop.offset, stop.color);
+    return;
+  }
+
+  DCHECK_EQ(desc.spreadMethod, SpreadMethodRepeat);
+
+  // The normalization trick we use for linear and radial doesn't work here,
+  // because the underlying Skia implementation doesn't support conic gradient
+  // tiling.  So we emit synthetic stops to cover the whole unit interval.
+  float repeatSpan = stops.back().offset - stops.front().offset;
+  DCHECK_GE(repeatSpan, 0.0f);
+  if (repeatSpan < std::numeric_limits<float>::epsilon()) {

[fs, 2017/04/05 19:19:57]

Should we be worried about small (greater than eps, but still small) values (=>
huge amounts of stops) here?

[f(malita), 2017/04/05 19:33:57]

Yup, that's not ideal.  The current Skia impl is using a 256 LUT (so it'll just
look ugly), but we're planning to switch to an analytical impl - then lots of
stops will slow things down.

But while we have the hood up, I think we could also add native sweep repeat to
Skia and then we can remove this kludge.

[fs, 2017/04/05 20:04:11]

We're good then it sounds like.

+    // All stops are coincident -> use a single solid color.
+    desc.stops.emplace_back(0, stops.back().color);
+    return;
+  }
+
+  // Compute an offset base as a repetition of stops[0].offset such that
+  // [ offsetBase, offsetBase + repeatSpan ] contains 0
+  // (aka the largest repeat value for stops[0] less than 0).
+  float offset = fmodf(stops.front().offset, repeatSpan) -
+                 (stops.front().offset < 0 ? 0 : repeatSpan);
+  DCHECK_LE(offset, 0);
+  DCHECK_GE(offset + repeatSpan, 0);
+
+  // Start throwing repeating values at the clamper.
+  do {
+    const float offsetBase = offset;
+    for (const auto& stop : stops) {
+      offset = offsetBase + stop.offset - stops.front().offset;
+      clamper.add(offset, stop.color);
+
+      if (offset >= 1)
+        break;
+    }
+  } while (offset < 1);
+}
+
+}  // anonymous ns
+
 void CSSGradientValue::addStops(CSSGradientValue::GradientDesc& desc,
                                 const CSSToLengthConversionData& conversionData,
                                 const LayoutObject& object) {
   if (m_gradientType == CSSDeprecatedLinearGradient ||
       m_gradientType == CSSDeprecatedRadialGradient) {
     addDeprecatedStops(desc, object);
     return;
   }
 
   size_t numStops = m_stops.size();
@@ skipping 108 matching lines @@
     }
   }
 
   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.
-  // Note: the normalization trick doesn't work for conic gradients, because
-  // the underlying Skia implementation doesn't support tiling.
-  if (isConicGradientValue() || !requiresStopsNormalization(stops, desc)) {
+  if (!requiresStopsNormalization(stops, desc)) {
     // No normalization required, just add the current stops.
     for (const auto& stop : stops)
       desc.stops.emplace_back(stop.offset, stop.color);
     return;
   }
 
   switch (getClassType()) {
     case LinearGradientClass:
       if (normalizeAndAddStops(stops, desc)) {
         adjustGradientPointsForOffsetRange(desc, stops.front().offset,
                                            stops.back().offset);
       }
       break;
     case RadialGradientClass:
       // 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 (!m_repeating)
         clampNegativeOffsets(stops);
 
       if (normalizeAndAddStops(stops, desc)) {
         adjustGradientRadiiForOffsetRange(desc, stops.front().offset,
                                           stops.back().offset);
       }
       break;
+    case ConicGradientClass:
+      normalizeAndAddConicStops(stops, desc);
+      break;
     default:
       NOTREACHED();
   }
 }
 
 static float positionFromValue(const CSSValue* value,
                                const CSSToLengthConversionData& conversionData,
                                const IntSize& size,
                                bool isHorizontal) {
   int origin = 0;
@@ skipping 774 matching lines @@
   const FloatPoint position(
       m_firstX ? positionFromValue(m_firstX, conversionData, size, true)
                : size.width() / 2,
       m_firstY ? positionFromValue(m_firstY, conversionData, size, false)
                : size.height() / 2);
 
   GradientDesc desc(position, position,
                     m_repeating ? SpreadMethodRepeat : SpreadMethodPad);
   addStops(desc, conversionData, object);
 
-  RefPtr<Gradient> gradient =
-      Gradient::createConic(position, angle, desc.spreadMethod,
-                            Gradient::ColorInterpolation::Premultiplied);
+  RefPtr<Gradient> gradient = Gradient::createConic(
+      position, angle, Gradient::ColorInterpolation::Premultiplied);
   gradient->addColorStops(desc.stops);
 
   return gradient.release();
 }
 
 bool CSSConicGradientValue::equals(const CSSConicGradientValue& other) const {
   return m_repeating == other.m_repeating &&
          dataEquivalent(m_firstX, other.m_firstX) &&
          dataEquivalent(m_firstY, other.m_firstY) &&
          dataEquivalent(m_fromAngle, other.m_fromAngle) &&
          m_stops == other.m_stops;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSConicGradientValue) {
   visitor->trace(m_fromAngle);
   CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 }  // namespace blink