Sk4fLinearGradient fuzzer fixes

src/effects/gradients/Sk4fLinearGradient.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "Sk4x4f.h"
 #include "SkXfermode.h"
@@ skipping 87 matching lines @@
 SkScalar pinFx<SkShader::kMirror_TileMode>(SkScalar fx) {
     const SkScalar f = SkScalarMod(fx, 2.0f);
     return f < 0 ? f + 2 : f;
 }
 
 // true when x is in [k1,k2), or [k2, k1) when the interval is reversed.
 // TODO(fmalita): hoist the reversed interval check out of this helper.
 bool in_range(SkScalar x, SkScalar k1, SkScalar k2) {
     SkASSERT(k1 != k2);
     return (k1 < k2)
-        ? (x >= k1 && x <  k2)
-        : (x >  k2 && x <= k1);
+        ? (x >= k1 && x < k2)
+        : (x >= k2 && x < k1);
 }
 
 } // anonymous namespace
 
 SkLinearGradient::
 LinearGradient4fContext::LinearGradient4fContext(const SkLinearGradient& shader,
                                                  const ContextRec& rec)
     : INHERITED(shader, rec) {
 
     // Our fast path expects interval points to be monotonically increasing in x.
@@ skipping 167 matching lines @@
         : fAdvX((i->fP1 - fx) / dx)
         , fFirstInterval(firstInterval)
         , fLastInterval(lastInterval)
         , fInterval(i)
         , fDx(dx)
         , fIsVertical(is_vertical)
     {
         SkASSERT(fAdvX >= 0);
         SkASSERT(firstInterval <= lastInterval);
         SkASSERT(in_range(fx, i->fP0, i->fP1));
+
+        if (tileMode != kClamp_TileMode && !is_vertical) {
+            const auto spanX = (lastInterval->fP1 - firstInterval->fP0) / dx;
+            SkASSERT(spanX >= 0);
+
+            // If we're in a repeating tile mode and the whole gradient is compressed into a
+            // fraction of a pixel, we just use the average color in zero-ramp mode.
+            // This also avoids cases where we make no progress due to interval advances being
+            // close to zero.
+            static constexpr SkScalar kMinSpanX = .25f;
+            if (spanX < kMinSpanX) {
+                this->init_average_props();
+                return;
+            }
+        }
+
         this->compute_interval_props(fx - i->fP0);
     }
 
     SkScalar currentAdvance() const {
         SkASSERT(fAdvX >= 0);
-        SkASSERT(fAdvX <= (fInterval->fP1 - fInterval->fP0) / fDx);
+        SkASSERT(fAdvX <= (fInterval->fP1 - fInterval->fP0) / fDx || !isfinite(fAdvX));
         return fAdvX;
     }
 
     bool currentRampIsZero() const { return fZeroRamp; }
     const Sk4f& currentColor() const { return fCc; }
     const Sk4f& currentColorGrad() const { return fDcDx; }
 
     void advance(SkScalar advX) {
         SkASSERT(advX > 0);
         SkASSERT(fAdvX >= 0);
@@ skipping 14 matching lines @@
 
         if (fInterval->isZeroRamp()) {
             fDcDx = 0;
         } else {
             const Sk4f dC = DstTraits<dstType, premul>::load(fInterval->fDc);
             fCc           = fCc + dC * Sk4f(t);
             fDcDx         = dC * fDx;
         }
     }
 
+    void init_average_props() {
+        fAdvX     = SK_ScalarInfinity;
+        fZeroRamp = true;
+        fDcDx     = 0;
+        fCc       = Sk4f(0);
+
+        // TODO: precompute the average at interval setup time?
+        for (const auto* i = fFirstInterval; i <= fLastInterval; ++i) {
+            // Each interval contributes its average color to the total/weighted average:
+            //
+            //   C = (c0 + c1) / 2 = (c0 + c0 + dc * (p1 - p0)) / 2
+            //
+            //   Avg += C * (p1 - p0)
+            //
+            const auto dp = i->fP1 - i->fP0;
+            auto c = DstTraits<dstType, premul>::load(i->fC0);
+            if (!i->fZeroRamp) {
+                c = c + DstTraits<dstType, premul>::load(i->fDc) * dp * 0.5f;
+            }
+            fCc = fCc + c * dp;
+        }
+    }
+
     const Interval* next_interval(const Interval* i) const {
         SkASSERT(i >= fFirstInterval);
         SkASSERT(i <= fLastInterval);
         i++;
 
         if (tileMode == kClamp_TileMode) {
             SkASSERT(i <= fLastInterval);
             return i;
         }
 
@@ skipping 132 matching lines @@
         static_cast<const LinearGradient4fContext*>(state->fCtx);
 
     if (ctx->fColorsArePremul) {
         ctx->shadePremulSpan<DstType::F16, ApplyPremul::False>(
             x, y, dst.writable_addr64(x, y), count);
     } else {
         ctx->shadePremulSpan<DstType::F16, ApplyPremul::True>(
             x, y, dst.writable_addr64(x, y), count);
     }
 }