Fix 4f gradient swizzle post http://crrev.com/1774523002

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"
 
 namespace {
@@ skipping 143 matching lines @@
 template<>
 float dst_component_scale<SkPM4f>() {
     return 1;
 }
 
 template<>
 float dst_component_scale<SkPMColor>() {
     return 255;
 }
 
+template<typename DstType>
+Sk4f dst_swizzle(const SkPM4f&);
+
+template<>
+Sk4f dst_swizzle<SkPM4f>(const SkPM4f& c) {
+    return c.to4f();
+}
+
+template<>
+Sk4f dst_swizzle<SkPMColor>(const SkPM4f& c) {
+    return c.to4f_pmorder();
+}
+
 SkPMColor pack_color(SkColor c, bool premul) {
     return premul
         ? SkPreMultiplyColor(c)
         : SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
 }
 
 // true when x is in [k1,k2)
 bool in_range(SkScalar x, SkScalar k1, SkScalar k2) {
     SkASSERT(k1 != k2);
     return (k1 < k2)
@@ skipping 123 matching lines @@
     //        interval series - then the iterator operates just as in the
     //        kRepeat case:
     //
     //          ->[P0,P1)->..[Pn-1,Pn)->[2 - Pn,2 - Pn-1)->..[2 - P1,2 - P0)->
     //
     // TODO: investigate collapsing intervals << 1px.
 
     SkASSERT(shader.fColorCount > 1);
     SkASSERT(shader.fOrigColors);
 
-    const float kInv255Float = 1.0f / 255;
-    const float paintAlpha = rec.fPaint->getAlpha() * kInv255Float;
+    const float paintAlpha = rec.fPaint->getAlpha() * (1.0f / 255);
     const Sk4f componentScale = fColorsArePremul
-        ? Sk4f(paintAlpha * kInv255Float)
-        : Sk4f(kInv255Float, kInv255Float, kInv255Float, paintAlpha * kInv255Float);
+        ? Sk4f(paintAlpha)
+        : Sk4f(1.0f, 1.0f, 1.0f, paintAlpha);
     const bool dx_is_pos = fDstToPos.getScaleX() >= 0;
     const int first_index = dx_is_pos ? 0 : shader.fColorCount - 1;
     const int last_index = shader.fColorCount - 1 - first_index;
     const SkScalar first_pos = dx_is_pos ? 0 : SK_Scalar1;
     const SkScalar last_pos = 1 - first_pos;
 
     if (shader.fTileMode == SkShader::kClamp_TileMode) {
         // synthetic edge interval: -/+inf .. P0
         const SkPMColor clamp_color = pack_color(shader.fOrigColors[first_index],
                                                  fColorsArePremul);
@@ skipping 233 matching lines @@
             advX = this->advance_interval(advX);
         }
         SkASSERT(advX < fAdvX);
 
         fCc = fCc + fDcDx * Sk4f(advX);
         fAdvX -= advX;
     }
 
 private:
     void compute_interval_props(SkScalar t) {
-        fDc   = Sk4f::Load(fInterval->fDc.fVec);
-        fCc   = Sk4f::Load(fInterval->fC0.fVec);
+        fDc   = dst_swizzle<DstType>(fInterval->fDc);
+        fCc   = dst_swizzle<DstType>(fInterval->fC0);
         fCc   = fCc + fDc * Sk4f(t);
         fCc   = fCc * fDstComponentScale;
         fDcDx = fDc * fDstComponentScale * Sk4f(fDx);
         fZeroRamp = fIsVertical || fInterval->isZeroRamp();
     }
 
     const Interval* next_interval(const Interval* i) const {
         SkASSERT(i >= fFirstInterval);
         SkASSERT(i <= fLastInterval);
         i++;
@@ skipping 30 matching lines @@
     Sk4f            fCc;        // current color, interpolated in dst
     SkScalar        fAdvX;      // remaining interval advance in dst
     bool            fZeroRamp;  // current interval color grad is 0
 
     const Interval* fFirstInterval;
     const Interval* fLastInterval;
     const Interval* fInterval;  // current interval
     const SkScalar  fDx;        // 'dx' for consistency with other impls; actually dt/dx
     const bool      fIsVertical;
 };