[Sk4fGradient] Use infinity floats for clamp-mode extreme positions

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>
@@ skipping 109 matching lines @@
 } // anonymous namespace
 
 SkGradientShaderBase::GradientShaderBase4fContext::
 Interval::Interval(const Sk4f& c0, SkScalar p0,
                    const Sk4f& c1, SkScalar p1)
     : fP0(p0)
     , fP1(p1)
     , fZeroRamp((c0 == c1).allTrue()) {
 
     SkASSERT(p0 != p1);
-    const Sk4f dc = (c1 - c0) / (p1 - p0);
+    // Either p0 or p1 can be (-)inf for synthetic clamp edge intervals.
+    SkASSERT(SkScalarIsFinite(p0) || SkScalarIsFinite(p1));
+
+    const auto dp = p1 - p0;
+
+    // Clamp edge intervals are always zero-ramp.
+    SkASSERT(SkScalarIsFinite(dp) || fZeroRamp);
+    const Sk4f dc = SkScalarIsFinite(dp) ? (c1 - c0) / dp : 0;
 
     c0.store(&fC0.fVec);
     dc.store(&fDc.fVec);
 }
 
 SkGradientShaderBase::
 GradientShaderBase4fContext::GradientShaderBase4fContext(const SkGradientShaderBase& shader,
                                                          const ContextRec& rec)
     : INHERITED(shader, rec)
     , fFlags(this->INHERITED::getFlags())
@@ skipping 75 matching lines @@
         : Sk4f(1.0f, 1.0f, 1.0f, paintAlpha);
     const int first_index = reverse ? shader.fColorCount - 1 : 0;
     const int last_index = shader.fColorCount - 1 - first_index;
     const SkScalar first_pos = reverse ? SK_Scalar1 : 0;
     const SkScalar last_pos = SK_Scalar1 - first_pos;
 
     if (shader.fTileMode == SkShader::kClamp_TileMode) {
         // synthetic edge interval: -/+inf .. P0
         const Sk4f clamp_color = pack_color(shader.fOrigColors[first_index],
                                             fColorsArePremul, componentScale);
-        const SkScalar clamp_pos = reverse ? SK_ScalarMax : SK_ScalarMin;
+        const SkScalar clamp_pos = reverse ? SK_ScalarInfinity : SK_ScalarNegativeInfinity;
         fIntervals.emplace_back(clamp_color, clamp_pos,
                                 clamp_color, first_pos);
     } else if (shader.fTileMode == SkShader::kMirror_TileMode && reverse) {
         // synthetic mirror intervals injected before main intervals: (2 .. 1]
         addMirrorIntervals(shader, componentScale, false);
     }
 
     const IntervalIterator iter(shader.fOrigColors,
                                 shader.fOrigPos,
                                 shader.fColorCount,
                                 reverse);
     iter.iterate([this, &componentScale] (SkColor c0, SkColor c1, SkScalar p0, SkScalar p1) {
         SkASSERT(fIntervals.empty() || fIntervals.back().fP1 == p0);
 
         fIntervals.emplace_back(pack_color(c0, fColorsArePremul, componentScale),
                                 p0,
                                 pack_color(c1, fColorsArePremul, componentScale),
                                 p1);
     });
 
     if (shader.fTileMode == SkShader::kClamp_TileMode) {
         // synthetic edge interval: Pn .. +/-inf
         const Sk4f clamp_color = pack_color(shader.fOrigColors[last_index],
                                             fColorsArePremul, componentScale);
-        const SkScalar clamp_pos = reverse ? SK_ScalarMin : SK_ScalarMax;
+        const SkScalar clamp_pos = reverse ? SK_ScalarNegativeInfinity : SK_ScalarInfinity;
         fIntervals.emplace_back(clamp_color, last_pos,
                                 clamp_color, clamp_pos);
     } else if (shader.fTileMode == SkShader::kMirror_TileMode && !reverse) {
         // synthetic mirror intervals injected after main intervals: [1 .. 2)
         addMirrorIntervals(shader, componentScale, true);
     }
 }
 
 void SkGradientShaderBase::
 GradientShaderBase4fContext::addMirrorIntervals(const SkGradientShaderBase& shader,
@@ skipping 166 matching lines @@
         fDc = DstTraits<dstType, premul>::load(i->fDc);
     }
 
     const Interval* fFirstInterval;
     const Interval* fLastInterval;
     const Interval* fInterval;
     SkScalar        fPrevT;
     Sk4f            fCc;
     Sk4f            fDc;
 };