Fix fuzzer assert in GradientShaderBase4fContext::TSampler

src/effects/gradients/Sk4fGradientBase.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 "Sk4fGradientBase.h"
 
 #include <functional>
 
 namespace {
 
 Sk4f pack_color(SkColor c, bool premul, const Sk4f& component_scale) {
     const SkColor4f c4f = SkColor4f::FromColor(c);
     const Sk4f pm4f = premul
         ? c4f.premul().to4f()
         : Sk4f{c4f.fR, c4f.fG, c4f.fB, c4f.fA};
 
     return pm4f * component_scale;
 }
 
-template<SkShader::TileMode>
-SkScalar tileProc(SkScalar t);
-
-template<>
-SkScalar tileProc<SkShader::kClamp_TileMode>(SkScalar t) {
-    // synthetic clamp-mode edge intervals allow for a free-floating t:
-    //   [-inf..0)[0..1)[1..+inf)
-    return t;
-}
-
-template<>
-SkScalar tileProc<SkShader::kRepeat_TileMode>(SkScalar t) {
-    // t % 1  (intervals range: [0..1))
-    return t - SkScalarFloorToScalar(t);
-}
-
-template<>
-SkScalar tileProc<SkShader::kMirror_TileMode>(SkScalar t) {
-    // t % 2  (synthetic mirror intervals expand the range to [0..2)
-    return t - SkScalarFloorToScalar(t / 2) * 2;
-}
-
 class IntervalIterator {
 public:
     IntervalIterator(const SkColor* colors, const SkScalar* pos, int count, bool reverse)
         : fColors(colors)
         , fPos(pos)
         , fCount(count)
         , fFirstPos(reverse ? SK_Scalar1 : 0)
         , fBegin(reverse ? count - 1 : 0)
         , fAdvance(reverse ? -1 : 1) {
         SkASSERT(colors);
@@ skipping 292 matching lines @@
         count -= n;
     } while (count > 0);
 }
 
 template<DstType dstType, ApplyPremul premul, SkShader::TileMode tileMode>
 class SkGradientShaderBase::GradientShaderBase4fContext::TSampler {
 public:
     TSampler(const GradientShaderBase4fContext& ctx)
         : fFirstInterval(ctx.fIntervals.begin())
         , fLastInterval(ctx.fIntervals.end() - 1)
-        , fInterval(nullptr) {
+        , fInterval(nullptr)
+        , fLargestLessThanTwo(nextafterf(2, 0)) {
         SkASSERT(fLastInterval >= fFirstInterval);
     }
 
     Sk4f sample(SkScalar t) {
-        const SkScalar tiled_t = tileProc<tileMode>(t);
+        const auto tiled_t = tileProc(t);
 
         if (!fInterval) {
             // Very first sample => locate the initial interval.
             // TODO: maybe do this in ctor to remove a branch?
             fInterval = this->findFirstInterval(tiled_t);
             this->loadIntervalData(fInterval);
         } else if (tiled_t < fInterval->fP0 || tiled_t >= fInterval->fP1) {
             fInterval = this->findNextInterval(t, tiled_t);
             this->loadIntervalData(fInterval);
         }
 
         fPrevT = t;
         return lerp(tiled_t);
     }
 
 private:
+    SkScalar tileProc(SkScalar t) const {
+        switch (tileMode) {
+        case kClamp_TileMode:
+            // synthetic clamp-mode edge intervals allow for a free-floating t:
+            //   [-inf..0)[0..1)[1..+inf)
+            return t;
+        case kRepeat_TileMode:
+            // t % 1  (intervals range: [0..1))
+            return t - SkScalarFloorToScalar(t);
+        case kMirror_TileMode:
+            // t % 2  (synthetic mirror intervals expand the range to [0..2)
+            // Due to the extra arithmetic, we must clamp to ensure the value remains less than 2.
+            return SkTMin(t - SkScalarFloorToScalar(t / 2) * 2, fLargestLessThanTwo);
+        }
+
+        SK_ABORT("Unhandled tile mode.");
+        return 0;
+    }
+
     Sk4f lerp(SkScalar t) {
         SkASSERT(t >= fInterval->fP0 && t < fInterval->fP1);
         return fCc + fDc * (t - fInterval->fP0);
     }
 
     const Interval* findFirstInterval(SkScalar t) const {
         // Binary search.
         const Interval* i0 = fFirstInterval;
         const Interval* i1 = fLastInterval;
 
@@ skipping 43 matching lines @@
 
     void loadIntervalData(const Interval* i) {
         fCc = DstTraits<dstType, premul>::load(i->fC0);
         fDc = DstTraits<dstType, premul>::load(i->fDc);
     }
 
     const Interval* fFirstInterval;
     const Interval* fLastInterval;
     const Interval* fInterval;
     SkScalar        fPrevT;
+    SkScalar        fLargestLessThanTwo;

[herb_g, 2016/11/04 14:58:44]

Can this be static constexpr?

[f(malita), 2016/11/04 15:05:53]

Unfortunately not, nextafterf is not constexpr :(

     Sk4f            fCc;
     Sk4f            fDc;
 };