Harden LinearGradient4fContext

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 82 matching lines @@
     const SkScalar f = SkScalarFraction(fx);
     return f < 0 ? f + 1 : f;
 }
 
 template<>
 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)
+// 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.
-    const bool reverseIntervals = this->isFast() && fDstToPos.getScaleX() < 0;
+    const bool reverseIntervals = this->isFast() && signbit(fDstToPos.getScaleX());
     this->buildIntervals(shader, rec, reverseIntervals);
 
     SkASSERT(fIntervals.count() > 0);
     fCachedInterval = fIntervals.begin();
 }
 
 const SkGradientShaderBase::GradientShaderBase4fContext::Interval*
 SkLinearGradient::LinearGradient4fContext::findInterval(SkScalar fx) const {
     SkASSERT(in_range(fx, fIntervals.front().fP0, fIntervals.back().fP1));
 
@@ skipping 153 matching lines @@
                             SkScalar fx,
                             SkScalar dx,
                             bool is_vertical)
         : 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));
         this->compute_interval_props(fx - i->fP0);
     }
 
     SkScalar currentAdvance() const {
         SkASSERT(fAdvX >= 0);
         SkASSERT(fAdvX <= (fInterval->fP1 - fInterval->fP0) / fDx);
         return fAdvX;
     }
@@ skipping 169 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);
     }
 }