Unify some SkNx code

src/effects/gradients/SkLinearGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLinearGradient.h"
 
 static const float kInv255Float = 1.0f / 255;
@@ skipping 132 matching lines @@
     }
 
     if (fApplyAlphaAfterInterp) {
         // Our fColor values are in PMColor order, but are still unpremultiplied, allowing us to
         // interpolate in unpremultiplied space first, and then scale by alpha right before we
         // convert to SkPMColor bytes.
         const float paintAlpha = ctx.fPaint->getAlpha() * kInv255Float;
         const Sk4f scale(1, 1, 1, paintAlpha);
         for (int i = 0; i < count; ++i) {
             uint32_t c = SkSwizzle_Color_to_PMColor(shader.fOrigColors[i]);
-            rec[i].fColor = Sk4f::FromBytes((const uint8_t*)&c) * scale;
+            rec[i].fColor = SkNx_cast<float>(Sk4b::Load((const uint8_t*)&c)) * scale;
             if (i > 0) {
                 SkASSERT(rec[i - 1].fPos <= rec[i].fPos);
             }
         }
     } else {
         // Our fColor values are premultiplied, so converting to SkPMColor is just a matter
         // of converting the floats down to bytes.
         unsigned alphaScale = ctx.fPaint->getAlpha() + (ctx.fPaint->getAlpha() >> 7);
         for (int i = 0; i < count; ++i) {
             SkPMColor pmc = SkPreMultiplyColor(shader.fOrigColors[i]);
             pmc = SkAlphaMulQ(pmc, alphaScale);
-            rec[i].fColor = Sk4f::FromBytes((const uint8_t*)&pmc);
+            rec[i].fColor = SkNx_cast<float>(Sk4b::Load((const uint8_t*)&pmc));
             if (i > 0) {
                 SkASSERT(rec[i - 1].fPos <= rec[i].fPos);
             }
         }
     }
 }
 
 #define NO_CHECK_ITER               \
     do {                            \
     unsigned fi = SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache32Shift; \
@@ skipping 516 matching lines @@
         rec -= 1;
         SkASSERT(rec[0].fPos >= 0 && rec[0].fPos <= 1);
         SkASSERT(rec[1].fPos >= 0 && rec[1].fPos <= 1);
         SkASSERT(rec[0].fPos <= rec[1].fPos);
     }
     return rec;
 }
 
 template <bool apply_alpha> SkPMColor trunc_from_255(const Sk4f& x) {
     SkPMColor c;
-    x.toBytes((uint8_t*)&c);
+    SkNx_cast<uint8_t>(x).store((uint8_t*)&c);
     if (apply_alpha) {
         c = SkPreMultiplyARGB(SkGetPackedA32(c), SkGetPackedR32(c),
                               SkGetPackedG32(c), SkGetPackedB32(c));
     }
     return c;
 }
 
 template <bool apply_alpha> void fill(SkPMColor dst[], int count,
                                       const Sk4f& c4, const Sk4f& c4other) {
     sk_memset32_dither(dst, trunc_from_255<apply_alpha>(c4),
@@ skipping 31 matching lines @@
 template <bool apply_alpha> void ramp(SkPMColor dstC[], int n, const Sk4f& c, const Sk4f& dc,
                                       const Sk4f& dither0, const Sk4f& dither1) {
     Sk4f dc2 = dc + dc;
     Sk4f dc4 = dc2 + dc2;
     Sk4f cd0 = c + dither0;
     Sk4f cd1 = c + dc + dither1;
     Sk4f cd2 = cd0 + dc2;
     Sk4f cd3 = cd1 + dc2;
     while (n >= 4) {
         if (!apply_alpha) {
-            Sk4f::ToBytes((uint8_t*)dstC, cd0, cd1, cd2, cd3);
+            Sk4f_ToBytes((uint8_t*)dstC, cd0, cd1, cd2, cd3);
             dstC += 4;
         } else {
             *dstC++ = trunc_from_255<apply_alpha>(cd0);
             *dstC++ = trunc_from_255<apply_alpha>(cd1);
             *dstC++ = trunc_from_255<apply_alpha>(cd2);
             *dstC++ = trunc_from_255<apply_alpha>(cd3);
         }
         cd0 = cd0 + dc4;
         cd1 = cd1 + dc4;
         cd2 = cd2 + dc4;
@@ skipping 157 matching lines @@
         }
     } else {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
         }
     }
 }