Observe gTreatSkColorAsSRGB for 4f gradients.

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 {
 
-SkPMColor pack_color(SkColor c, bool premul) {
-    return premul
-        ? SkPreMultiplyColor(c)
-        : SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
+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;
@@ skipping 82 matching lines @@
     const SkScalar* fPos;
     const int       fCount;
     const SkScalar  fFirstPos;
     const int       fBegin;
     const int       fAdvance;
 };
 
 } // anonymous namespace
 
 SkGradientShaderBase::GradientShaderBase4fContext::
-Interval::Interval(SkPMColor c0, SkScalar p0,
-                   SkPMColor c1, SkScalar p1,
-                   const Sk4f& componentScale)
+Interval::Interval(const Sk4f& c0, SkScalar p0,
+                   const Sk4f& c1, SkScalar p1)
     : fP0(p0)
     , fP1(p1)
-    , fZeroRamp(c0 == c1) {
+    , fZeroRamp((c0 == c1).allTrue()) {
+
     SkASSERT(p0 != p1);
+    const Sk4f dc = (c1 - c0) / (p1 - p0);
 
-    const Sk4f c4f0 = SkPM4f::FromPMColor(c0).to4f() * componentScale;
-    const Sk4f c4f1 = SkPM4f::FromPMColor(c1).to4f() * componentScale;
-    const Sk4f dc4f = (c4f1 - c4f0) / (p1 - p0);
-
-    c4f0.store(&fC0.fVec);
-    dc4f.store(&fDc.fVec);
+    c0.store(&fC0.fVec);
+    dc.store(&fDc.fVec);
 }
 
 SkGradientShaderBase::
 GradientShaderBase4fContext::GradientShaderBase4fContext(const SkGradientShaderBase& shader,
                                                          const ContextRec& rec)
     : INHERITED(shader, rec)
     , fFlags(this->INHERITED::getFlags())
 #ifdef SK_SUPPORT_LEGACY_GRADIENT_DITHERING
     , fDither(true)
 #else
@@ skipping 65 matching lines @@
     const Sk4f componentScale = fColorsArePremul
         ? Sk4f(paintAlpha)
         : 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 SkPMColor clamp_color = pack_color(shader.fOrigColors[first_index],
-                                                 fColorsArePremul);
+        const Sk4f clamp_color = pack_color(shader.fOrigColors[first_index],
+                                            fColorsArePremul, componentScale);
         const SkScalar clamp_pos = reverse ? SK_ScalarMax : SK_ScalarMin;
         fIntervals.emplace_back(clamp_color, clamp_pos,
-                                clamp_color, first_pos,
-                                componentScale);
+                                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),
+        fIntervals.emplace_back(pack_color(c0, fColorsArePremul, componentScale),
                                 p0,
-                                pack_color(c1, fColorsArePremul),
-                                p1,
-                                componentScale);
+                                pack_color(c1, fColorsArePremul, componentScale),
+                                p1);
     });
 
     if (shader.fTileMode == SkShader::kClamp_TileMode) {
         // synthetic edge interval: Pn .. +/-inf
-        const SkPMColor clamp_color =
-            pack_color(shader.fOrigColors[last_index], fColorsArePremul);
+        const Sk4f clamp_color = pack_color(shader.fOrigColors[last_index],
+                                            fColorsArePremul, componentScale);
         const SkScalar clamp_pos = reverse ? SK_ScalarMin : SK_ScalarMax;
         fIntervals.emplace_back(clamp_color, last_pos,
-                                clamp_color, clamp_pos,
-                                componentScale);
+                                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,
                                             const Sk4f& componentScale, bool reverse) {
     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 == 2 - p0);
 
-        fIntervals.emplace_back(pack_color(c0, fColorsArePremul),
+        fIntervals.emplace_back(pack_color(c0, fColorsArePremul, componentScale),
                                 2 - p0,
-                                pack_color(c1, fColorsArePremul),
-                                2 - p1,
-                                componentScale);
+                                pack_color(c1, fColorsArePremul, componentScale),
+                                2 - p1);
     });
 }
 
 void SkGradientShaderBase::
 GradientShaderBase4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) {
     if (fColorsArePremul) {
         this->shadePremulSpan<DstType::L32, ApplyPremul::False>(x, y, dst, count);
     } else {
         this->shadePremulSpan<DstType::L32, ApplyPremul::True>(x, y, dst, count);
     }
@@ skipping 144 matching lines @@
         fDc = DstTraits<dstType>::load(i->fDc);
     }
 
     const Interval* fFirstInterval;
     const Interval* fLastInterval;
     const Interval* fInterval;
     SkScalar        fPrevT;
     Sk4f            fCc;
     Sk4f            fDc;
 };