Change SkShader;asFragmentProcessor signature to no longer take skpaint\grcolor*

Review URL: https://codereview.chromium.org/1316513002

20 files changed, 132 insertions, 225 deletions

diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 0f96cdf59a..b28a62bcd7 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -195,7 +195,7 @@ void GrGLAlphaThresholdEffect::onSetData(const GrGLProgramDataManager& pdman,
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AlphaThresholdEffect);
 
-GrFragmentProcessor* AlphaThresholdEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* AlphaThresholdEffect::TestCreate(GrProcessorTestData* d) {
     GrTexture* bmpTex = d->fTextures[GrProcessorUnitTest::kSkiaPMTextureIdx];
     GrTexture* maskTex = d->fTextures[GrProcessorUnitTest::kAlphaTextureIdx];
     float innerThresh = d->fRandom->nextUScalar1();
diff --git a/src/effects/SkArithmeticMode_gpu.cpp b/src/effects/SkArithmeticMode_gpu.cpp
index 7732917e42..fd20b73cdc 100644
--- a/src/effects/SkArithmeticMode_gpu.cpp
+++ b/src/effects/SkArithmeticMode_gpu.cpp
@@ -137,7 +137,7 @@ void GrArithmeticFP::onComputeInvariantOutput(GrInvariantOutput* inout) const {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrFragmentProcessor* GrArithmeticFP::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrArithmeticFP::TestCreate(GrProcessorTestData* d) {
     float k1 = d->fRandom->nextF();
     float k2 = d->fRandom->nextF();
     float k3 = d->fRandom->nextF();
@@ -295,7 +295,7 @@ void GrArithmeticXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorP
 
 GR_DEFINE_XP_FACTORY_TEST(GrArithmeticXPFactory);
 
-GrXPFactory* GrArithmeticXPFactory::TestCreate(GrProcessorTestData* d) {
+const GrXPFactory* GrArithmeticXPFactory::TestCreate(GrProcessorTestData* d) {
     float k1 = d->fRandom->nextF();
     float k2 = d->fRandom->nextF();
     float k3 = d->fRandom->nextF();
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index f2bcf3ed0d..1bd708b5e0 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -816,7 +816,7 @@ void GrRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
 
-GrFragmentProcessor* GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
     float sigma = d->fRandom->nextRangeF(3,8);
     float width = d->fRandom->nextRangeF(200,300);
     float height = d->fRandom->nextRangeF(200,300);
@@ -997,7 +997,7 @@ bool GrRRectBlurEffect::onIsEqual(const GrFragmentProcessor& other) const {
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect);
 
-GrFragmentProcessor* GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f);
     SkScalar r = d->fRandom->nextRangeF(1.f, 9.f);
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index c3fa730d00..c38328ccbb 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -339,7 +339,7 @@ void ModeColorFilterEffect::onComputeInvariantOutput(GrInvariantOutput* inout) c
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ModeColorFilterEffect);
-GrFragmentProcessor* ModeColorFilterEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* ModeColorFilterEffect::TestCreate(GrProcessorTestData* d) {
     SkXfermode::Mode mode = SkXfermode::kDst_Mode;
     while (SkXfermode::kDst_Mode == mode) {
         mode = static_cast<SkXfermode::Mode>(d->fRandom->nextRangeU(0, SkXfermode::kLastCoeffMode));
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index 8dc603042c..92b26ebdf9 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -526,7 +526,7 @@ private:
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorMatrixEffect);
 
-GrFragmentProcessor* ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
     SkColorMatrix colorMatrix;
     for (size_t i = 0; i < SK_ARRAY_COUNT(colorMatrix.fMat); ++i) {
         colorMatrix.fMat[i] = d->fRandom->nextSScalar1();
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 9044284300..49290718e3 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -517,7 +517,7 @@ void GrDisplacementMapEffect::onComputeInvariantOutput(GrInvariantOutput* inout)
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDisplacementMapEffect);
 
-GrFragmentProcessor* GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) {
     int texIdxDispl = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                                GrProcessorUnitTest::kAlphaTextureIdx;
     int texIdxColor = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index dd56751382..240a6939ae 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -1633,7 +1633,7 @@ GrGLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const {
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
 
-GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar surfaceScale = d->fRandom->nextSScalar1();
     SkScalar kd = d->fRandom->nextUScalar1();
     SkAutoTUnref<SkImageFilterLight> light(create_random_light(d->fRandom));
@@ -1836,7 +1836,7 @@ GrGLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const {
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
 
-GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar surfaceScale = d->fRandom->nextSScalar1();
     SkScalar ks = d->fRandom->nextUScalar1();
     SkScalar shininess = d->fRandom->nextUScalar1();
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index b9998f8122..622144bfad 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -195,7 +195,7 @@ GrGLFragmentProcessor* GrMagnifierEffect::onCreateGLInstance() const {
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
 
-GrFragmentProcessor* GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
     GrTexture* texture = d->fTextures[0];
     const int kMaxWidth = 200;
     const int kMaxHeight = 200;
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index cde29c0f4c..2c99af92da 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -445,7 +445,7 @@ void GrMorphologyEffect::onComputeInvariantOutput(GrInvariantOutput* inout) cons
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMorphologyEffect);
 
-GrFragmentProcessor* GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
                                       GrProcessorUnitTest::kAlphaTextureIdx;
     Direction dir = d->fRandom->nextBool() ? kX_Direction : kY_Direction;
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index af6622be4d..40da2db14a 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -19,6 +19,8 @@
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
 #include "SkGr.h"
+#include "effects/GrConstColorProcessor.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #endif
@@ -500,7 +502,6 @@ private:
     bool                                  fStitchTiles;
     int                                   fNumOctaves;
     GrGLProgramDataManager::UniformHandle fBaseFrequencyUni;
-    GrGLProgramDataManager::UniformHandle fAlphaUni;
 
 private:
     typedef GrGLFragmentProcessor INHERITED;
@@ -515,9 +516,9 @@ public:
                                        int numOctaves, bool stitchTiles,
                                        SkPerlinNoiseShader::PaintingData* paintingData,
                                        GrTexture* permutationsTexture, GrTexture* noiseTexture,
-                                       const SkMatrix& matrix, uint8_t alpha) {
+                                       const SkMatrix& matrix) {
         return new GrPerlinNoiseEffect(procDataManager, type, numOctaves, stitchTiles, paintingData,
-                                       permutationsTexture, noiseTexture, matrix, alpha);
+                                       permutationsTexture, noiseTexture, matrix);
     }
 
     virtual ~GrPerlinNoiseEffect() { delete fPaintingData; }
@@ -531,7 +532,6 @@ public:
     const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
     int numOctaves() const { return fNumOctaves; }
     const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
-    uint8_t alpha() const { return fAlpha; }
 
 private:
     GrGLFragmentProcessor* onCreateGLInstance() const override {
@@ -549,7 +549,6 @@ private:
                fPaintingData->fBaseFrequency == s.fPaintingData->fBaseFrequency &&
                fNumOctaves == s.fNumOctaves &&
                fStitchTiles == s.fStitchTiles &&
-               fAlpha == s.fAlpha &&
                fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
     }
 
@@ -561,11 +560,10 @@ private:
                         int numOctaves, bool stitchTiles,
                         SkPerlinNoiseShader::PaintingData* paintingData,
                         GrTexture* permutationsTexture, GrTexture* noiseTexture,
-                        const SkMatrix& matrix, uint8_t alpha)
+                        const SkMatrix& matrix)
       : fType(type)
       , fNumOctaves(numOctaves)
       , fStitchTiles(stitchTiles)
-      , fAlpha(alpha)
       , fPermutationsAccess(permutationsTexture)
       , fNoiseAccess(noiseTexture)
       , fPaintingData(paintingData) {
@@ -582,7 +580,6 @@ private:
     GrCoordTransform                fCoordTransform;
     int                             fNumOctaves;
     bool                            fStitchTiles;
-    uint8_t                         fAlpha;
     GrTextureAccess                 fPermutationsAccess;
     GrTextureAccess                 fNoiseAccess;
     SkPerlinNoiseShader::PaintingData *fPaintingData;
@@ -594,7 +591,7 @@ private:
 /////////////////////////////////////////////////////////////////////
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrPerlinNoiseEffect);
 
-GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
     int      numOctaves = d->fRandom->nextRangeU(2, 10);
     bool     stitchTiles = d->fRandom->nextBool();
     SkScalar seed = SkIntToScalar(d->fRandom->nextU());
@@ -611,14 +608,12 @@ GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
         SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
                                              stitchTiles ? &tileSize : nullptr);
 
-    SkPaint paint;
-    GrColor paintColor;
     GrFragmentProcessor* effect;
     GrPaint grPaint;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, grPaint.getProcessorDataManager(),
-                                               &effect));
+    return shader->asFragmentProcessor(d->fContext,
+                                       GrTest::TestMatrix(d->fRandom), NULL,
+                                       kNone_SkFilterQuality,
+                                       grPaint.getProcessorDataManager());
 
     delete shader;
 
@@ -639,10 +634,6 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
                                             "baseFrequency");
     const char* baseFrequencyUni = args.fBuilder->getUniformCStr(fBaseFrequencyUni);
-    fAlphaUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kFloat_GrSLType, kDefault_GrSLPrecision,
-                                    "alpha");
-    const char* alphaUni = args.fBuilder->getUniformCStr(fAlphaUni);
 
     const char* stitchDataUni = nullptr;
     if (fStitchTiles) {
@@ -875,8 +866,6 @@ void GrGLPerlinNoise::emitCode(EmitArgs& args) {
                                args.fOutputColor,args.fOutputColor);
     }
 
-    fsBuilder->codeAppendf("\n\t\t%s.a *= %s;", args.fOutputColor, alphaUni);
-
     // Clamp values
     fsBuilder->codeAppendf("\n\t\t%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
 
@@ -920,7 +909,6 @@ void GrGLPerlinNoise::onSetData(const GrGLProgramDataManager& pdman, const GrPro
 
     const SkVector& baseFrequency = turbulence.baseFrequency();
     pdman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY);
-    pdman.set1f(fAlphaUni, SkIntToScalar(turbulence.alpha()) / 255);
 
     if (turbulence.stitchTiles()) {
         const SkPerlinNoiseShader::StitchData& stitchData = turbulence.stitchData();
@@ -930,17 +918,11 @@ void GrGLPerlinNoise::onSetData(const GrGLProgramDataManager& pdman, const GrPro
 }
 
 /////////////////////////////////////////////////////////////////////
-
-bool SkPerlinNoiseShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
-                                              const SkMatrix& viewM,
-                                              const SkMatrix* externalLocalMatrix,
-                                              GrColor* paintColor,
-                                              GrProcessorDataManager* procDataManager,
-                                              GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkPerlinNoiseShader::asFragmentProcessor(GrContext* context,
+    const SkMatrix& viewM, const SkMatrix* externalLocalMatrix, SkFilterQuality,
+    GrProcessorDataManager* procDataManager) const {
     SkASSERT(context);
 
-    *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-
     SkMatrix localMatrix = this->getLocalMatrix();
     if (externalLocalMatrix) {
         localMatrix.preConcat(*externalLocalMatrix);
@@ -951,13 +933,14 @@ bool SkPerlinNoiseShader::asFragmentProcessor(GrContext* context, const SkPaint&
 
     if (0 == fNumOctaves) {
         if (kFractalNoise_Type == fType) {
-            uint32_t alpha = paint.getAlpha() >> 1;
-            uint32_t rgb = alpha >> 1;
-            *paintColor = GrColorPackRGBA(rgb, rgb, rgb, alpha);
-        } else {
-            *paintColor = 0;
+            // Extract the incoming alpha and emit rgba = (a/4, a/4, a/4, a/2)
+            SkAutoTUnref<const GrFragmentProcessor> inner(
+                GrConstColorProcessor::Create(0x80404040,
+                                              GrConstColorProcessor::kModulateRGBA_InputMode));
+            return GrExtractAlphaFragmentProcessor::Create(inner);
         }
-        return true;
+        // Emit zero.
+        return GrConstColorProcessor::Create(0x0, GrConstColorProcessor::kIgnore_InputMode);
     }
 
     // Either we don't stitch tiles, either we have a valid tile size
@@ -974,27 +957,18 @@ bool SkPerlinNoiseShader::asFragmentProcessor(GrContext* context, const SkPaint&
     m.setTranslateX(-localMatrix.getTranslateX() + SK_Scalar1);
     m.setTranslateY(-localMatrix.getTranslateY() + SK_Scalar1);
     if ((permutationsTexture) && (noiseTexture)) {
-        *fp = GrPerlinNoiseEffect::Create(procDataManager,
-                                          fType,
-                                          fNumOctaves,
-                                          fStitchTiles,
-                                          paintingData,
-                                          permutationsTexture, noiseTexture,
-                                          m, paint.getAlpha());
-    } else {
-        delete paintingData;
-        *fp = nullptr;
-    }
-    return true;
-}
-
-#else
-
-bool SkPerlinNoiseShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
-                                              const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                                              GrFragmentProcessor**) const {
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
+        SkAutoTUnref<GrFragmentProcessor> inner(
+            GrPerlinNoiseEffect::Create(procDataManager,
+                                        fType,
+                                        fNumOctaves,
+                                        fStitchTiles,
+                                        paintingData,
+                                        permutationsTexture, noiseTexture,
+                                        m));
+        return GrExtractAlphaFragmentProcessor::Create(inner);
+    }
+    delete paintingData;
+    return nullptr;
 }
 
 #endif
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index f0245b7cfa..1a2b1343b6 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -541,7 +541,7 @@ void ColorTableEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorTableEffect);
 
-GrFragmentProcessor* ColorTableEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* ColorTableEffect::TestCreate(GrProcessorTestData* d) {
     int flags = 0;
     uint8_t luts[256][4];
     do {
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 86142fda73..df27ebcb17 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -439,6 +439,7 @@ void SkLinearGradient::LinearGradientContext::shadeSpan16(int x, int y,
 
 #if SK_SUPPORT_GPU
 
+#include "effects/GrExtractAlphaFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "SkGr.h"
 
@@ -507,7 +508,7 @@ private:
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrLinearGradient);
 
-GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) {
     SkPoint points[] = {{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()},
                         {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}};
 
@@ -519,12 +520,9 @@ GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) {
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points,
                                                                  colors, stops, colorCount,
                                                                  tm));
-    SkPaint paint;
-    GrColor paintColor;
-    GrFragmentProcessor* fp;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }
 
@@ -541,40 +539,29 @@ void GrGLLinearGradient::emitCode(EmitArgs& args) {
 
 /////////////////////////////////////////////////////////////////////
 
-bool SkLinearGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
-                                           const SkMatrix& viewm, const SkMatrix* localMatrix,
-                                           GrColor* paintColor,
-                                           GrProcessorDataManager* procDataManager,
-                                           GrFragmentProcessor** fp)  const {
+const GrFragmentProcessor* SkLinearGradient::asFragmentProcessor(
+    GrContext* context, const SkMatrix& viewm, const SkMatrix* localMatrix, SkFilterQuality,
+    GrProcessorDataManager* procDataManager)  const {
     SkASSERT(context);
 
     SkMatrix matrix;
     if (!this->getLocalMatrix().invert(&matrix)) {
-        return false;
+        return nullptr;
     }
     if (localMatrix) {
         SkMatrix inv;
         if (!localMatrix->invert(&inv)) {
-            return false;
+            return nullptr;
         }
         matrix.postConcat(inv);
     }
     matrix.postConcat(fPtsToUnit);
 
-    *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-    *fp = GrLinearGradient::Create(context, procDataManager, *this, matrix, fTileMode);
-
-    return true;
+    SkAutoTUnref<const GrFragmentProcessor> inner(
+        GrLinearGradient::Create(context, procDataManager, *this, matrix, fTileMode));
+    return GrExtractAlphaFragmentProcessor::Create(inner);
 }
 
-#else
-
-bool SkLinearGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
-                                           const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                                           GrFragmentProcessor**)  const {
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
-}
 
 #endif
 
diff --git a/src/effects/gradients/SkLinearGradient.h b/src/effects/gradients/SkLinearGradient.h
index eddb35512f..a1ae39fb44 100644
--- a/src/effects/gradients/SkLinearGradient.h
+++ b/src/effects/gradients/SkLinearGradient.h
@@ -29,9 +29,10 @@ public:
     };
 
     GradientType asAGradient(GradientInfo* info) const override;
-    bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
-                             const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                             GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+    const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+        const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLinearGradient)
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index c7e7308251..9cd198cf37 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -415,6 +415,7 @@ void SkRadialGradient::RadialGradientContext::shadeSpan(int x, int y,
 #if SK_SUPPORT_GPU
 
 #include "SkGr.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 class GrGLRadialGradient : public GrGLGradientEffect {
@@ -479,7 +480,7 @@ private:
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient);
 
-GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) {
     SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius = d->fRandom->nextUScalar1();
 
@@ -491,12 +492,9 @@ GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) {
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius,
                                                                  colors, stops, colorCount,
                                                                  tm));
-    SkPaint paint;
-    GrColor paintColor;
-    GrFragmentProcessor* fp;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }
 
@@ -514,39 +512,26 @@ void GrGLRadialGradient::emitCode(EmitArgs& args) {
 
 /////////////////////////////////////////////////////////////////////
 
-bool SkRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
-                                           const SkMatrix& viewM,
-                                           const SkMatrix* localMatrix, GrColor* paintColor,
-                                           GrProcessorDataManager* procDataManager,
-                                           GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkRadialGradient::asFragmentProcessor(GrContext* context, 
+    const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality,
+    GrProcessorDataManager* procDataManager) const {
     SkASSERT(context);
 
     SkMatrix matrix;
     if (!this->getLocalMatrix().invert(&matrix)) {
-        return false;
+        return nullptr;
     }
     if (localMatrix) {
         SkMatrix inv;
         if (!localMatrix->invert(&inv)) {
-            return false;
+            return nullptr;
         }
         matrix.postConcat(inv);
     }
     matrix.postConcat(fPtsToUnit);
-
-    *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-    *fp = GrRadialGradient::Create(context, procDataManager, *this, matrix, fTileMode);
-
-    return true;
-}
-
-#else
-
-bool SkRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
-                                           const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                                           GrFragmentProcessor**) const {
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
+        SkAutoTUnref<const GrFragmentProcessor> inner(
+            GrRadialGradient::Create(context, procDataManager, *this, matrix, fTileMode));
+    return GrExtractAlphaFragmentProcessor::Create(inner);
 }
 
 #endif
diff --git a/src/effects/gradients/SkRadialGradient.h b/src/effects/gradients/SkRadialGradient.h
index d0f63ac54d..bc79d92660 100644
--- a/src/effects/gradients/SkRadialGradient.h
+++ b/src/effects/gradients/SkRadialGradient.h
@@ -29,9 +29,10 @@ public:
     };
 
     GradientType asAGradient(GradientInfo* info) const override;
-    bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
-                             const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                             GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+    const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+        const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRadialGradient)
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index c6699e87e0..ae88c8a311 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -167,6 +167,7 @@ void SkSweepGradient::SweepGradientContext::shadeSpan16(int x, int y, uint16_t*
 #if SK_SUPPORT_GPU
 
 #include "SkGr.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 class GrGLSweepGradient : public GrGLGradientEffect {
@@ -226,7 +227,7 @@ private:
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSweepGradient);
 
-GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) {
     SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
 
     SkColor colors[kMaxRandomGradientColors];
@@ -236,12 +237,11 @@ GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) {
     int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tmIgnored);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateSweep(center.fX, center.fY,
                                                                 colors, stops, colorCount));
-    SkPaint paint;
-    GrFragmentProcessor* fp;
-    GrColor paintColor;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+                                                                GrTest::TestMatrix(d->fRandom),
+                                                                NULL, kNone_SkFilterQuality,
+                                                                d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }
 
@@ -270,38 +270,26 @@ void GrGLSweepGradient::emitCode(EmitArgs& args) {
 
 /////////////////////////////////////////////////////////////////////
 
-bool SkSweepGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
-                                          const SkMatrix& viewM,
-                                          const SkMatrix* localMatrix, GrColor* paintColor,
-                                          GrProcessorDataManager* procDataManager,
-                                          GrFragmentProcessor** effect)  const {
+const GrFragmentProcessor* SkSweepGradient::asFragmentProcessor(GrContext* context,
+    const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality,
+    GrProcessorDataManager* procDataManager)  const {
 
     SkMatrix matrix;
     if (!this->getLocalMatrix().invert(&matrix)) {
-        return false;
+        return nullptr;
     }
     if (localMatrix) {
         SkMatrix inv;
         if (!localMatrix->invert(&inv)) {
-            return false;
+            return nullptr;
         }
         matrix.postConcat(inv);
     }
     matrix.postConcat(fPtsToUnit);
 
-    *effect = GrSweepGradient::Create(context, procDataManager, *this, matrix);
-    *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-
-    return true;
-}
-
-#else
-
-bool SkSweepGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
-                                          const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                                          GrFragmentProcessor**)  const {
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
+    SkAutoTUnref<const GrFragmentProcessor> inner(
+        GrSweepGradient::Create(context, procDataManager, *this, matrix));
+    return GrExtractAlphaFragmentProcessor::Create(inner);
 }
 
 #endif
diff --git a/src/effects/gradients/SkSweepGradient.h b/src/effects/gradients/SkSweepGradient.h
index bc465bdc44..8094a48c79 100644
--- a/src/effects/gradients/SkSweepGradient.h
+++ b/src/effects/gradients/SkSweepGradient.h
@@ -30,9 +30,10 @@ public:
 
     GradientType asAGradient(GradientInfo* info) const override;
 
-    bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
-                             const SkMatrix*, GrColor*, GrProcessorDataManager*,
-                             GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+    const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+        const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSweepGradient)
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index 41b5c1bbae..d1fa7b005d 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -359,31 +359,17 @@ void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const {
 #if SK_SUPPORT_GPU
 
 #include "SkGr.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
 
-bool SkTwoPointConicalGradient::asFragmentProcessor(GrContext* context,
-                                                    const SkPaint& paint,
-                                                    const SkMatrix& viewM,
-                                                    const SkMatrix* localMatrix,
-                                                    GrColor* paintColor,
-                                                    GrProcessorDataManager* procDataManager,
-                                                    GrFragmentProcessor** fp)  const {
+const GrFragmentProcessor* SkTwoPointConicalGradient::asFragmentProcessor(GrContext* context,
+    const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality,
+    GrProcessorDataManager* procDataManager)  const {
     SkASSERT(context);
     SkASSERT(fPtsToUnit.isIdentity());
-
-    *fp = Gr2PtConicalGradientEffect::Create(context, procDataManager, *this, fTileMode,
-                                             localMatrix);
-    *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-    return true;
-}
-
-#else
-
-bool SkTwoPointConicalGradient::asFragmentProcessor(GrContext*, const SkPaint&,
-                                                    const SkMatrix&, const SkMatrix*,
-                                                    GrColor*, GrProcessorDataManager*,
-                                                    GrFragmentProcessor**)  const {
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
+    SkAutoTUnref<const GrFragmentProcessor> inner(
+        Gr2PtConicalGradientEffect::Create(context, procDataManager, *this, fTileMode,
+                                            localMatrix));
+    return GrExtractAlphaFragmentProcessor::Create(inner);
 }
 
 #endif
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.h b/src/effects/gradients/SkTwoPointConicalGradient.h
index 8bba9e1b7f..17ed32b018 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.h
+++ b/src/effects/gradients/SkTwoPointConicalGradient.h
@@ -59,9 +59,10 @@ public:
     };
 
     SkShader::GradientType asAGradient(GradientInfo* info) const  override;
-    bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&, const SkMatrix*,
-                             GrColor*, GrProcessorDataManager*,
-                             GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+    const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix&, const SkMatrix*,
+        SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
     bool isOpaque() const override;
 
     SkScalar getCenterX1() const { return SkPoint::Distance(fCenter1, fCenter2); }
diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
index 30f0fdf6a1..c88e75692c 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -183,7 +183,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
-GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = d->fRandom->nextUScalar1();
     SkPoint center2;
@@ -209,12 +209,9 @@ GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
-    SkPaint paint;
-    GrFragmentProcessor* fp;
-    GrColor paintColor;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }
 
@@ -465,7 +462,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
-GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = 0.f;
     SkPoint center2;
@@ -488,15 +485,10 @@ GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestDat
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
-    SkPaint paint;
-    GrFragmentProcessor* effect;
-    GrColor paintColor;
-    GrPaint grPaint;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager,
-                                               &effect));
-    return effect;
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+    GrAlwaysAssert(fp);
+    return fp;
 }
 
 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
@@ -676,7 +668,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
-GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = 0.f;
     SkPoint center2;
@@ -701,12 +693,9 @@ GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
-    SkPaint paint;
-    GrColor paintColor;
-    GrFragmentProcessor* fp;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }
 
@@ -923,8 +912,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
-GrFragmentProcessor*
-CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
@@ -948,12 +936,9 @@ CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
-    SkPaint paint;
-    GrColor paintColor;
-    GrFragmentProcessor* fp;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+        GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }
 
@@ -1154,7 +1139,7 @@ GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
-GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
     SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
     SkPoint center2;
@@ -1179,12 +1164,10 @@ GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestDa
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
-    SkPaint paint;
-    GrColor paintColor;
-    GrFragmentProcessor* fp;
-    SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
-                                               GrTest::TestMatrix(d->fRandom), nullptr,
-                                               &paintColor, d->fProcDataManager, &fp));
+    const GrFragmentProcessor* fp = shader->asFragmentProcessor(
+        d->fContext,GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality,
+        d->fProcDataManager);
+    GrAlwaysAssert(fp);
     return fp;
 }