SkShaderBase

Introduce a private base class (SkShaderBase), to hide
implementation details from the public interface (SkShader).

Change-Id: If3ec26ca6abc9da20e3f139c11fdc023bdd85176
Reviewed-on: https://skia-review.googlesource.com/17241
Commit-Queue: Florin Malita <fmalita@chromium.org>
Reviewed-by: Mike Reed <reed@google.com>

61 files changed, 729 insertions, 664 deletions

diff --git a/bench/SkLinearBitmapPipelineBench.cpp b/bench/SkLinearBitmapPipelineBench.cpp
index 0a867786e6..bbacac7431 100644
--- a/bench/SkLinearBitmapPipelineBench.cpp
+++ b/bench/SkLinearBitmapPipelineBench.cpp
@@ -15,7 +15,7 @@
 #include "SkImage.h"
 #include "SkLinearBitmapPipeline.h"
 #include "SkPM4f.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 struct CommonBitmapFPBenchmark : public Benchmark {
     CommonBitmapFPBenchmark(
@@ -201,10 +201,10 @@ struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark {
         SkAutoTMalloc<SkPMColor> buffer4b(width*height);
 
         SkArenaAlloc alloc{0};
-        const SkShader::ContextRec rec(fPaint, fM, nullptr,
-                                       SkShader::ContextRec::kPMColor_DstType,
-                                       nullptr);
-        SkShader::Context* ctx = fPaint.getShader()->makeContext(rec, &alloc);
+        const SkShaderBase::ContextRec rec(fPaint, fM, nullptr,
+                                           SkShaderBase::ContextRec::kPMColor_DstType,
+                                           nullptr);
+        SkShaderBase::Context* ctx = as_SB(fPaint.getShader())->makeContext(rec, &alloc);
 
         int count = 100;
 
diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
index 88ed0f10bf..1ebee2ef73 100644
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
@@ -564,8 +564,8 @@ SkPMColor SkPerlinNoiseShader2::PerlinNoiseShaderContext::shade(
     return SkPreMultiplyARGB(rgba[3], rgba[0], rgba[1], rgba[2]);
 }
 
-SkShader::Context* SkPerlinNoiseShader2::onMakeContext(const ContextRec& rec,
-                                                       SkArenaAlloc* alloc) const {
+SkShaderBase::Context* SkPerlinNoiseShader2::onMakeContext(const ContextRec& rec,
+                                                           SkArenaAlloc* alloc) const {
     return alloc->make<PerlinNoiseShaderContext>(*this, rec);
 }
 
@@ -719,7 +719,7 @@ sk_sp<GrFragmentProcessor> GrPerlinNoise2Effect::TestCreate(GrProcessorTestData*
                                              stitchTiles ? &tileSize : nullptr));
 
     GrTest::TestAsFPArgs asFPArgs(d);
-    return shader->asFragmentProcessor(asFPArgs.args());
+    return as_SB(shader)->asFragmentProcessor(asFPArgs.args());
 }
 #endif
 
@@ -1126,7 +1126,7 @@ sk_sp<GrFragmentProcessor> GrImprovedPerlinNoiseEffect::TestCreate(GrProcessorTe
                                                                    z));
 
     GrTest::TestAsFPArgs asFPArgs(d);
-    return shader->asFragmentProcessor(asFPArgs.args());
+    return as_SB(shader)->asFragmentProcessor(asFPArgs.args());
 }
 #endif
 
diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h
index 0f40ae4af3..8a46a326d9 100644
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.h
@@ -8,7 +8,7 @@
 #ifndef SkPerlinNoiseShader2_DEFINED
 #define SkPerlinNoiseShader2_DEFINED
 
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 /** \class SkPerlinNoiseShader2
 
@@ -22,7 +22,7 @@
     The algorithm used is described here :
     http://www.w3.org/TR/SVG/filters.html#feTurbulenceElement
 */
-class SK_API SkPerlinNoiseShader2 : public SkShader {
+class SK_API SkPerlinNoiseShader2 : public SkShaderBase {
 public:
     struct StitchData;
     struct PaintingData;
@@ -83,7 +83,7 @@ public:
         return MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize);
     }
 
-    class PerlinNoiseShaderContext : public SkShader::Context {
+    class PerlinNoiseShaderContext : public Context {
     public:
         PerlinNoiseShaderContext(const SkPerlinNoiseShader2& shader, const ContextRec&);
         ~PerlinNoiseShaderContext() override;
@@ -102,7 +102,7 @@ public:
         SkMatrix fMatrix;
         PaintingData* fPaintingData;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
 #if SK_SUPPORT_GPU
@@ -130,7 +130,7 @@ private:
     const SkISize                   fTileSize;
     const bool                      fStitchTiles;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/gm/SkLinearBitmapPipelineGM.cpp b/gm/SkLinearBitmapPipelineGM.cpp
index f07d2f7efe..87566ad43e 100644
--- a/gm/SkLinearBitmapPipelineGM.cpp
+++ b/gm/SkLinearBitmapPipelineGM.cpp
@@ -16,7 +16,7 @@
 #include "SkLinearBitmapPipeline.h"
 #include "SkXfermodePriv.h"
 #include "SkPM4fPriv.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 static void fill_in_bits(SkBitmap& bm, SkIRect ir, SkColor c, bool premul) {
     bm.allocN32Pixels(ir.width(), ir.height());
@@ -72,11 +72,11 @@ static void draw_rect_orig(SkCanvas* canvas, const SkRect& r, SkColor c, const S
         paint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
     }
     paint.setShader(std::move(shader));
-    const SkShader::ContextRec rec(paint, *mat, nullptr,
-                                   SkBlitter::PreferredShaderDest(pmsrc.info()),
-                                   canvas->imageInfo().colorSpace());
+    const SkShaderBase::ContextRec rec(paint, *mat, nullptr,
+                                       SkBlitter::PreferredShaderDest(pmsrc.info()),
+                                       canvas->imageInfo().colorSpace());
 
-    SkShader::Context* ctx = paint.getShader()->makeContext(rec, &alloc);
+    SkShaderBase::Context* ctx = as_SB(paint.getShader())->makeContext(rec, &alloc);
 
     for (int y = 0; y < ir.height(); y++) {
         ctx->shadeSpan(0, y, pmdst.writable_addr32(0, y), ir.width());
diff --git a/gn/core.gni b/gn/core.gni
index 5566ddebdd..9dfc47826b 100644
--- a/gn/core.gni
+++ b/gn/core.gni
@@ -302,6 +302,7 @@ skia_core_sources = [
   "$_src/core/SkScan_Path.cpp",
   "$_src/core/SkSemaphore.cpp",
   "$_src/core/SkShader.cpp",
+  "$_src/core/SkShaderBase.h",
   "$_src/core/SkSharedMutex.cpp",
   "$_src/core/SkSharedMutex.h",
   "$_src/core/SkSinglyLinkedList.h",
diff --git a/include/core/SkFlattenable.h b/include/core/SkFlattenable.h
index 88aeb7ee38..49c491eb20 100644
--- a/include/core/SkFlattenable.h
+++ b/include/core/SkFlattenable.h
@@ -78,7 +78,7 @@ public:
         kSkPathEffect_Type,
         kSkPixelRef_Type,
         kSkRasterizer_Type,
-        kSkShader_Type,
+        kSkShaderBase_Type,
         kSkUnused_Type,     // used to be SkUnitMapper
         kSkXfermode_Type,
         kSkNormalSource_Type,
diff --git a/include/core/SkShader.h b/include/core/SkShader.h
index 260306cfd4..20898574e0 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -40,17 +40,6 @@ class GrFragmentProcessor;
  */
 class SK_API SkShader : public SkFlattenable {
 public:
-    SkShader(const SkMatrix* localMatrix = NULL);
-    ~SkShader() override;
-
-    /**
-     *  Returns the local matrix.
-     *
-     *  FIXME: This can be incorrect for a Shader with its own local matrix
-     *  that is also wrapped via CreateLocalMatrixShader.
-     */
-    const SkMatrix& getLocalMatrix() const { return fLocalMatrix; }
-
     enum TileMode {
         /** replicate the edge color if the shader draws outside of its
          *  original bounds
@@ -75,23 +64,13 @@ public:
         kTileModeCount = kMirror_TileMode + 1
     };
 
-    // override these in your subclass
-
-    enum Flags {
-        //!< set if all of the colors will be opaque
-        kOpaqueAlpha_Flag = 1 << 0,
-
-        /** set if the spans only vary in X (const in Y).
-            e.g. an Nx1 bitmap that is being tiled in Y, or a linear-gradient
-            that varies from left-to-right. This flag specifies this for
-            shadeSpan().
-         */
-        kConstInY32_Flag = 1 << 1,
-
-        /** hint for the blitter that 4f is the preferred shading mode.
-         */
-        kPrefers4f_Flag  = 1 << 2,
-    };
+    /**
+     *  Returns the local matrix.
+     *
+     *  FIXME: This can be incorrect for a Shader with its own local matrix
+     *  that is also wrapped via CreateLocalMatrixShader.
+     */
+    const SkMatrix& getLocalMatrix() const;
 
     /**
      *  Returns true if the shader is guaranteed to produce only opaque
@@ -101,150 +80,13 @@ public:
      */
     virtual bool isOpaque() const { return false; }
 
-    /**
-     *  Returns true if the shader is guaranteed to produce only a single color.
-     *  Subclasses can override this to allow loop-hoisting optimization.
-     */
-    virtual bool isConstant() const { return false; }
-
-    /**
-     *  ContextRec acts as a parameter bundle for creating Contexts.
-     */
-    struct ContextRec {
-        enum DstType {
-            kPMColor_DstType, // clients prefer shading into PMColor dest
-            kPM4f_DstType,    // clients prefer shading into PM4f dest
-        };
-
-        ContextRec(const SkPaint& paint, const SkMatrix& matrix, const SkMatrix* localM,
-                   DstType dstType, SkColorSpace* dstColorSpace)
-            : fPaint(&paint)
-            , fMatrix(&matrix)
-            , fLocalMatrix(localM)
-            , fPreferredDstType(dstType)
-            , fDstColorSpace(dstColorSpace) {}
-
-        const SkPaint*  fPaint;            // the current paint associated with the draw
-        const SkMatrix* fMatrix;           // the current matrix in the canvas
-        const SkMatrix* fLocalMatrix;      // optional local matrix
-        const DstType   fPreferredDstType; // the "natural" client dest type
-        SkColorSpace*   fDstColorSpace;    // the color space of the dest surface (if any)
-    };
-
-    class Context : public ::SkNoncopyable {
-    public:
-        Context(const SkShader& shader, const ContextRec&);
-
-        virtual ~Context();
-
-        /**
-         *  Called sometimes before drawing with this shader. Return the type of
-         *  alpha your shader will return. The default implementation returns 0.
-         *  Your subclass should override if it can (even sometimes) report a
-         *  non-zero value, since that will enable various blitters to perform
-         *  faster.
-         */
-        virtual uint32_t getFlags() const { return 0; }
-
-        /**
-         *  Called for each span of the object being drawn. Your subclass should
-         *  set the appropriate colors (with premultiplied alpha) that correspond
-         *  to the specified device coordinates.
-         */
-        virtual void shadeSpan(int x, int y, SkPMColor[], int count) = 0;
-
-        virtual void shadeSpan4f(int x, int y, SkPM4f[], int count);
-
-        struct BlitState;
-        typedef void (*BlitBW)(BlitState*,
-                               int x, int y, const SkPixmap&, int count);
-        typedef void (*BlitAA)(BlitState*,
-                               int x, int y, const SkPixmap&, int count, const SkAlpha[]);
-
-        struct BlitState {
-            // inputs
-            Context*    fCtx;
-            SkBlendMode fMode;
-
-            // outputs
-            enum { N = 2 };
-            void*       fStorage[N];
-            BlitBW      fBlitBW;
-            BlitAA      fBlitAA;
-        };
-
-        // Returns true if one or more of the blitprocs are set in the BlitState
-        bool chooseBlitProcs(const SkImageInfo& info, BlitState* state) {
-            state->fBlitBW = nullptr;
-            state->fBlitAA = nullptr;
-            if (this->onChooseBlitProcs(info, state)) {
-                SkASSERT(state->fBlitBW || state->fBlitAA);
-                return true;
-            }
-            return false;
-        }
-
-        /**
-         * The const void* ctx is only const because all the implementations are const.
-         * This can be changed to non-const if a new shade proc needs to change the ctx.
-         */
-        typedef void (*ShadeProc)(const void* ctx, int x, int y, SkPMColor[], int count);
-        virtual ShadeProc asAShadeProc(void** ctx);
-
-        /**
-         *  Similar to shadeSpan, but only returns the alpha-channel for a span.
-         *  The default implementation calls shadeSpan() and then extracts the alpha
-         *  values from the returned colors.
-         */
-        virtual void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count);
-
-        // Notification from blitter::blitMask in case we need to see the non-alpha channels
-        virtual void set3DMask(const SkMask*) {}
-
-    protected:
-        // Reference to shader, so we don't have to dupe information.
-        const SkShader& fShader;
-
-        enum MatrixClass {
-            kLinear_MatrixClass,            // no perspective
-            kFixedStepInX_MatrixClass,      // fast perspective, need to call fixedStepInX() each
-                                            // scanline
-            kPerspective_MatrixClass        // slow perspective, need to mappoints each pixel
-        };
-        static MatrixClass ComputeMatrixClass(const SkMatrix&);
-
-        uint8_t         getPaintAlpha() const { return fPaintAlpha; }
-        const SkMatrix& getTotalInverse() const { return fTotalInverse; }
-        MatrixClass     getInverseClass() const { return (MatrixClass)fTotalInverseClass; }
-        const SkMatrix& getCTM() const { return fCTM; }
-
-        virtual bool onChooseBlitProcs(const SkImageInfo&, BlitState*) { return false; }
-
-    private:
-        SkMatrix    fCTM;
-        SkMatrix    fTotalInverse;
-        uint8_t     fPaintAlpha;
-        uint8_t     fTotalInverseClass;
-
-        typedef SkNoncopyable INHERITED;
-    };
-
-    /**
-     * Make a context using the memory provided by the arena.
-     *
-     * @return pointer to context or nullptr if can't be created
-     */
-    Context* makeContext(const ContextRec&, SkArenaAlloc*) const;
-
 #ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP
     /**
      *  Returns true if this shader is just a bitmap, and if not null, returns the bitmap,
      *  localMatrix, and tilemodes. If this is not a bitmap, returns false and ignores the
      *  out-parameters.
      */
-    bool isABitmap(SkBitmap* outTexture, SkMatrix* outMatrix, TileMode xy[2]) const {
-        return this->onIsABitmap(outTexture, outMatrix, xy);
-    }
+    bool isABitmap(SkBitmap* outTexture, SkMatrix* outMatrix, TileMode xy[2]) const;
 
     bool isABitmap() const {
         return this->isABitmap(nullptr, nullptr, nullptr);
@@ -255,9 +97,7 @@ public:
      *  Iff this shader is backed by a single SkImage, return its ptr (the caller must ref this
      *  if they want to keep it longer than the lifetime of the shader). If not, return nullptr.
      */
-    SkImage* isAImage(SkMatrix* localMatrix, TileMode xy[2]) const {
-        return this->onIsAImage(localMatrix, xy);
-    }
+    SkImage* isAImage(SkMatrix* localMatrix, TileMode xy[2]) const;
 
     bool isAImage() const {
         return this->isAImage(nullptr, nullptr) != nullptr;
@@ -317,68 +157,6 @@ public:
 
     virtual GradientType asAGradient(GradientInfo* info) const;
 
-    /**
-     *  If the shader subclass is composed of two shaders, return true, and if rec is not NULL,
-     *  fill it out with info about the shader.
-     *
-     *  These are bare pointers; the ownership and reference count are unchanged.
-     */
-
-    struct ComposeRec {
-        const SkShader*     fShaderA;
-        const SkShader*     fShaderB;
-        SkBlendMode         fBlendMode;
-    };
-
-    virtual bool asACompose(ComposeRec*) const { return false; }
-
-#if SK_SUPPORT_GPU
-    struct AsFPArgs {
-        AsFPArgs() {}
-        AsFPArgs(GrContext* context,
-                 const SkMatrix* viewMatrix,
-                 const SkMatrix* localMatrix,
-                 SkFilterQuality filterQuality,
-                 SkColorSpace* dstColorSpace)
-            : fContext(context)
-            , fViewMatrix(viewMatrix)
-            , fLocalMatrix(localMatrix)
-            , fFilterQuality(filterQuality)
-            , fDstColorSpace(dstColorSpace) {}
-
-        GrContext*                    fContext;
-        const SkMatrix*               fViewMatrix;
-        const SkMatrix*               fLocalMatrix;
-        SkFilterQuality               fFilterQuality;
-        SkColorSpace*                 fDstColorSpace;
-    };
-
-    /**
-     *  Returns a GrFragmentProcessor that implements the shader for the GPU backend. NULL is
-     *  returned if there is no GPU implementation.
-     *
-     *  The GPU device does not call SkShader::createContext(), instead we pass the view matrix,
-     *  local matrix, and filter quality directly.
-     *
-     *  The GrContext may be used by the to create textures that are required by the returned
-     *  processor.
-     *
-     *  The returned GrFragmentProcessor should expect an unpremultiplied input color and
-     *  produce a premultiplied output.
-     */
-    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const;
-#endif
-
-    /**
-     *  If the shader can represent its "average" luminance in a single color, return true and
-     *  if color is not NULL, return that color. If it cannot, return false and ignore the color
-     *  parameter.
-     *
-     *  Note: if this returns true, the returned color will always be opaque, as only the RGB
-     *  components are used to compute luminance.
-     */
-    bool asLuminanceColor(SkColor*) const;
-
     //////////////////////////////////////////////////////////////////////////
     //  Methods to create combinations or variants of shaders
 
@@ -454,73 +232,10 @@ public:
     static sk_sp<SkShader> MakePictureShader(sk_sp<SkPicture> src, TileMode tmx, TileMode tmy,
                                              const SkMatrix* localMatrix, const SkRect* tile);
 
-    /**
-     *  If this shader can be represented by another shader + a localMatrix, return that shader and
-     *  the localMatrix. If not, return nullptr and ignore the localMatrix parameter.
-     */
-    virtual sk_sp<SkShader> makeAsALocalMatrixShader(SkMatrix* localMatrix) const;
-
-    SK_TO_STRING_VIRT()
-    SK_DEFINE_FLATTENABLE_TYPE(SkShader)
-    SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
-
-    bool appendStages(SkRasterPipeline*, SkColorSpace* dstCS, SkArenaAlloc*,
-                      const SkMatrix& ctm, const SkPaint&, const SkMatrix* localM=nullptr) const;
-
 protected:
-    void flatten(SkWriteBuffer&) const override;
-
-    bool computeTotalInverse(const SkMatrix& ctm,
-                             const SkMatrix* outerLocalMatrix,
-                             SkMatrix* totalInverse) const;
-
-    /**
-     * Specialize creating a SkShader context using the supplied allocator.
-     * @return pointer to context owned by the arena allocator.
-     */
-    virtual Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const {
-        return nullptr;
-    }
-
-    virtual bool onAsLuminanceColor(SkColor*) const {
-        return false;
-    }
-
-#ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP
-    virtual bool onIsABitmap(SkBitmap*, SkMatrix*, TileMode[2]) const {
-        return false;
-    }
-#endif
-
-    virtual SkImage* onIsAImage(SkMatrix*, TileMode[2]) const {
-        return nullptr;
-    }
-
-    /**
-     *  Returns a shader transformed into a new color space via the |xformer|.
-     */
-    sk_sp<SkShader> makeColorSpace(SkColorSpaceXformer* xformer) const {
-        return this->onMakeColorSpace(xformer);
-    }
-    virtual sk_sp<SkShader> onMakeColorSpace(SkColorSpaceXformer*) const {
-        return sk_ref_sp(const_cast<SkShader*>(this));
-    }
-
-    virtual bool isRasterPipelineOnly() const { return false; }
+    SkShader() = default;
 
 private:
-    virtual bool onAppendStages(SkRasterPipeline*, SkColorSpace* dstCS, SkArenaAlloc*,
-                                const SkMatrix&, const SkPaint&, const SkMatrix* localM) const;
-
-    // This is essentially const, but not officially so it can be modified in constructors.
-    SkMatrix fLocalMatrix;
-
-    friend class SkLocalMatrixShader;         // sets fLocalMatrix in SkReadBuffer constructor
-    friend class SkBitmapProcLegacyShader;    // calls computeTotalInverse()
-    friend class SkColorSpaceXformer;         // calls makeColorSpace()
-    friend class SkBlitter;                   // calls isRasterPipelineOnly()
-    friend class SkComposeShader;             // calls isRasterPipelineOnly()
-
     typedef SkFlattenable INHERITED;
 };
 
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index b7bd39c197..e52982354d 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -17,21 +17,21 @@ static bool only_scale_and_translate(const SkMatrix& matrix) {
     return (matrix.getType() & ~mask) == 0;
 }
 
-class BitmapProcInfoContext : public SkShader::Context {
+class BitmapProcInfoContext : public SkShaderBase::Context {
 public:
     // The info has been allocated elsewhere, but we are responsible for calling its destructor.
-    BitmapProcInfoContext(const SkShader& shader, const SkShader::ContextRec& rec,
+    BitmapProcInfoContext(const SkShaderBase& shader, const SkShaderBase::ContextRec& rec,
                             SkBitmapProcInfo* info)
         : INHERITED(shader, rec)
         , fInfo(info)
     {
         fFlags = 0;
         if (fInfo->fPixmap.isOpaque() && (255 == this->getPaintAlpha())) {
-            fFlags |= SkShader::kOpaqueAlpha_Flag;
+            fFlags |= SkShaderBase::kOpaqueAlpha_Flag;
         }
 
         if (1 == fInfo->fPixmap.height() && only_scale_and_translate(this->getTotalInverse())) {
-            fFlags |= SkShader::kConstInY32_Flag;
+            fFlags |= SkShaderBase::kConstInY32_Flag;
         }
     }
 
@@ -41,14 +41,14 @@ private:
     SkBitmapProcInfo*   fInfo;
     uint32_t            fFlags;
 
-    typedef SkShader::Context INHERITED;
+    typedef SkShaderBase::Context INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class BitmapProcShaderContext : public BitmapProcInfoContext {
 public:
-    BitmapProcShaderContext(const SkShader& shader, const SkShader::ContextRec& rec,
+    BitmapProcShaderContext(const SkShaderBase& shader, const SkShaderBase::ContextRec& rec,
                             SkBitmapProcState* state)
         : INHERITED(shader, rec, state)
         , fState(state)
@@ -104,7 +104,7 @@ private:
 
 class LinearPipelineContext : public BitmapProcInfoContext {
 public:
-    LinearPipelineContext(const SkShader& shader, const SkShader::ContextRec& rec,
+    LinearPipelineContext(const SkShaderBase& shader, const SkShaderBase::ContextRec& rec,
                           SkBitmapProcInfo* info, SkArenaAlloc* alloc)
         : INHERITED(shader, rec, info), fAllocator{alloc}
     {
@@ -183,12 +183,12 @@ private:
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static bool choose_linear_pipeline(const SkShader::ContextRec& rec, const SkImageInfo& srcInfo) {
+static bool choose_linear_pipeline(const SkShaderBase::ContextRec& rec, const SkImageInfo& srcInfo) {
     // If we get here, we can reasonably use either context, respect the caller's preference
     //
     bool needsPremul = srcInfo.alphaType() == kUnpremul_SkAlphaType;
     bool needsSwizzle = srcInfo.bytesPerPixel() == 4 && srcInfo.colorType() != kN32_SkColorType;
-    return SkShader::ContextRec::kPM4f_DstType == rec.fPreferredDstType
+    return SkShaderBase::ContextRec::kPM4f_DstType == rec.fPreferredDstType
            || needsPremul || needsSwizzle;
 }
 
@@ -199,8 +199,8 @@ size_t SkBitmapProcLegacyShader::ContextSize(const ContextRec& rec, const SkImag
     return s;
 }
 
-SkShader::Context* SkBitmapProcLegacyShader::MakeContext(
-    const SkShader& shader, TileMode tmx, TileMode tmy,
+SkShaderBase::Context* SkBitmapProcLegacyShader::MakeContext(
+    const SkShaderBase& shader, TileMode tmx, TileMode tmy,
     const SkBitmapProvider& provider, const ContextRec& rec, SkArenaAlloc* alloc)
 {
     SkMatrix totalInverse;
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 204b27dd4c..2a2599cb1d 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -8,19 +8,19 @@
 #define SkBitmapProcShader_DEFINED
 
 #include "SkImagePriv.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SkBitmapProvider;
 
-class SkBitmapProcLegacyShader : public SkShader {
+class SkBitmapProcLegacyShader : public SkShaderBase {
 private:
     friend class SkImageShader;
 
     static size_t ContextSize(const ContextRec&, const SkImageInfo& srcInfo);
-    static Context* MakeContext(const SkShader&, TileMode tmx, TileMode tmy,
+    static Context* MakeContext(const SkShaderBase&, TileMode tmx, TileMode tmy,
                                 const SkBitmapProvider&, const ContextRec&, SkArenaAlloc* alloc);
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 30f845ac06..ba79abd3f0 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -14,6 +14,7 @@
 #include "SkWriteBuffer.h"
 #include "SkMask.h"
 #include "SkMaskFilter.h"
+#include "SkShaderBase.h"
 #include "SkString.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
@@ -582,14 +583,14 @@ SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip,
 #include "SkColorShader.h"
 #include "SkColorPriv.h"
 
-class Sk3DShader : public SkShader {
+class Sk3DShader : public SkShaderBase {
 public:
     Sk3DShader(sk_sp<SkShader> proxy) : fProxy(std::move(proxy)) {}
 
     Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const override {
-        SkShader::Context* proxyContext = nullptr;
+        SkShaderBase::Context* proxyContext = nullptr;
         if (fProxy) {
-            proxyContext = fProxy->makeContext(rec, alloc);
+            proxyContext = as_SB(fProxy)->makeContext(rec, alloc);
             if (!proxyContext) {
                 return nullptr;
             }
@@ -597,11 +598,11 @@ public:
         return alloc->make<Sk3DShaderContext>(*this, rec, proxyContext);
     }
 
-    class Sk3DShaderContext : public SkShader::Context {
+    class Sk3DShaderContext : public Context {
     public:
         // Calls proxyContext's destructor but will NOT free its memory.
         Sk3DShaderContext(const Sk3DShader& shader, const ContextRec& rec,
-                          SkShader::Context* proxyContext)
+                          Context* proxyContext)
             : INHERITED(shader, rec)
             , fMask(nullptr)
             , fProxyContext(proxyContext)
@@ -685,12 +686,12 @@ public:
 
     private:
         // Unowned.
-        const SkMask*       fMask;
+        const SkMask* fMask;
         // Memory is unowned, but we need to call the destructor.
-        SkShader::Context*  fProxyContext;
-        SkPMColor           fPMColor;
+        Context*      fProxyContext;
+        SkPMColor     fPMColor;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
 #ifndef SK_IGNORE_TO_STRING
@@ -699,7 +700,7 @@ public:
 
         if (fProxy) {
             str->append("Proxy: ");
-            fProxy->toString(str);
+            as_SB(fProxy)->toString(str);
         }
 
         this->INHERITED::toString(str);
@@ -718,7 +719,7 @@ protected:
 private:
     sk_sp<SkShader> fProxy;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 sk_sp<SkFlattenable> Sk3DShader::CreateProc(SkReadBuffer& buffer) {
@@ -727,7 +728,7 @@ sk_sp<SkFlattenable> Sk3DShader::CreateProc(SkReadBuffer& buffer) {
 
 class Sk3DBlitter : public SkBlitter {
 public:
-    Sk3DBlitter(SkBlitter* proxy, SkShader::Context* shaderContext)
+    Sk3DBlitter(SkBlitter* proxy, SkShaderBase::Context* shaderContext)
         : fProxy(proxy)
         , fShaderContext(shaderContext)
     {}
@@ -764,21 +765,21 @@ public:
 
 private:
     // Both pointers are unowned. They will be deleted by SkSmallAllocator.
-    SkBlitter*          fProxy;
-    SkShader::Context*  fShaderContext;
+    SkBlitter*              fProxy;
+    SkShaderBase::Context*  fShaderContext;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkCoreBlitters.h"
 
-SkShader::ContextRec::DstType SkBlitter::PreferredShaderDest(const SkImageInfo& dstInfo) {
+SkShaderBase::ContextRec::DstType SkBlitter::PreferredShaderDest(const SkImageInfo& dstInfo) {
 #ifdef SK_FORCE_PM4f_FOR_L32_BLITS
     return SkShader::ContextRec::kPM4f_DstType;
 #else
     return (dstInfo.gammaCloseToSRGB() || dstInfo.colorType() == kRGBA_F16_SkColorType)
-            ? SkShader::ContextRec::kPM4f_DstType
-            : SkShader::ContextRec::kPMColor_DstType;
+            ? SkShaderBase::ContextRec::kPM4f_DstType
+            : SkShaderBase::ContextRec::kPMColor_DstType;
 #endif
 }
 
@@ -792,7 +793,7 @@ bool SkBlitter::UseRasterPipelineBlitter(const SkPixmap& device, const SkPaint&
     }
 
     // ... unless the shader is raster pipeline-only.
-    if (paint.getShader() && paint.getShader()->isRasterPipelineOnly()) {
+    if (paint.getShader() && as_SB(paint.getShader())->isRasterPipelineOnly()) {
         return true;
     }
 
@@ -814,7 +815,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
         return alloc->make<SkNullBlitter>();
     }
 
-    SkShader* shader = origPaint.getShader();
+    auto* shader = as_SB(origPaint.getShader());
     SkColorFilter* cf = origPaint.getColorFilter();
     SkBlendMode mode = origPaint.getBlendMode();
     sk_sp<Sk3DShader> shader3D;
@@ -826,7 +827,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
         shader3D = sk_make_sp<Sk3DShader>(sk_ref_sp(shader));
         // we know we haven't initialized lazyPaint yet, so just do it
         paint.writable()->setShader(shader3D);
-        shader = shader3D.get();
+        shader = as_SB(shader3D.get());
     }
 
     if (mode != SkBlendMode::kSrcOver) {
@@ -876,7 +877,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
             // xfermodes (and filters) require shaders for our current blitters
             paint.writable()->setShader(SkShader::MakeColorShader(paint->getColor()));
             paint.writable()->setAlpha(0xFF);
-            shader = paint->getShader();
+            shader = as_SB(paint->getShader());
         } else if (cf) {
             // if no shader && no xfermode, we just apply the colorfilter to
             // our color and move on.
@@ -890,7 +891,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     if (cf) {
         SkASSERT(shader);
         paint.writable()->setShader(shader->makeWithColorFilter(sk_ref_sp(cf)));
-        shader = paint->getShader();
+        shader = as_SB(paint->getShader());
         // blitters should ignore the presence/absence of a filter, since
         // if there is one, the shader will take care of it.
     }
@@ -898,9 +899,9 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     /*
      *  We create a SkShader::Context object, and store it on the blitter.
      */
-    SkShader::Context* shaderContext = nullptr;
+    SkShaderBase::Context* shaderContext = nullptr;
     if (shader) {
-        const SkShader::ContextRec rec(*paint, matrix, nullptr,
+        const SkShaderBase::ContextRec rec(*paint, matrix, nullptr,
                                        PreferredShaderDest(device.info()),
                                        device.colorSpace());
         // Try to create the ShaderContext
@@ -974,7 +975,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
 ///////////////////////////////////////////////////////////////////////////////
 
 SkShaderBlitter::SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
-                                 SkShader::Context* shaderContext)
+                                 SkShaderBase::Context* shaderContext)
         : INHERITED(device)
         , fShader(paint.getShader())
         , fShaderContext(shaderContext) {
@@ -983,7 +984,7 @@ SkShaderBlitter::SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
 
     fShader->ref();
     fShaderFlags = fShaderContext->getFlags();
-    fConstInY = SkToBool(fShaderFlags & SkShader::kConstInY32_Flag);
+    fConstInY = SkToBool(fShaderFlags & SkShaderBase::kConstInY32_Flag);
 }
 
 SkShaderBlitter::~SkShaderBlitter() {
diff --git a/src/core/SkBlitter.h b/src/core/SkBlitter.h
index 27552b918f..6558045f4f 100644
--- a/src/core/SkBlitter.h
+++ b/src/core/SkBlitter.h
@@ -13,7 +13,7 @@
 #include "SkColor.h"
 #include "SkRect.h"
 #include "SkRegion.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SkArenaAlloc;
 class SkMatrix;
@@ -148,7 +148,7 @@ public:
                                    SkArenaAlloc*);
     ///@}
 
-    static SkShader::ContextRec::DstType PreferredShaderDest(const SkImageInfo&);
+    static SkShaderBase::ContextRec::DstType PreferredShaderDest(const SkImageInfo&);
 
     static bool UseRasterPipelineBlitter(const SkPixmap&, const SkPaint&);
 
diff --git a/src/core/SkBlitter_A8.cpp b/src/core/SkBlitter_A8.cpp
index 1fd4d5f0d9..6f0df2ef26 100644
--- a/src/core/SkBlitter_A8.cpp
+++ b/src/core/SkBlitter_A8.cpp
@@ -227,7 +227,7 @@ void SkA8_Blitter::blitRect(int x, int y, int width, int height) {
 ///////////////////////////////////////////////////////////////////////
 
 SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                                         SkShader::Context* shaderContext)
+                                         SkShaderBase::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
     fXfermode = SkXfermode::Peek(paint.getBlendMode());
@@ -247,9 +247,9 @@ void SkA8_Shader_Blitter::blitH(int x, int y, int width) {
              (unsigned)(x + width) <= (unsigned)fDevice.width());
 
     uint8_t* device = fDevice.writable_addr8(x, y);
-    SkShader::Context* shaderContext = fShaderContext;
+    auto* shaderContext = fShaderContext;
 
-    if ((shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) {
+    if ((shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag) && !fXfermode) {
         memset(device, 0xFF, width);
     } else {
         SkPMColor*  span = fBuffer;
@@ -280,12 +280,12 @@ static inline uint8_t aa_blend8(SkPMColor src, U8CPU da, int aa) {
 
 void SkA8_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                     const int16_t runs[]) {
-    SkShader::Context* shaderContext = fShaderContext;
+    auto* shaderContext = fShaderContext;
     SkXfermode*        mode = fXfermode;
     uint8_t*           aaExpand = fAAExpand;
     SkPMColor*         span = fBuffer;
     uint8_t*           device = fDevice.writable_addr8(x, y);
-    int                opaque = shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag;
+    int                opaque = shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag;
 
     for (;;) {
         int count = *runs;
@@ -327,7 +327,7 @@ void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
     int height = clip.height();
     uint8_t* device = fDevice.writable_addr8(x, y);
     const uint8_t* alpha = mask.getAddr8(x, y);
-    SkShader::Context* shaderContext = fShaderContext;
+    auto* shaderContext = fShaderContext;
 
     SkPMColor*  span = fBuffer;
 
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index 4478b2bd64..aef1044a94 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -330,7 +330,7 @@ static void blend_srcmode(SkPMColor* SK_RESTRICT device,
 }
 
 SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
-        const SkPaint& paint, SkShader::Context* shaderContext)
+        const SkPaint& paint, SkShaderBase::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
     fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * (sizeof(SkPMColor)));
@@ -338,7 +338,7 @@ SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
     fXfermode = SkXfermode::Peek(paint.getBlendMode());
 
     int flags = 0;
-    if (!(shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag)) {
+    if (!(shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag)) {
         flags |= SkBlitRow::kSrcPixelAlpha_Flag32;
     }
     // we call this on the output from the shader
@@ -348,7 +348,7 @@ SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
 
     fShadeDirectlyIntoDevice = false;
     if (fXfermode == nullptr) {
-        if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
+        if (shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag) {
             fShadeDirectlyIntoDevice = true;
         }
     } else {
@@ -361,7 +361,7 @@ SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
         }
     }
 
-    fConstInY = SkToBool(shaderContext->getFlags() & SkShader::kConstInY32_Flag);
+    fConstInY = SkToBool(shaderContext->getFlags() & SkShaderBase::kConstInY32_Flag);
 }
 
 SkARGB32_Shader_Blitter::~SkARGB32_Shader_Blitter() {
@@ -390,10 +390,10 @@ void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x >= 0 && y >= 0 &&
              x + width <= fDevice.width() && y + height <= fDevice.height());
 
-    uint32_t*          device = fDevice.writable_addr32(x, y);
-    size_t             deviceRB = fDevice.rowBytes();
-    SkShader::Context* shaderContext = fShaderContext;
-    SkPMColor*         span = fBuffer;
+    uint32_t*  device = fDevice.writable_addr32(x, y);
+    size_t     deviceRB = fDevice.rowBytes();
+    auto*      shaderContext = fShaderContext;
+    SkPMColor* span = fBuffer;
 
     if (fConstInY) {
         if (fShadeDirectlyIntoDevice) {
@@ -427,7 +427,7 @@ void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) {
 
     if (fShadeDirectlyIntoDevice) {
         void* ctx;
-        SkShader::Context::ShadeProc shadeProc = shaderContext->asAShadeProc(&ctx);
+        auto shadeProc = shaderContext->asAShadeProc(&ctx);
         if (shadeProc) {
             do {
                 shadeProc(ctx, x, y, device, width);
@@ -464,9 +464,9 @@ void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) {
 
 void SkARGB32_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                         const int16_t runs[]) {
-    SkPMColor*         span = fBuffer;
-    uint32_t*          device = fDevice.writable_addr32(x, y);
-    SkShader::Context* shaderContext = fShaderContext;
+    SkPMColor* span = fBuffer;
+    uint32_t*  device = fDevice.writable_addr32(x, y);
+    auto*      shaderContext = fShaderContext;
 
     if (fXfermode && !fShadeDirectlyIntoDevice) {
         for (;;) {
@@ -493,7 +493,7 @@ void SkARGB32_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
             x += count;
         }
     } else if (fShadeDirectlyIntoDevice ||
-               (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag)) {
+               (shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag)) {
         for (;;) {
             int count = *runs;
             if (count <= 0) {
@@ -546,11 +546,11 @@ void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip)
 
     SkASSERT(mask.fBounds.contains(clip));
 
-    SkShader::Context*  shaderContext = fShaderContext;
+    auto* shaderContext = fShaderContext;
     SkBlitMask::RowProc proc = nullptr;
     if (!fXfermode) {
         unsigned flags = 0;
-        if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
+        if (shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag) {
             flags |= SkBlitMask::kSrcIsOpaque_RowFlag;
         }
         proc = SkBlitMask::RowFactory(kN32_SkColorType, mask.fFormat,
@@ -597,9 +597,9 @@ void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip)
 void SkARGB32_Shader_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
     SkASSERT(x >= 0 && y >= 0 && y + height <= fDevice.height());
 
-    uint32_t*          device = fDevice.writable_addr32(x, y);
-    size_t             deviceRB = fDevice.rowBytes();
-    SkShader::Context* shaderContext = fShaderContext;
+    uint32_t* device = fDevice.writable_addr32(x, y);
+    size_t    deviceRB = fDevice.rowBytes();
+    auto*     shaderContext = fShaderContext;
 
     if (fConstInY) {
         SkPMColor c;
@@ -637,7 +637,7 @@ void SkARGB32_Shader_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
 
     if (fShadeDirectlyIntoDevice) {
         void* ctx;
-        SkShader::Context::ShadeProc shadeProc = shaderContext->asAShadeProc(&ctx);
+        auto shadeProc = shaderContext->asAShadeProc(&ctx);
         if (255 == alpha) {
             if (shadeProc) {
                 do {
diff --git a/src/core/SkBlitter_PM4f.cpp b/src/core/SkBlitter_PM4f.cpp
index 61105ce2db..f83e0c214e 100644
--- a/src/core/SkBlitter_PM4f.cpp
+++ b/src/core/SkBlitter_PM4f.cpp
@@ -139,7 +139,7 @@ public:
 template <typename State> class SkState_Shader_Blitter : public SkShaderBlitter {
 public:
     SkState_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                           const SkShader::Context::BlitState& bstate)
+                           const SkShaderBase::Context::BlitState& bstate)
         : INHERITED(device, paint, bstate.fCtx)
         , fState(device.info(), paint, bstate.fCtx)
         , fBState(bstate)
@@ -309,10 +309,10 @@ public:
     }
 
 protected:
-    State                        fState;
-    SkShader::Context::BlitState fBState;
-    SkShader::Context::BlitBW    fBlitBW;
-    SkShader::Context::BlitAA    fBlitAA;
+    State                            fState;
+    SkShaderBase::Context::BlitState fBState;
+    SkShaderBase::Context::BlitBW    fBlitBW;
+    SkShaderBase::Context::BlitAA    fBlitAA;
 
     typedef SkShaderBlitter INHERITED;
 };
@@ -320,13 +320,14 @@ protected:
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static bool is_opaque(const SkPaint& paint, const SkShader::Context* shaderContext) {
-    return shaderContext ? SkToBool(shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag)
+static bool is_opaque(const SkPaint& paint, const SkShaderBase::Context* shaderContext) {
+    return shaderContext ? SkToBool(shaderContext->getFlags() & SkShaderBase::kOpaqueAlpha_Flag)
     : 0xFF == paint.getAlpha();
 }
 
 struct State4f {
-    State4f(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext) {
+    State4f(const SkImageInfo& info, const SkPaint& paint,
+            const SkShaderBase::Context* shaderContext) {
         fMode = paint.getBlendMode();
         if (shaderContext) {
             fBuffer.reset(info.width());
@@ -336,12 +337,11 @@ struct State4f {
         fFlags = 0;
     }
 
-    SkPM4f                  fPM4f;
-    SkAutoTMalloc<SkPM4f>   fBuffer;
-    uint32_t                fFlags;
-    SkBlendMode             fMode;
-
-    SkShader::Context::BlitState fBState;
+    SkPM4f                           fPM4f;
+    SkAutoTMalloc<SkPM4f>            fBuffer;
+    uint32_t                         fFlags;
+    SkBlendMode                      fMode;
+    SkShaderBase::Context::BlitState fBState;
 };
 
 struct State32 : State4f {
@@ -350,7 +350,8 @@ struct State32 : State4f {
     SkXfermode::D32Proc fProc1;
     SkXfermode::D32Proc fProcN;
 
-    State32(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
+    State32(const SkImageInfo& info, const SkPaint& paint,
+            const SkShaderBase::Context* shaderContext)
         : State4f(info, paint, shaderContext)
     {
         if (is_opaque(paint, shaderContext)) {
@@ -382,7 +383,8 @@ struct StateF16 : State4f {
     SkXfermode::F16Proc fProc1;
     SkXfermode::F16Proc fProcN;
 
-    StateF16(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
+    StateF16(const SkImageInfo& info, const SkPaint& paint,
+             const SkShaderBase::Context* shaderContext)
         : State4f(info, paint, shaderContext)
     {
         if (is_opaque(paint, shaderContext)) {
@@ -404,12 +406,12 @@ struct StateF16 : State4f {
 };
 
 template <typename State> SkBlitter* create(const SkPixmap& device, const SkPaint& paint,
-                                            SkShader::Context* shaderContext,
+                                            SkShaderBase::Context* shaderContext,
                                             SkArenaAlloc* alloc) {
     SkASSERT(alloc != nullptr);
 
     if (shaderContext) {
-        SkShader::Context::BlitState bstate;
+        SkShaderBase::Context::BlitState bstate;
         sk_bzero(&bstate, sizeof(bstate));
         bstate.fCtx = shaderContext;
         bstate.fMode = paint.getBlendMode();
@@ -426,13 +428,13 @@ template <typename State> SkBlitter* create(const SkPixmap& device, const SkPain
 }
 
 SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint& paint,
-                                   SkShader::Context* shaderContext,
+                                   SkShaderBase::Context* shaderContext,
                                    SkArenaAlloc* alloc) {
     return create<State32>(device, paint, shaderContext, alloc);
 }
 
 SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint& paint,
-                                SkShader::Context* shaderContext,
+                                SkShaderBase::Context* shaderContext,
                                 SkArenaAlloc* alloc) {
     return create<StateF16>(device, paint, shaderContext, alloc);
 }
diff --git a/src/core/SkBlitter_RGB16.cpp b/src/core/SkBlitter_RGB16.cpp
index 6330a39357..2c7fbf76da 100644
--- a/src/core/SkBlitter_RGB16.cpp
+++ b/src/core/SkBlitter_RGB16.cpp
@@ -110,7 +110,7 @@ private:
 class SkRGB16_Shader_Blitter : public SkShaderBlitter {
 public:
     SkRGB16_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                           SkShader::Context* shaderContext);
+                           SkShaderBase::Context* shaderContext);
     ~SkRGB16_Shader_Blitter() override;
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
@@ -132,7 +132,7 @@ private:
 class SkRGB16_Shader_Xfermode_Blitter : public SkShaderBlitter {
 public:
     SkRGB16_Shader_Xfermode_Blitter(const SkPixmap& device, const SkPaint& paint,
-                                    SkShader::Context* shaderContext);
+                                    SkShaderBase::Context* shaderContext);
     ~SkRGB16_Shader_Xfermode_Blitter() override;
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
@@ -671,7 +671,7 @@ void SkRGB16_Blitter::blitRect(int x, int y, int width, int height) {
 
 SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device,
                                                const SkPaint& paint,
-                                               SkShader::Context* shaderContext)
+                                               SkShaderBase::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
     SkASSERT(paint.isSrcOver());
@@ -683,7 +683,7 @@ SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device,
 
     uint32_t shaderFlags = fShaderFlags;
     // shaders take care of global alpha, so we never set it in SkBlitRow
-    if (!(shaderFlags & SkShader::kOpaqueAlpha_Flag)) {
+    if (!(shaderFlags & SkShaderBase::kOpaqueAlpha_Flag)) {
         flags |= SkBlitRow::kSrcPixelAlpha_Flag;
     }
     if (paint.isDither()) {
@@ -708,13 +708,13 @@ void SkRGB16_Shader_Blitter::blitH(int x, int y, int width) {
 }
 
 void SkRGB16_Shader_Blitter::blitRect(int x, int y, int width, int height) {
-    SkShader::Context* shaderContext = fShaderContext;
+    auto* shaderContext = fShaderContext;
     SkBlitRow::Proc16  proc = fOpaqueProc;
     SkPMColor*         buffer = fBuffer;
     uint16_t*          dst = fDevice.writable_addr16(x, y);
     size_t             dstRB = fDevice.rowBytes();
 
-    if (fShaderFlags & SkShader::kConstInY32_Flag) {
+    if (fShaderFlags & SkShaderBase::kConstInY32_Flag) {
         shaderContext->shadeSpan(x, y, buffer, width);
         do {
             proc(dst, buffer, width, 0xFF, x, y);
@@ -748,7 +748,7 @@ static inline int count_nonzero_span(const int16_t runs[], const SkAlpha aa[]) {
 void SkRGB16_Shader_Blitter::blitAntiH(int x, int y,
                                        const SkAlpha* SK_RESTRICT antialias,
                                        const int16_t* SK_RESTRICT runs) {
-    SkShader::Context*     shaderContext = fShaderContext;
+    auto*     shaderContext = fShaderContext;
     SkPMColor* SK_RESTRICT span = fBuffer;
     uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
 
@@ -797,7 +797,7 @@ void SkRGB16_Shader_Blitter::blitAntiH(int x, int y,
 
 SkRGB16_Shader_Xfermode_Blitter::SkRGB16_Shader_Xfermode_Blitter(
                                 const SkPixmap& device, const SkPaint& paint,
-                                SkShader::Context* shaderContext)
+                                SkShaderBase::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
     fXfermode = SkXfermode::Peek(paint.getBlendMode());
@@ -825,7 +825,7 @@ void SkRGB16_Shader_Xfermode_Blitter::blitH(int x, int y, int width) {
 void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y,
                                 const SkAlpha* SK_RESTRICT antialias,
                                 const int16_t* SK_RESTRICT runs) {
-    SkShader::Context*     shaderContext = fShaderContext;
+    auto*     shaderContext = fShaderContext;
     SkXfermode*            mode = fXfermode;
     SkPMColor* SK_RESTRICT span = fBuffer;
     uint8_t* SK_RESTRICT   aaExpand = fAAExpand;
@@ -880,7 +880,7 @@ void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y,
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
-        SkShader::Context* shaderContext,
+        SkShaderBase::Context* shaderContext,
         SkArenaAlloc* alloc) {
     SkASSERT(alloc != nullptr);
 
diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp
index 6569e1379a..4798422dfa 100644
--- a/src/core/SkColorFilterShader.cpp
+++ b/src/core/SkColorFilterShader.cpp
@@ -49,14 +49,14 @@ uint32_t SkColorFilterShader::FilterShaderContext::getFlags() const {
     // in the shader flags.
     //
     if (!(filterF & SkColorFilter::kAlphaUnchanged_Flag)) {
-        shaderF &= ~SkShader::kOpaqueAlpha_Flag;
+        shaderF &= ~kOpaqueAlpha_Flag;
     }
     return shaderF;
 }
 
-SkShader::Context* SkColorFilterShader::onMakeContext(const ContextRec& rec,
-                                                      SkArenaAlloc* alloc) const {
-    SkShader::Context* shaderContext = fShader->makeContext(rec, alloc);
+SkShaderBase::Context* SkColorFilterShader::onMakeContext(const ContextRec& rec,
+                                                          SkArenaAlloc* alloc) const {
+    auto* shaderContext = as_SB(fShader)->makeContext(rec, alloc);
     if (nullptr == shaderContext) {
         return nullptr;
     }
@@ -69,7 +69,7 @@ sk_sp<SkShader> SkColorFilterShader::onMakeColorSpace(SkColorSpaceXformer* xform
 
 SkColorFilterShader::FilterShaderContext::FilterShaderContext(
                                                          const SkColorFilterShader& filterShader,
-                                                         SkShader::Context* shaderContext,
+                                                         SkShaderBase::Context* shaderContext,
                                                          const ContextRec& rec)
     : INHERITED(filterShader, rec)
     , fShaderContext(shaderContext)
@@ -96,7 +96,7 @@ void SkColorFilterShader::FilterShaderContext::shadeSpan4f(int x, int y, SkPM4f
 
 sk_sp<GrFragmentProcessor> SkColorFilterShader::asFragmentProcessor(const AsFPArgs& args) const {
 
-    sk_sp<GrFragmentProcessor> fp1(fShader->asFragmentProcessor(args));
+    sk_sp<GrFragmentProcessor> fp1(as_SB(fShader)->asFragmentProcessor(args));
     if (!fp1) {
         return nullptr;
     }
@@ -117,7 +117,7 @@ void SkColorFilterShader::toString(SkString* str) const {
     str->append("SkColorFilterShader: (");
 
     str->append("Shader: ");
-    fShader->toString(str);
+    as_SB(fShader)->toString(str);
     str->append(" Filter: ");
     // TODO: add "fFilter->toString(str);" once SkColorFilter::toString is added
 
diff --git a/src/core/SkColorFilterShader.h b/src/core/SkColorFilterShader.h
index 18f65ba67f..7f4202158a 100644
--- a/src/core/SkColorFilterShader.h
+++ b/src/core/SkColorFilterShader.h
@@ -9,11 +9,11 @@
 #define SkColorFilterShader_DEFINED
 
 #include "SkColorFilter.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SkArenaAlloc;
 
-class SkColorFilterShader : public SkShader {
+class SkColorFilterShader : public SkShaderBase {
 public:
     SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter);
 
@@ -21,10 +21,10 @@ public:
     sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
 #endif
 
-    class FilterShaderContext : public SkShader::Context {
+    class FilterShaderContext : public Context {
     public:
         // Takes ownership of shaderContext and calls its destructor.
-        FilterShaderContext(const SkColorFilterShader&, SkShader::Context*, const ContextRec&);
+        FilterShaderContext(const SkColorFilterShader&, SkShaderBase::Context*, const ContextRec&);
 
         uint32_t getFlags() const override;
 
@@ -37,9 +37,9 @@ public:
         }
 
     private:
-        SkShader::Context* fShaderContext;
+        SkShaderBase::Context* fShaderContext;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     SK_TO_STRING_OVERRIDE()
@@ -54,7 +54,7 @@ private:
     sk_sp<SkShader>      fShader;
     sk_sp<SkColorFilter> fFilter;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/src/core/SkColorShader.cpp b/src/core/SkColorShader.cpp
index 94d1abc6f0..32b2c54d71 100644
--- a/src/core/SkColorShader.cpp
+++ b/src/core/SkColorShader.cpp
@@ -31,7 +31,8 @@ uint32_t SkColorShader::ColorShaderContext::getFlags() const {
     return fFlags;
 }
 
-SkShader::Context* SkColorShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
+SkShaderBase::Context* SkColorShader::onMakeContext(const ContextRec& rec,
+                                                    SkArenaAlloc* alloc) const {
     return alloc->make<ColorShaderContext>(*this, rec);
 }
 
@@ -149,7 +150,8 @@ uint32_t SkColor4Shader::Color4Context::getFlags() const {
     return fFlags;
 }
 
-SkShader::Context* SkColor4Shader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
+SkShaderBase::Context* SkColor4Shader::onMakeContext(const ContextRec& rec,
+                                                     SkArenaAlloc* alloc) const {
     return alloc->make<Color4Context>(*this, rec);
 }
 
@@ -250,28 +252,28 @@ sk_sp<SkShader> SkShader::MakeColorShader(const SkColor4f& color, sk_sp<SkColorS
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static void D32_BlitBW(SkShader::Context::BlitState* state, int x, int y, const SkPixmap& dst,
+static void D32_BlitBW(SkShaderBase::Context::BlitState* state, int x, int y, const SkPixmap& dst,
                        int count) {
     SkXfermode::D32Proc proc = (SkXfermode::D32Proc)state->fStorage[0];
     const SkPM4f* src = (const SkPM4f*)state->fStorage[1];
     proc(state->fMode, dst.writable_addr32(x, y), src, count, nullptr);
 }
 
-static void D32_BlitAA(SkShader::Context::BlitState* state, int x, int y, const SkPixmap& dst,
+static void D32_BlitAA(SkShaderBase::Context::BlitState* state, int x, int y, const SkPixmap& dst,
                        int count, const SkAlpha aa[]) {
     SkXfermode::D32Proc proc = (SkXfermode::D32Proc)state->fStorage[0];
     const SkPM4f* src = (const SkPM4f*)state->fStorage[1];
     proc(state->fMode, dst.writable_addr32(x, y), src, count, aa);
 }
 
-static void F16_BlitBW(SkShader::Context::BlitState* state, int x, int y, const SkPixmap& dst,
+static void F16_BlitBW(SkShaderBase::Context::BlitState* state, int x, int y, const SkPixmap& dst,
                        int count) {
     SkXfermode::F16Proc proc = (SkXfermode::F16Proc)state->fStorage[0];
     const SkPM4f* src = (const SkPM4f*)state->fStorage[1];
     proc(state->fMode, dst.writable_addr64(x, y), src, count, nullptr);
 }
 
-static void F16_BlitAA(SkShader::Context::BlitState* state, int x, int y, const SkPixmap& dst,
+static void F16_BlitAA(SkShaderBase::Context::BlitState* state, int x, int y, const SkPixmap& dst,
                        int count, const SkAlpha aa[]) {
     SkXfermode::F16Proc proc = (SkXfermode::F16Proc)state->fStorage[0];
     const SkPM4f* src = (const SkPM4f*)state->fStorage[1];
@@ -279,7 +281,7 @@ static void F16_BlitAA(SkShader::Context::BlitState* state, int x, int y, const
 }
 
 static bool choose_blitprocs(const SkPM4f* pm4, const SkImageInfo& info,
-                             SkShader::Context::BlitState* state) {
+                             SkShaderBase::Context::BlitState* state) {
     uint32_t flags = SkXfermode::kSrcIsSingle_D32Flag;
     if (pm4->a() == 1) {
         flags |= SkXfermode::kSrcIsOpaque_D32Flag;
diff --git a/src/core/SkColorShader.h b/src/core/SkColorShader.h
index 0a6a935afd..9af83c1163 100644
--- a/src/core/SkColorShader.h
+++ b/src/core/SkColorShader.h
@@ -9,7 +9,7 @@
 #define SkColorShader_DEFINED
 
 #include "SkColorSpaceXformer.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkPM4f.h"
 
 /** \class SkColorShader
@@ -17,7 +17,7 @@
     accomplished by just using the color field on the paint, but if an
     actual shader object is needed, this provides that feature.
 */
-class SK_API SkColorShader : public SkShader {
+class SK_API SkColorShader : public SkShaderBase {
 public:
     /** Create a ColorShader that ignores the color in the paint, and uses the
         specified color. Note: like all shaders, at draw time the paint's alpha
@@ -28,7 +28,7 @@ public:
     bool isOpaque() const override;
     bool isConstant() const override { return true; }
 
-    class ColorShaderContext : public SkShader::Context {
+    class ColorShaderContext : public Context {
     public:
         ColorShaderContext(const SkColorShader& shader, const ContextRec&);
 
@@ -45,7 +45,7 @@ public:
         SkPMColor   fPMColor;
         uint32_t    fFlags;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     GradientType asAGradient(GradientInfo* info) const override;
@@ -77,10 +77,10 @@ protected:
 private:
     SkColor fColor;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
-class SkColor4Shader : public SkShader {
+class SkColor4Shader : public SkShaderBase {
 public:
     SkColor4Shader(const SkColor4f&, sk_sp<SkColorSpace>);
 
@@ -89,7 +89,7 @@ public:
     }
     bool isConstant() const override { return true; }
 
-    class Color4Context : public SkShader::Context {
+    class Color4Context : public Context {
     public:
         Color4Context(const SkColor4Shader& shader, const ContextRec&);
 
@@ -106,7 +106,7 @@ public:
         SkPMColor   fPMColor;
         uint32_t    fFlags;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     GradientType asAGradient(GradientInfo* info) const override;
@@ -136,7 +136,7 @@ private:
     const SkColor4f     fColor4;
     const SkColor       fCachedByteColor;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/src/core/SkColorSpaceXformer.cpp b/src/core/SkColorSpaceXformer.cpp
index f5f22a18b1..74daf661eb 100644
--- a/src/core/SkColorSpaceXformer.cpp
+++ b/src/core/SkColorSpaceXformer.cpp
@@ -14,6 +14,7 @@
 #include "SkImageFilter.h"
 #include "SkImagePriv.h"
 #include "SkMakeUnique.h"
+#include "SkShaderBase.h"
 
 std::unique_ptr<SkColorSpaceXformer> SkColorSpaceXformer::Make(sk_sp<SkColorSpace> dst) {
     std::unique_ptr<SkColorSpaceXform> fromSRGB = SkColorSpaceXform_Base::New(
@@ -53,7 +54,7 @@ sk_sp<SkImageFilter> SkColorSpaceXformer::apply(const SkImageFilter* imageFilter
 }
 
 sk_sp<SkShader> SkColorSpaceXformer::apply(const SkShader* shader) {
-    return shader->makeColorSpace(this);
+    return as_SB(shader)->makeColorSpace(this);
 }
 
 void SkColorSpaceXformer::apply(SkColor* xformed, const SkColor* srgb, int n) {
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 942c2931d2..7735494291 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -72,7 +72,7 @@ void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
     buffer.write32((int)fMode);
 }
 
-SkShader::Context* SkComposeShader::onMakeContext(
+SkShaderBase::Context* SkComposeShader::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const
 {
     // we preconcat our localMatrix (if any) with the device matrix
@@ -90,8 +90,8 @@ SkShader::Context* SkComposeShader::onMakeContext(
     newRec.fMatrix = &tmpM;
     newRec.fPaint = &opaquePaint;
 
-    SkShader::Context* contextA = fShaderA->makeContext(newRec, alloc);
-    SkShader::Context* contextB = fShaderB->makeContext(newRec, alloc);
+    SkShaderBase::Context* contextA = as_SB(fShaderA)->makeContext(newRec, alloc);
+    SkShaderBase::Context* contextB = as_SB(fShaderB)->makeContext(newRec, alloc);
     if (!contextA || !contextB) {
         return nullptr;
     }
@@ -106,7 +106,7 @@ sk_sp<SkShader> SkComposeShader::onMakeColorSpace(SkColorSpaceXformer* xformer)
 
 SkComposeShader::ComposeShaderContext::ComposeShaderContext(
         const SkComposeShader& shader, const ContextRec& rec,
-        SkShader::Context* contextA, SkShader::Context* contextB)
+        SkShaderBase::Context* contextA, SkShaderBase::Context* contextB)
     : INHERITED(shader, rec)
     , fShaderContextA(contextA)
     , fShaderContextB(contextB) {}
@@ -121,7 +121,7 @@ bool SkComposeShader::asACompose(ComposeRec* rec) const {
 }
 
 bool SkComposeShader::isRasterPipelineOnly() const {
-    return fShaderA->isRasterPipelineOnly() || fShaderB->isRasterPipelineOnly();
+    return as_SB(fShaderA)->isRasterPipelineOnly() || as_SB(fShaderB)->isRasterPipelineOnly();
 }
 
 bool SkComposeShader::onAppendStages(SkRasterPipeline* pipeline, SkColorSpace* dstCS,
@@ -138,7 +138,7 @@ bool SkComposeShader::onAppendStages(SkRasterPipeline* pipeline, SkColorSpace* d
     // will be smashed, and I'll need them again for fShaderB. store_rgba saves off 4 registers
     // even though we only need to save r,g.
     pipeline->append(SkRasterPipeline::store_rgba, storage->fXY);
-    if (!fShaderB->appendStages(pipeline, dstCS, alloc, ctm, paint, localM)) { // SRC
+    if (!as_SB(fShaderB)->appendStages(pipeline, dstCS, alloc, ctm, paint, localM)) { // SRC
         return false;
     }
     // This outputs r,g,b,a, which we'll need later when we apply the mode, but we save it off now
@@ -146,7 +146,7 @@ bool SkComposeShader::onAppendStages(SkRasterPipeline* pipeline, SkColorSpace* d
     pipeline->append(SkRasterPipeline::store_rgba, storage->fRGBA);
     // Now we restore the device x,y for the next shader
     pipeline->append(SkRasterPipeline::load_rgba, storage->fXY);
-    if (!fShaderA->appendStages(pipeline, dstCS, alloc, ctm, paint, localM)) {  // DST
+    if (!as_SB(fShaderA)->appendStages(pipeline, dstCS, alloc, ctm, paint, localM)) {  // DST
         return false;
     }
     // We now have our logical 'dst' in r,g,b,a, but we need it in dr,dg,db,da for the mode
@@ -169,8 +169,8 @@ bool SkComposeShader::onAppendStages(SkRasterPipeline* pipeline, SkColorSpace* d
 #define TMP_COLOR_COUNT     64
 
 void SkComposeShader::ComposeShaderContext::shadeSpan(int x, int y, SkPMColor result[], int count) {
-    SkShader::Context* shaderContextA = fShaderContextA;
-    SkShader::Context* shaderContextB = fShaderContextB;
+    auto* shaderContextA = fShaderContextA;
+    auto* shaderContextB = fShaderContextB;
     SkBlendMode        mode = static_cast<const SkComposeShader&>(fShader).fMode;
     unsigned           scale = SkAlpha255To256(this->getPaintAlpha());
 
@@ -229,8 +229,8 @@ void SkComposeShader::ComposeShaderContext::shadeSpan(int x, int y, SkPMColor re
 }
 
 void SkComposeShader::ComposeShaderContext::shadeSpan4f(int x, int y, SkPM4f result[], int count) {
-    SkShader::Context* shaderContextA = fShaderContextA;
-    SkShader::Context* shaderContextB = fShaderContextB;
+    auto* shaderContextA = fShaderContextA;
+    auto* shaderContextB = fShaderContextB;
     SkBlendMode        mode = static_cast<const SkComposeShader&>(fShader).fMode;
     unsigned           alpha = this->getPaintAlpha();
     Sk4f               scale(alpha * (1.0f / 255));
@@ -272,17 +272,17 @@ sk_sp<GrFragmentProcessor> SkComposeShader::asFragmentProcessor(const AsFPArgs&
                                                GrConstColorProcessor::kIgnore_InputMode);
             break;
         case SkBlendMode::kSrc:
-            return fShaderB->asFragmentProcessor(args);
+            return as_SB(fShaderB)->asFragmentProcessor(args);
             break;
         case SkBlendMode::kDst:
-            return fShaderA->asFragmentProcessor(args);
+            return as_SB(fShaderA)->asFragmentProcessor(args);
             break;
         default:
-            sk_sp<GrFragmentProcessor> fpA(fShaderA->asFragmentProcessor(args));
+            sk_sp<GrFragmentProcessor> fpA(as_SB(fShaderA)->asFragmentProcessor(args));
             if (!fpA) {
                 return nullptr;
             }
-            sk_sp<GrFragmentProcessor> fpB(fShaderB->asFragmentProcessor(args));
+            sk_sp<GrFragmentProcessor> fpB(as_SB(fShaderB)->asFragmentProcessor(args));
             if (!fpB) {
                 return nullptr;
             }
@@ -297,9 +297,9 @@ void SkComposeShader::toString(SkString* str) const {
     str->append("SkComposeShader: (");
 
     str->append("ShaderA: ");
-    fShaderA->toString(str);
+    as_SB(fShaderA)->toString(str);
     str->append(" ShaderB: ");
-    fShaderB->toString(str);
+    as_SB(fShaderB)->toString(str);
     if (SkBlendMode::kSrcOver != fMode) {
         str->appendf(" Xfermode: %s", SkXfermode::ModeName(fMode));
     }
diff --git a/src/core/SkComposeShader.h b/src/core/SkComposeShader.h
index d3f8c9dc27..8592f3a8ae 100644
--- a/src/core/SkComposeShader.h
+++ b/src/core/SkComposeShader.h
@@ -8,7 +8,7 @@
 #ifndef SkComposeShader_DEFINED
 #define SkComposeShader_DEFINED
 
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkBlendMode.h"
 
 class SkColorSpacXformer;
@@ -19,7 +19,7 @@ class SkColorSpacXformer;
     This subclass of shader returns the composition of two other shaders, combined by
     a xfermode.
 */
-class SK_API SkComposeShader : public SkShader {
+class SK_API SkComposeShader : public SkShaderBase {
 public:
     /** Create a new compose shader, given shaders A, B, and a combining xfermode mode.
         When the xfermode is called, it will be given the result from shader A as its
@@ -40,21 +40,21 @@ public:
     sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
 #endif
 
-    class ComposeShaderContext : public SkShader::Context {
+    class ComposeShaderContext : public Context {
     public:
         // When this object gets destroyed, it will call contextA and contextB's destructor
         // but it will NOT free the memory.
         ComposeShaderContext(const SkComposeShader&, const ContextRec&,
-                             SkShader::Context* contextA, SkShader::Context* contextB);
+                             SkShaderBase::Context* contextA, SkShaderBase::Context* contextB);
 
         void shadeSpan(int x, int y, SkPMColor[], int count) override;
         void shadeSpan4f(int x, int y, SkPM4f[], int count) override;
 
     private:
-        SkShader::Context* fShaderContextA;
-        SkShader::Context* fShaderContextB;
+        SkShaderBase::Context* fShaderContextA;
+        SkShaderBase::Context* fShaderContextB;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
 #ifdef SK_DEBUG
@@ -82,7 +82,7 @@ private:
     sk_sp<SkShader>     fShaderB;
     SkBlendMode         fMode;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 8dfeb7486a..7f3de32ab1 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -11,7 +11,7 @@
 #include "SkBitmapProcShader.h"
 #include "SkBlitter.h"
 #include "SkBlitRow.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkXfermodePriv.h"
 
 class SkRasterBlitter : public SkBlitter {
@@ -33,14 +33,14 @@ public:
       *  exchange that object.
       */
     SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
-                    SkShader::Context* shaderContext);
+                    SkShaderBase::Context* shaderContext);
     virtual ~SkShaderBlitter();
 
 protected:
-    uint32_t            fShaderFlags;
-    const SkShader*     fShader;
-    SkShader::Context*  fShaderContext;
-    bool                fConstInY;
+    uint32_t                fShaderFlags;
+    const SkShader*         fShader;
+    SkShaderBase::Context*  fShaderContext;
+    bool                    fConstInY;
 
 private:
     // illegal
@@ -84,7 +84,7 @@ private:
 class SkA8_Shader_Blitter : public SkShaderBlitter {
 public:
     SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                        SkShader::Context* shaderContext);
+                        SkShaderBase::Context* shaderContext);
     ~SkA8_Shader_Blitter() override;
     void blitH(int x, int y, int width) override;
     void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) override;
@@ -155,7 +155,7 @@ private:
 class SkARGB32_Shader_Blitter : public SkShaderBlitter {
 public:
     SkARGB32_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
-                            SkShader::Context* shaderContext);
+                            SkShaderBase::Context* shaderContext);
     ~SkARGB32_Shader_Blitter() override;
     void blitH(int x, int y, int width) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
@@ -176,10 +176,10 @@ private:
     typedef SkShaderBlitter INHERITED;
 };
 
-SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint&, SkShader::Context*,
+SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint&, SkShaderBase::Context*,
                                    SkArenaAlloc*);
 
-SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint&, SkShader::Context*,
+SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint&, SkShaderBase::Context*,
                                 SkArenaAlloc*);
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -198,7 +198,7 @@ SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint&, SkShader
  */
 
 SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
-                                SkShader::Context* shaderContext,
+                                SkShaderBase::Context* shaderContext,
                                 SkArenaAlloc* allocator);
 
 
diff --git a/src/core/SkDraw_vertices.cpp b/src/core/SkDraw_vertices.cpp
index 125ab7a9ce..7720acc088 100644
--- a/src/core/SkDraw_vertices.cpp
+++ b/src/core/SkDraw_vertices.cpp
@@ -13,7 +13,7 @@
 #include "SkPM4fPriv.h"
 #include "SkRasterClip.h"
 #include "SkScan.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkString.h"
 #include "SkVertState.h"
 
@@ -69,7 +69,7 @@ static bool texture_to_matrix(const VertState& state, const SkPoint verts[],
     return matrix->setPolyToPoly(src, dst, 3);
 }
 
-class SkTriColorShader : public SkShader {
+class SkTriColorShader : public SkShaderBase {
 public:
     SkTriColorShader(bool isOpaque) : fIsOpaque(isOpaque) {}
 
@@ -102,7 +102,7 @@ private:
     Matrix43 fM43;
     const bool fIsOpaque;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/core/SkEmptyShader.h b/src/core/SkEmptyShader.h
index b2c9b76792..c1bcfe0957 100644
--- a/src/core/SkEmptyShader.h
+++ b/src/core/SkEmptyShader.h
@@ -8,7 +8,7 @@
 #ifndef SkEmptyShader_DEFINED
 #define SkEmptyShader_DEFINED
 
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 // TODO: move this to private, as there is a public factory on SkShader
 
@@ -16,7 +16,7 @@
  *  \class SkEmptyShader
  *  A Shader that always draws nothing. Its createContext always returns nullptr.
  */
-class SK_API SkEmptyShader : public SkShader {
+class SK_API SkEmptyShader : public SkShaderBase {
 public:
     SkEmptyShader() {}
 
@@ -24,7 +24,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmptyShader)
 
 protected:
-    SkShader::Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override {
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override {
         return nullptr;
     }
 
@@ -35,7 +35,7 @@ protected:
     }
 
 private:
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/src/core/SkGlobalInitialization_core.cpp b/src/core/SkGlobalInitialization_core.cpp
index 298357eb78..9fa128f987 100644
--- a/src/core/SkGlobalInitialization_core.cpp
+++ b/src/core/SkGlobalInitialization_core.cpp
@@ -19,6 +19,7 @@
 #include "SkPathEffect.h"
 #include "SkPictureShader.h"
 #include "SkRecordedDrawable.h"
+#include "SkShaderBase.h"
 
 /*
  *  Registers all of the required effects subclasses for picture deserialization.
@@ -42,7 +43,7 @@ void SkFlattenable::PrivateInitializer::InitCore() {
 
     SkColorFilter::InitializeFlattenables();
     SkPathEffect::InitializeFlattenables();
-    SkShader::InitializeFlattenables();
+    SkShaderBase::InitializeFlattenables();
     SkXfermode::InitializeFlattenables();
 
     // Drawable
diff --git a/src/core/SkLightingShader.cpp b/src/core/SkLightingShader.cpp
index ca370b0a3a..cdfa528e1e 100644
--- a/src/core/SkLightingShader.cpp
+++ b/src/core/SkLightingShader.cpp
@@ -16,6 +16,7 @@
 #include "SkNormalSource.h"
 #include "SkPoint3.h"
 #include "SkReadBuffer.h"
+#include "SkShaderBase.h"
 #include "SkWriteBuffer.h"
 
 ////////////////////////////////////////////////////////////////////////////
@@ -36,7 +37,7 @@
 /** \class SkLightingShaderImpl
     This subclass of shader applies lighting.
 */
-class SkLightingShaderImpl : public SkShader {
+class SkLightingShaderImpl : public SkShaderBase {
 public:
     /** Create a new lighting shader that uses the provided normal map and
         lights to light the diffuse bitmap.
@@ -57,12 +58,12 @@ public:
     sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const override;
 #endif
 
-    class LightingShaderContext : public SkShader::Context {
+    class LightingShaderContext : public Context {
     public:
         // The context takes ownership of the context and provider. It will call their destructors
         // and then indirectly free their memory by calling free() on heapAllocated
         LightingShaderContext(const SkLightingShaderImpl&, const ContextRec&,
-                              SkShader::Context* diffuseContext, SkNormalSource::Provider*,
+                              SkShaderBase::Context* diffuseContext, SkNormalSource::Provider*,
                               void* heapAllocated);
 
         void shadeSpan(int x, int y, SkPMColor[], int count) override;
@@ -70,12 +71,12 @@ public:
         uint32_t getFlags() const override { return fFlags; }
 
     private:
-        SkShader::Context*        fDiffuseContext;
+        SkShaderBase::Context*    fDiffuseContext;
         SkNormalSource::Provider* fNormalProvider;
         SkColor                   fPaintColor;
         uint32_t                  fFlags;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     SK_TO_STRING_OVERRIDE()
@@ -93,7 +94,7 @@ private:
 
     friend class SkLightingShader;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
@@ -270,7 +271,7 @@ sk_sp<GrFragmentProcessor> SkLightingShaderImpl::asFragmentProcessor(const AsFPA
 
     if (fDiffuseShader) {
         sk_sp<GrFragmentProcessor> fpPipeline[] = {
-            fDiffuseShader->asFragmentProcessor(args),
+            as_SB(fDiffuseShader)->asFragmentProcessor(args),
             sk_make_sp<LightingFP>(std::move(normalFP), fLights)
         };
         if(!fpPipeline[0]) {
@@ -298,7 +299,7 @@ bool SkLightingShaderImpl::isOpaque() const {
 
 SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(
         const SkLightingShaderImpl& shader, const ContextRec& rec,
-        SkShader::Context* diffuseContext, SkNormalSource::Provider* normalProvider,
+        SkShaderBase::Context* diffuseContext, SkNormalSource::Provider* normalProvider,
         void* heapAllocated)
     : INHERITED(shader, rec)
     , fDiffuseContext(diffuseContext)
@@ -419,7 +420,7 @@ sk_sp<SkFlattenable> SkLightingShaderImpl::CreateProc(SkReadBuffer& buf) {
     bool hasDiffuse = buf.readBool();
     sk_sp<SkShader> diffuseShader = nullptr;
     if (hasDiffuse) {
-        diffuseShader = buf.readFlattenable<SkShader>();
+        diffuseShader = buf.readFlattenable<SkShaderBase>();
     }
 
     return sk_make_sp<SkLightingShaderImpl>(std::move(diffuseShader), std::move(normalSource),
@@ -438,12 +439,12 @@ void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     }
 }
 
-SkShader::Context* SkLightingShaderImpl::onMakeContext(
+SkShaderBase::Context* SkLightingShaderImpl::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const
 {
-    SkShader::Context *diffuseContext = nullptr;
+    SkShaderBase::Context *diffuseContext = nullptr;
     if (fDiffuseShader) {
-        diffuseContext = fDiffuseShader->makeContext(rec, alloc);
+        diffuseContext = as_SB(fDiffuseShader)->makeContext(rec, alloc);
         if (!diffuseContext) {
             return nullptr;
         }
diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp
index 8a9a1656d9..e21e4a84b7 100644
--- a/src/core/SkLocalMatrixShader.cpp
+++ b/src/core/SkLocalMatrixShader.cpp
@@ -17,7 +17,7 @@ sk_sp<GrFragmentProcessor> SkLocalMatrixShader::asFragmentProcessor(const AsFPAr
     if (args.fLocalMatrix) {
         tmp.preConcat(*args.fLocalMatrix);
     }
-    return fProxyShader->asFragmentProcessor(AsFPArgs(
+    return as_SB(fProxyShader)->asFragmentProcessor(AsFPArgs(
         args.fContext, args.fViewMatrix, &tmp, args.fFilterQuality, args.fDstColorSpace));
 }
 #endif
@@ -37,7 +37,7 @@ void SkLocalMatrixShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeFlattenable(fProxyShader.get());
 }
 
-SkShader::Context* SkLocalMatrixShader::onMakeContext(
+SkShaderBase::Context* SkLocalMatrixShader::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const
 {
     ContextRec newRec(rec);
@@ -48,7 +48,7 @@ SkShader::Context* SkLocalMatrixShader::onMakeContext(
     } else {
         newRec.fLocalMatrix = &this->getLocalMatrix();
     }
-    return fProxyShader->makeContext(newRec, alloc);
+    return as_SB(fProxyShader)->makeContext(newRec, alloc);
 }
 
 SkImage* SkLocalMatrixShader::onIsAImage(SkMatrix* outMatrix, enum TileMode* mode) const {
@@ -72,15 +72,15 @@ bool SkLocalMatrixShader::onAppendStages(SkRasterPipeline* p,
     if (localM) {
         tmp.setConcat(*localM, this->getLocalMatrix());
     }
-    return fProxyShader->appendStages(p, dst, scratch, ctm, paint,
-                                      localM ? &tmp : &this->getLocalMatrix());
+    return as_SB(fProxyShader)->appendStages(p, dst, scratch, ctm, paint,
+                                             localM ? &tmp : &this->getLocalMatrix());
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkLocalMatrixShader::toString(SkString* str) const {
     str->append("SkLocalMatrixShader: (");
 
-    fProxyShader->toString(str);
+    as_SB(fProxyShader)->toString(str);
 
     this->INHERITED::toString(str);
 
@@ -97,7 +97,7 @@ sk_sp<SkShader> SkShader::makeWithLocalMatrix(const SkMatrix& localMatrix) const
 
     sk_sp<SkShader> baseShader;
     SkMatrix otherLocalMatrix;
-    sk_sp<SkShader> proxy(this->makeAsALocalMatrixShader(&otherLocalMatrix));
+    sk_sp<SkShader> proxy(as_SB(this)->makeAsALocalMatrixShader(&otherLocalMatrix));
     if (proxy) {
         otherLocalMatrix.preConcat(localMatrix);
         lm = &otherLocalMatrix;
diff --git a/src/core/SkLocalMatrixShader.h b/src/core/SkLocalMatrixShader.h
index b00ee89d56..4572e9fe2e 100644
--- a/src/core/SkLocalMatrixShader.h
+++ b/src/core/SkLocalMatrixShader.h
@@ -8,7 +8,7 @@
 #ifndef SkLocalMatrixShader_DEFINED
 #define SkLocalMatrixShader_DEFINED
 
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
@@ -16,7 +16,7 @@ class GrFragmentProcessor;
 class SkArenaAlloc;
 class SkColorSpaceXformer;
 
-class SkLocalMatrixShader : public SkShader {
+class SkLocalMatrixShader : public SkShaderBase {
 public:
     SkLocalMatrixShader(sk_sp<SkShader> proxy, const SkMatrix& localMatrix)
     : INHERITED(&localMatrix)
@@ -52,7 +52,8 @@ protected:
                         const SkMatrix&, const SkPaint&, const SkMatrix*) const override;
 
     sk_sp<SkShader> onMakeColorSpace(SkColorSpaceXformer* xformer) const override {
-        return fProxyShader->makeColorSpace(xformer)->makeWithLocalMatrix(this->getLocalMatrix());
+        return as_SB(fProxyShader)->makeColorSpace(xformer)->makeWithLocalMatrix(
+            this->getLocalMatrix());
     }
 
 #ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP
@@ -62,13 +63,13 @@ protected:
 #endif
 
     bool isRasterPipelineOnly() const final {
-        return fProxyShader->isRasterPipelineOnly();
+        return as_SB(fProxyShader)->isRasterPipelineOnly();
     }
 
 private:
     sk_sp<SkShader> fProxyShader;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/src/core/SkMipMap.h b/src/core/SkMipMap.h
index f3425cbeaa..4ca9cbd63e 100644
--- a/src/core/SkMipMap.h
+++ b/src/core/SkMipMap.h
@@ -12,7 +12,7 @@
 #include "SkPixmap.h"
 #include "SkScalar.h"
 #include "SkSize.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SkBitmap;
 class SkDiscardableMemory;
@@ -33,8 +33,8 @@ public:
     static SkMipMap* Build(const SkBitmap& src, SkDestinationSurfaceColorMode,
                            SkDiscardableFactoryProc);
 
-    static SkDestinationSurfaceColorMode DeduceColorMode(const SkShader::ContextRec& rec) {
-        return (SkShader::ContextRec::kPMColor_DstType == rec.fPreferredDstType)
+    static SkDestinationSurfaceColorMode DeduceColorMode(const SkShaderBase::ContextRec& rec) {
+        return (SkShaderBase::ContextRec::kPMColor_DstType == rec.fPreferredDstType)
             ? SkDestinationSurfaceColorMode::kLegacy
             : SkDestinationSurfaceColorMode::kGammaAndColorSpaceAware;
     }
diff --git a/src/core/SkNormalBevelSource.cpp b/src/core/SkNormalBevelSource.cpp
index 05bb5f6163..0f1305cd15 100644
--- a/src/core/SkNormalBevelSource.cpp
+++ b/src/core/SkNormalBevelSource.cpp
@@ -241,7 +241,7 @@ private:
 };
 
 sk_sp<GrFragmentProcessor> SkNormalBevelSourceImpl::asFragmentProcessor(
-        const SkShader::AsFPArgs& args) const {
+        const SkShaderBase::AsFPArgs& args) const {
 
     // This assumes a uniform scale. Anisotropic scaling might not be handled gracefully.
     SkScalar maxScale = args.fViewMatrix->getMaxScale();
@@ -258,7 +258,7 @@ SkNormalBevelSourceImpl::Provider::Provider() {}
 
 SkNormalBevelSourceImpl::Provider::~Provider() {}
 
-SkNormalSource::Provider* SkNormalBevelSourceImpl::asProvider(const SkShader::ContextRec &rec,
+SkNormalSource::Provider* SkNormalBevelSourceImpl::asProvider(const SkShaderBase::ContextRec &rec,
                                                               SkArenaAlloc* alloc) const {
     return alloc->make<Provider>();
 }
diff --git a/src/core/SkNormalBevelSource.h b/src/core/SkNormalBevelSource.h
index 2fefacda8e..1e06303879 100644
--- a/src/core/SkNormalBevelSource.h
+++ b/src/core/SkNormalBevelSource.h
@@ -18,10 +18,10 @@ public:
         , fHeight(height) {}
 
 #if SK_SUPPORT_GPU
-    sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShader::AsFPArgs&) const override;
+    sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShaderBase::AsFPArgs&) const override;
 #endif
 
-    SkNormalSource::Provider* asProvider(const SkShader::ContextRec& rec,
+    SkNormalSource::Provider* asProvider(const SkShaderBase::ContextRec& rec,
                                          SkArenaAlloc*) const override;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNormalBevelSourceImpl)
diff --git a/src/core/SkNormalFlatSource.cpp b/src/core/SkNormalFlatSource.cpp
index 2547f4bda4..922ad15e92 100644
--- a/src/core/SkNormalFlatSource.cpp
+++ b/src/core/SkNormalFlatSource.cpp
@@ -60,7 +60,7 @@ private:
 };
 
 sk_sp<GrFragmentProcessor> SkNormalFlatSourceImpl::asFragmentProcessor(
-        const SkShader::AsFPArgs&) const {
+        const SkShaderBase::AsFPArgs&) const {
 
     return sk_make_sp<NormalFlatFP>();
 }
@@ -73,7 +73,7 @@ SkNormalFlatSourceImpl::Provider::Provider() {}
 
 SkNormalFlatSourceImpl::Provider::~Provider() {}
 
-SkNormalSource::Provider* SkNormalFlatSourceImpl::asProvider(const SkShader::ContextRec &rec,
+SkNormalSource::Provider* SkNormalFlatSourceImpl::asProvider(const SkShaderBase::ContextRec &rec,
                                                              SkArenaAlloc *alloc) const {
     return alloc->make<Provider>();
 }
diff --git a/src/core/SkNormalFlatSource.h b/src/core/SkNormalFlatSource.h
index 82b56f1a8b..938e28f3c5 100644
--- a/src/core/SkNormalFlatSource.h
+++ b/src/core/SkNormalFlatSource.h
@@ -15,10 +15,10 @@ public:
     SkNormalFlatSourceImpl(){}
 
 #if SK_SUPPORT_GPU
-    sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShader::AsFPArgs&) const override;
+    sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShaderBase::AsFPArgs&) const override;
 #endif
 
-    SkNormalSource::Provider* asProvider(const SkShader::ContextRec& rec,
+    SkNormalSource::Provider* asProvider(const SkShaderBase::ContextRec& rec,
                                          SkArenaAlloc* alloc) const override;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNormalFlatSourceImpl)
diff --git a/src/core/SkNormalMapSource.cpp b/src/core/SkNormalMapSource.cpp
index fb133da1b7..f655b687d6 100644
--- a/src/core/SkNormalMapSource.cpp
+++ b/src/core/SkNormalMapSource.cpp
@@ -118,8 +118,8 @@ private:
 };
 
 sk_sp<GrFragmentProcessor> SkNormalMapSourceImpl::asFragmentProcessor(
-        const SkShader::AsFPArgs& args) const {
-    sk_sp<GrFragmentProcessor> mapFP = fMapShader->asFragmentProcessor(args);
+        const SkShaderBase::AsFPArgs& args) const {
+    sk_sp<GrFragmentProcessor> mapFP = as_SB(fMapShader)->asFragmentProcessor(args);
     if (!mapFP) {
         return nullptr;
     }
@@ -132,11 +132,11 @@ sk_sp<GrFragmentProcessor> SkNormalMapSourceImpl::asFragmentProcessor(
 ////////////////////////////////////////////////////////////////////////////
 
 SkNormalMapSourceImpl::Provider::Provider(const SkNormalMapSourceImpl& source,
-                                          SkShader::Context* mapContext)
+                                          SkShaderBase::Context* mapContext)
     : fSource(source)
     , fMapContext(mapContext) {}
 
-SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(const SkShader::ContextRec &rec,
+SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(const SkShaderBase::ContextRec &rec,
                                                             SkArenaAlloc* alloc) const {
     SkMatrix normTotalInv;
     if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
@@ -146,10 +146,10 @@ SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(const SkShader::Cont
     // Overriding paint's alpha because we need the normal map's RGB channels to be unpremul'd
     SkPaint overridePaint {*(rec.fPaint)};
     overridePaint.setAlpha(0xFF);
-    SkShader::ContextRec overrideRec(overridePaint, *(rec.fMatrix), rec.fLocalMatrix,
-                                     rec.fPreferredDstType, rec.fDstColorSpace);
+    SkShaderBase::ContextRec overrideRec(overridePaint, *(rec.fMatrix), rec.fLocalMatrix,
+                                         rec.fPreferredDstType, rec.fDstColorSpace);
 
-    SkShader::Context* context = fMapShader->makeContext(overrideRec, alloc);
+    auto* context = as_SB(fMapShader)->makeContext(overrideRec, alloc);
     if (!context) {
         return nullptr;
     }
@@ -157,7 +157,7 @@ SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(const SkShader::Cont
     return alloc->make<Provider>(*this, context);
 }
 
-bool SkNormalMapSourceImpl::computeNormTotalInverse(const SkShader::ContextRec& rec,
+bool SkNormalMapSourceImpl::computeNormTotalInverse(const SkShaderBase::ContextRec& rec,
                                                     SkMatrix* normTotalInverse) const {
     SkMatrix total = SkMatrix::Concat(*rec.fMatrix, fMapShader->getLocalMatrix());
     if (rec.fLocalMatrix) {
@@ -221,7 +221,7 @@ void SkNormalMapSourceImpl::Provider::fillScanLine(int x, int y, SkPoint3 output
 
 sk_sp<SkFlattenable> SkNormalMapSourceImpl::CreateProc(SkReadBuffer& buf) {
 
-    sk_sp<SkShader> mapShader = buf.readFlattenable<SkShader>();
+    sk_sp<SkShader> mapShader = buf.readFlattenable<SkShaderBase>();
 
     SkMatrix invCTM;
     buf.readMatrix(&invCTM);
diff --git a/src/core/SkNormalMapSource.h b/src/core/SkNormalMapSource.h
index f2b07f21e9..a02e6abd09 100644
--- a/src/core/SkNormalMapSource.h
+++ b/src/core/SkNormalMapSource.h
@@ -17,10 +17,10 @@ public:
             , fInvCTM(invCTM) {}
 
 #if SK_SUPPORT_GPU
-    sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShader::AsFPArgs&) const override;
+    sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShaderBase::AsFPArgs&) const override;
 #endif
 
-    SkNormalSource::Provider* asProvider(const SkShader::ContextRec& rec,
+    SkNormalSource::Provider* asProvider(const SkShaderBase::ContextRec& rec,
                                          SkArenaAlloc* alloc) const override;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNormalMapSourceImpl)
@@ -28,18 +28,19 @@ public:
 protected:
     void flatten(SkWriteBuffer& buf) const override;
 
-    bool computeNormTotalInverse(const SkShader::ContextRec& rec, SkMatrix* normTotalInverse) const;
+    bool computeNormTotalInverse(const SkShaderBase::ContextRec& rec,
+                                 SkMatrix* normTotalInverse) const;
 
 private:
     class Provider : public SkNormalSource::Provider {
     public:
-        Provider(const SkNormalMapSourceImpl& source, SkShader::Context* mapContext);
+        Provider(const SkNormalMapSourceImpl& source, SkShaderBase::Context* mapContext);
 
         void fillScanLine(int x, int y, SkPoint3 output[], int count) const override;
 
     private:
         const SkNormalMapSourceImpl& fSource;
-        SkShader::Context* fMapContext;
+        SkShaderBase::Context*       fMapContext;
 
         typedef SkNormalSource::Provider INHERITED;
     };
diff --git a/src/core/SkNormalSource.h b/src/core/SkNormalSource.h
index 221c09db99..54d44d410a 100644
--- a/src/core/SkNormalSource.h
+++ b/src/core/SkNormalSource.h
@@ -9,7 +9,7 @@
 #define SkNormalSource_DEFINED
 
 #include "SkFlattenable.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SkMatrix;
 struct SkPoint3;
@@ -28,7 +28,7 @@ public:
     /** Returns a fragment processor that takes no input and outputs a normal (already rotated)
         as its output color. To be used as a child fragment processor.
     */
-    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShader::AsFPArgs&) const = 0;
+    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(const SkShaderBase::AsFPArgs&) const = 0;
 #endif
 
     class Provider {
@@ -44,7 +44,7 @@ public:
     /** Returns an instance of 'Provider' that provides normals for the CPU pipeline. The
         necessary data will be initialized in place at 'storage'.
     */
-    virtual Provider* asProvider(const SkShader::ContextRec&, SkArenaAlloc*) const = 0;
+    virtual Provider* asProvider(const SkShaderBase::ContextRec&, SkArenaAlloc*) const = 0;
 
     /** Returns a normal source that provides normals sourced from the the normal map argument.
 
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 568ba6a021..2d3eb1822b 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -26,6 +26,7 @@
 #include "SkScalar.h"
 #include "SkScalerContext.h"
 #include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkStringUtils.h"
 #include "SkStroke.h"
 #include "SkStrokeRec.h"
@@ -1250,7 +1251,7 @@ static SkPaint::Hinting computeHinting(const SkPaint& paint) {
 static bool justAColor(const SkPaint& paint, SkColor* color) {
     SkColor c = paint.getColor();
 
-    SkShader* shader = paint.getShader();
+    const auto* shader = as_SB(paint.getShader());
     if (shader && !shader->asLuminanceColor(&c)) {
         return false;
     }
@@ -2071,8 +2072,7 @@ void SkPaint::toString(SkString* str) const {
         str->append("</dd>");
     }
 
-    SkShader* shader = this->getShader();
-    if (shader) {
+    if (const auto* shader = as_SB(this->getShader())) {
         str->append("<dt>Shader:</dt><dd>");
         shader->toString(str);
         str->append("</dd>");
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index a92cf04d28..d6ee941251 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -277,11 +277,11 @@ bool SkPictureShader::onAppendStages(SkRasterPipeline* p, SkColorSpace* cs, SkAr
     // Keep bitmapShader alive by using alloc instead of stack memory
     auto& bitmapShader = *alloc->make<sk_sp<SkShader>>();
     bitmapShader = this->refBitmapShader(ctm, localMatrix, cs);
-    return bitmapShader && bitmapShader->appendStages(p, cs, alloc, ctm, paint);
+    return bitmapShader && as_SB(bitmapShader)->appendStages(p, cs, alloc, ctm, paint);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
-SkShader::Context* SkPictureShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc)
+SkShaderBase::Context* SkPictureShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc)
 const {
     sk_sp<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix,
                                                        rec.fDstColorSpace));
@@ -310,7 +310,7 @@ SkPictureShader::PictureShaderContext::PictureShaderContext(
     : INHERITED(shader, rec)
     , fBitmapShader(std::move(bitmapShader))
 {
-    fBitmapShaderContext = fBitmapShader->makeContext(rec, alloc);
+    fBitmapShaderContext = as_SB(fBitmapShader)->makeContext(rec, alloc);
     //if fBitmapShaderContext is null, we are invalid
 }
 
@@ -319,7 +319,7 @@ uint32_t SkPictureShader::PictureShaderContext::getFlags() const {
     return fBitmapShaderContext->getFlags();
 }
 
-SkShader::Context::ShadeProc SkPictureShader::PictureShaderContext::asAShadeProc(void** ctx) {
+SkShaderBase::Context::ShadeProc SkPictureShader::PictureShaderContext::asAShadeProc(void** ctx) {
     SkASSERT(fBitmapShaderContext);
     return fBitmapShaderContext->asAShadeProc(ctx);
 }
@@ -358,7 +358,7 @@ sk_sp<GrFragmentProcessor> SkPictureShader::asFragmentProcessor(const AsFPArgs&
     if (!bitmapShader) {
         return nullptr;
     }
-    return bitmapShader->asFragmentProcessor(SkShader::AsFPArgs(
+    return as_SB(bitmapShader)->asFragmentProcessor(SkShaderBase::AsFPArgs(
         args.fContext, args.fViewMatrix, nullptr, args.fFilterQuality, args.fDstColorSpace));
 }
 #endif
diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h
index 10b1f932d7..f7a509f181 100644
--- a/src/core/SkPictureShader.h
+++ b/src/core/SkPictureShader.h
@@ -8,7 +8,7 @@
 #ifndef SkPictureShader_DEFINED
 #define SkPictureShader_DEFINED
 
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SkArenaAlloc;
 class SkBitmap;
@@ -20,7 +20,7 @@ class SkPicture;
  * The SkPicture is first rendered into a tile, which is then used to shade the area according
  * to specified tiling rules.
  */
-class SkPictureShader : public SkShader {
+class SkPictureShader : public SkShaderBase {
 public:
     static sk_sp<SkShader> Make(sk_sp<SkPicture>, TileMode, TileMode, const SkMatrix*,
                                 const SkRect*);
@@ -52,7 +52,7 @@ private:
     SkRect              fTile;
     TileMode            fTmx, fTmy;
 
-    class PictureShaderContext : public SkShader::Context {
+    class PictureShaderContext : public Context {
     public:
         PictureShaderContext(
             const SkPictureShader&, const ContextRec&, sk_sp<SkShader> bitmapShader, SkArenaAlloc*);
@@ -62,18 +62,18 @@ private:
         ShadeProc asAShadeProc(void** ctx) override;
         void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
 
-        sk_sp<SkShader>     fBitmapShader;
-        SkShader::Context*  fBitmapShaderContext;
-        void*               fBitmapShaderContextStorage;
+        sk_sp<SkShader>         fBitmapShader;
+        SkShaderBase::Context*  fBitmapShaderContext;
+        void*                   fBitmapShaderContextStorage;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     // Should never be set by a public constructor.  This is only used when onMakeColorSpace()
     // forces a deferred color space xform.
     sk_sp<SkColorSpace>   fColorSpace;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif // SkPictureShader_DEFINED
diff --git a/src/core/SkRasterPipelineBlitter.cpp b/src/core/SkRasterPipelineBlitter.cpp
index 023ff1e234..cc48df03db 100644
--- a/src/core/SkRasterPipelineBlitter.cpp
+++ b/src/core/SkRasterPipelineBlitter.cpp
@@ -16,6 +16,7 @@
 #include "SkPM4fPriv.h"
 #include "SkRasterPipeline.h"
 #include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkUtils.h"
 #include "../jumper/SkJumper.h"
 
@@ -23,13 +24,14 @@ class SkRasterPipelineBlitter final : public SkBlitter {
 public:
     // This is our common entrypoint for creating the blitter once we've sorted out shaders.
     static SkBlitter* Create(const SkPixmap&, const SkPaint&, SkArenaAlloc*,
-                             const SkRasterPipeline& shaderPipeline, SkShader::Context* shaderCtx,
+                             const SkRasterPipeline& shaderPipeline,
+                             SkShaderBase::Context* shaderCtx,
                              bool is_opaque, bool is_constant, bool wants_dither);
 
     SkRasterPipelineBlitter(SkPixmap dst,
                             SkBlendMode blend,
                             SkArenaAlloc* alloc,
-                            SkShader::Context* shaderCtx)
+                            SkShaderBase::Context* shaderCtx)
         : fDst(dst)
         , fBlend(blend)
         , fAlloc(alloc)
@@ -54,11 +56,11 @@ private:
     // If we have an SkShader::Context, use it to fill our shader buffer.
     void maybe_shade(int x, int y, int w);
 
-    SkPixmap           fDst;
-    SkBlendMode        fBlend;
-    SkArenaAlloc*      fAlloc;
-    SkShader::Context* fShaderCtx;
-    SkRasterPipeline   fColorPipeline;
+    SkPixmap               fDst;
+    SkBlendMode            fBlend;
+    SkArenaAlloc*          fAlloc;
+    SkShaderBase::Context* fShaderCtx;
+    SkRasterPipeline       fColorPipeline;
 
     // We may be able to specialize blitH() into a memset.
     bool     fCanMemsetInBlitH = false;
@@ -90,7 +92,7 @@ SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
                                          SkArenaAlloc* alloc) {
     SkColorSpace* dstCS = dst.colorSpace();
     auto paintColor = alloc->make<SkPM4f>(SkPM4f_from_SkColor(paint.getColor(), dstCS));
-    auto shader = paint.getShader();
+    auto shader = as_SB(paint.getShader());
 
     SkRasterPipeline_<256> shaderPipeline;
     if (!shader) {
@@ -124,11 +126,12 @@ SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
     if (dstCS) {
         // We need to transform the shader into the dst color space, and extend its lifetime.
         sk_sp<SkShader> in_dstCS = SkColorSpaceXformer::Make(sk_ref_sp(dstCS))->apply(shader);
-        shader = in_dstCS.get();
+        shader = as_SB(in_dstCS.get());
         alloc->make<sk_sp<SkShader>>(std::move(in_dstCS));
     }
-    SkShader::ContextRec rec(paint, ctm, nullptr, SkShader::ContextRec::kPM4f_DstType, dstCS);
-    SkShader::Context* shaderCtx = shader->makeContext(rec, alloc);
+    SkShaderBase::ContextRec rec(paint, ctm, nullptr, SkShaderBase::ContextRec::kPM4f_DstType,
+                                 dstCS);
+    SkShaderBase::Context* shaderCtx = shader->makeContext(rec, alloc);
     if (!shaderCtx) {
         // When a shader fails to create a context, it has vetoed drawing entirely.
         return alloc->make<SkNullBlitter>();
@@ -154,7 +157,7 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
                                            const SkPaint& paint,
                                            SkArenaAlloc* alloc,
                                            const SkRasterPipeline& shaderPipeline,
-                                           SkShader::Context* shaderCtx,
+                                           SkShaderBase::Context* shaderCtx,
                                            bool is_opaque,
                                            bool is_constant,
                                            bool wants_dither) {
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index adc529ea77..453d22fe91 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -20,7 +20,7 @@
 #include "SkReadBuffer.h"
 #include "SkReader32.h"
 #include "SkRefCnt.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkTHash.h"
 #include "SkWriteBuffer.h"
 #include "SkXfermodePriv.h"
@@ -150,7 +150,7 @@ public:
     sk_sp<SkMaskFilter> readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); }
     sk_sp<SkPathEffect> readPathEffect() { return this->readFlattenable<SkPathEffect>(); }
     sk_sp<SkRasterizer> readRasterizer() { return this->readFlattenable<SkRasterizer>(); }
-    sk_sp<SkShader> readShader() { return this->readFlattenable<SkShader>(); }
+    sk_sp<SkShader> readShader() { return this->readFlattenable<SkShaderBase>(); }
     sk_sp<SkXfermode> readXfermode() { return this->readFlattenable<SkXfermode>(); }
 
     // binary data and arrays
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index ff5b400a25..4f39f704b8 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -18,7 +18,7 @@
 #include "SkRasterPipeline.h"
 #include "SkReadBuffer.h"
 #include "SkScalar.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkTLazy.h"
 #include "SkWriteBuffer.h"
 #include "../jumper/SkJumper.h"
@@ -46,22 +46,18 @@ static inline void dec_shader_counter() {
 #endif
 }
 
-SkShader::SkShader(const SkMatrix* localMatrix) {
+SkShaderBase::SkShaderBase(const SkMatrix* localMatrix)
+    : fLocalMatrix(localMatrix ? *localMatrix : SkMatrix::I()) {
     inc_shader_counter();
-    if (localMatrix) {
-        fLocalMatrix = *localMatrix;
-    } else {
-        fLocalMatrix.reset();
-    }
     // Pre-cache so future calls to fLocalMatrix.getType() are threadsafe.
     (void)fLocalMatrix.getType();
 }
 
-SkShader::~SkShader() {
+SkShaderBase::~SkShaderBase() {
     dec_shader_counter();
 }
 
-void SkShader::flatten(SkWriteBuffer& buffer) const {
+void SkShaderBase::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     bool hasLocalM = !fLocalMatrix.isIdentity();
     buffer.writeBool(hasLocalM);
@@ -70,9 +66,9 @@ void SkShader::flatten(SkWriteBuffer& buffer) const {
     }
 }
 
-bool SkShader::computeTotalInverse(const SkMatrix& ctm,
-                                   const SkMatrix* outerLocalMatrix,
-                                   SkMatrix* totalInverse) const {
+bool SkShaderBase::computeTotalInverse(const SkMatrix& ctm,
+                                       const SkMatrix* outerLocalMatrix,
+                                       SkMatrix* totalInverse) const {
     SkMatrix total = SkMatrix::Concat(ctm, fLocalMatrix);
     if (outerLocalMatrix) {
         total.preConcat(*outerLocalMatrix);
@@ -81,7 +77,7 @@ bool SkShader::computeTotalInverse(const SkMatrix& ctm,
     return total.invert(totalInverse);
 }
 
-bool SkShader::asLuminanceColor(SkColor* colorPtr) const {
+bool SkShaderBase::asLuminanceColor(SkColor* colorPtr) const {
     SkColor storage;
     if (nullptr == colorPtr) {
         colorPtr = &storage;
@@ -93,14 +89,14 @@ bool SkShader::asLuminanceColor(SkColor* colorPtr) const {
     return false;
 }
 
-SkShader::Context* SkShader::makeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
+SkShaderBase::Context* SkShaderBase::makeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
     if (!this->computeTotalInverse(*rec.fMatrix, rec.fLocalMatrix, nullptr)) {
         return nullptr;
     }
     return this->onMakeContext(rec, alloc);
 }
 
-SkShader::Context::Context(const SkShader& shader, const ContextRec& rec)
+SkShaderBase::Context::Context(const SkShaderBase& shader, const ContextRec& rec)
     : fShader(shader), fCTM(*rec.fMatrix)
 {
     // We should never use a context for RP-only shaders.
@@ -114,13 +110,13 @@ SkShader::Context::Context(const SkShader& shader, const ContextRec& rec)
     fPaintAlpha = rec.fPaint->getAlpha();
 }
 
-SkShader::Context::~Context() {}
+SkShaderBase::Context::~Context() {}
 
-SkShader::Context::ShadeProc SkShader::Context::asAShadeProc(void** ctx) {
+SkShaderBase::Context::ShadeProc SkShaderBase::Context::asAShadeProc(void** ctx) {
     return nullptr;
 }
 
-void SkShader::Context::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
+void SkShaderBase::Context::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
     const int N = 128;
     SkPMColor tmp[N];
     while (count > 0) {
@@ -146,7 +142,7 @@ void SkShader::Context::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
     #define SkU32BitShiftToByteOffset(shift)    ((shift) >> 3)
 #endif
 
-void SkShader::Context::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
+void SkShaderBase::Context::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
     SkASSERT(count > 0);
 
     SkPMColor   colors[kTempColorCount];
@@ -200,7 +196,7 @@ void SkShader::Context::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count)
 #endif
 }
 
-SkShader::Context::MatrixClass SkShader::Context::ComputeMatrixClass(const SkMatrix& mat) {
+SkShaderBase::Context::MatrixClass SkShaderBase::Context::ComputeMatrixClass(const SkMatrix& mat) {
     MatrixClass mc = kLinear_MatrixClass;
 
     if (mat.hasPerspective()) {
@@ -215,17 +211,31 @@ SkShader::Context::MatrixClass SkShader::Context::ComputeMatrixClass(const SkMat
 
 //////////////////////////////////////////////////////////////////////////////
 
+const SkMatrix& SkShader::getLocalMatrix() const {
+    return as_SB(this)->getLocalMatrix();
+}
+
+#ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP
+bool SkShader::isABitmap(SkBitmap* outTexture, SkMatrix* outMatrix, TileMode xy[2]) const {
+    return  as_SB(this)->onIsABitmap(outTexture, outMatrix, xy);
+}
+#endif
+
+SkImage* SkShader::isAImage(SkMatrix* localMatrix, TileMode xy[2]) const {
+    return as_SB(this)->onIsAImage(localMatrix, xy);
+}
+
 SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const {
     return kNone_GradientType;
 }
 
 #if SK_SUPPORT_GPU
-sk_sp<GrFragmentProcessor> SkShader::asFragmentProcessor(const AsFPArgs&) const {
+sk_sp<GrFragmentProcessor> SkShaderBase::asFragmentProcessor(const AsFPArgs&) const {
     return nullptr;
 }
 #endif
 
-sk_sp<SkShader> SkShader::makeAsALocalMatrixShader(SkMatrix*) const {
+sk_sp<SkShader> SkShaderBase::makeAsALocalMatrixShader(SkMatrix*) const {
     return nullptr;
 }
 
@@ -250,7 +260,7 @@ sk_sp<SkShader> SkShader::MakePictureShader(sk_sp<SkPicture> src, TileMode tmx,
 }
 
 #ifndef SK_IGNORE_TO_STRING
-void SkShader::toString(SkString* str) const {
+void SkShaderBase::toString(SkString* str) const {
     if (!fLocalMatrix.isIdentity()) {
         str->append(" ");
         fLocalMatrix.toString(str);
@@ -258,21 +268,21 @@ void SkShader::toString(SkString* str) const {
 }
 #endif
 
-bool SkShader::appendStages(SkRasterPipeline* p,
-                            SkColorSpace* dstCS,
-                            SkArenaAlloc* alloc,
-                            const SkMatrix& ctm,
-                            const SkPaint& paint,
-                            const SkMatrix* localM) const {
+bool SkShaderBase::appendStages(SkRasterPipeline* p,
+                                SkColorSpace* dstCS,
+                                SkArenaAlloc* alloc,
+                                const SkMatrix& ctm,
+                                const SkPaint& paint,
+                                const SkMatrix* localM) const {
     return this->onAppendStages(p, dstCS, alloc, ctm, paint, localM);
 }
 
-bool SkShader::onAppendStages(SkRasterPipeline* p,
-                              SkColorSpace* dstCS,
-                              SkArenaAlloc* alloc,
-                              const SkMatrix& ctm,
-                              const SkPaint& paint,
-                              const SkMatrix* localM) const {
+bool SkShaderBase::onAppendStages(SkRasterPipeline* p,
+                                  SkColorSpace* dstCS,
+                                  SkArenaAlloc* alloc,
+                                  const SkMatrix& ctm,
+                                  const SkPaint& paint,
+                                  const SkMatrix* localM) const {
     return false;
 }
 
diff --git a/src/core/SkShaderBase.h b/src/core/SkShaderBase.h
new file mode 100644
index 0000000000..e03fb76bab
--- /dev/null
+++ b/src/core/SkShaderBase.h
@@ -0,0 +1,324 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkShaderBase_DEFINED
+#define SkShaderBase_DEFINED
+
+#include "SkFilterQuality.h"
+#include "SkMatrix.h"
+#include "SkShader.h"
+
+class GrContext;
+class GrFragmentProcessor;
+class SkArenaAlloc;
+class SkColorSpace;
+class SkColorSpaceXformer;
+class SkImage;
+struct SkImageInfo;
+class SkPaint;
+class SkRasterPipeline;
+
+class SkShaderBase : public SkShader {
+public:
+    SkShaderBase(const SkMatrix* localMatrix = nullptr);
+
+    ~SkShaderBase() override;
+
+    /**
+     *  Returns true if the shader is guaranteed to produce only a single color.
+     *  Subclasses can override this to allow loop-hoisting optimization.
+     */
+    virtual bool isConstant() const { return false; }
+
+    const SkMatrix& getLocalMatrix() const { return fLocalMatrix; }
+
+    enum Flags {
+        //!< set if all of the colors will be opaque
+        kOpaqueAlpha_Flag = 1 << 0,
+
+        /** set if the spans only vary in X (const in Y).
+            e.g. an Nx1 bitmap that is being tiled in Y, or a linear-gradient
+            that varies from left-to-right. This flag specifies this for
+            shadeSpan().
+         */
+        kConstInY32_Flag = 1 << 1,
+
+        /** hint for the blitter that 4f is the preferred shading mode.
+         */
+        kPrefers4f_Flag  = 1 << 2,
+    };
+
+    /**
+     *  ContextRec acts as a parameter bundle for creating Contexts.
+     */
+    struct ContextRec {
+        enum DstType {
+            kPMColor_DstType, // clients prefer shading into PMColor dest
+            kPM4f_DstType,    // clients prefer shading into PM4f dest
+        };
+
+        ContextRec(const SkPaint& paint, const SkMatrix& matrix, const SkMatrix* localM,
+                   DstType dstType, SkColorSpace* dstColorSpace)
+            : fPaint(&paint)
+            , fMatrix(&matrix)
+            , fLocalMatrix(localM)
+            , fPreferredDstType(dstType)
+            , fDstColorSpace(dstColorSpace) {}
+
+        const SkPaint*  fPaint;            // the current paint associated with the draw
+        const SkMatrix* fMatrix;           // the current matrix in the canvas
+        const SkMatrix* fLocalMatrix;      // optional local matrix
+        const DstType   fPreferredDstType; // the "natural" client dest type
+        SkColorSpace*   fDstColorSpace;    // the color space of the dest surface (if any)
+    };
+
+    class Context : public ::SkNoncopyable {
+    public:
+        Context(const SkShaderBase& shader, const ContextRec&);
+
+        virtual ~Context();
+
+        /**
+         *  Called sometimes before drawing with this shader. Return the type of
+         *  alpha your shader will return. The default implementation returns 0.
+         *  Your subclass should override if it can (even sometimes) report a
+         *  non-zero value, since that will enable various blitters to perform
+         *  faster.
+         */
+        virtual uint32_t getFlags() const { return 0; }
+
+        /**
+         *  Called for each span of the object being drawn. Your subclass should
+         *  set the appropriate colors (with premultiplied alpha) that correspond
+         *  to the specified device coordinates.
+         */
+        virtual void shadeSpan(int x, int y, SkPMColor[], int count) = 0;
+
+        virtual void shadeSpan4f(int x, int y, SkPM4f[], int count);
+
+        struct BlitState;
+        typedef void (*BlitBW)(BlitState*,
+                               int x, int y, const SkPixmap&, int count);
+        typedef void (*BlitAA)(BlitState*,
+                               int x, int y, const SkPixmap&, int count, const SkAlpha[]);
+
+        struct BlitState {
+            // inputs
+            Context*    fCtx;
+            SkBlendMode fMode;
+
+            // outputs
+            enum { N = 2 };
+            void*       fStorage[N];
+            BlitBW      fBlitBW;
+            BlitAA      fBlitAA;
+        };
+
+        // Returns true if one or more of the blitprocs are set in the BlitState
+        bool chooseBlitProcs(const SkImageInfo& info, BlitState* state) {
+            state->fBlitBW = nullptr;
+            state->fBlitAA = nullptr;
+            if (this->onChooseBlitProcs(info, state)) {
+                SkASSERT(state->fBlitBW || state->fBlitAA);
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * The const void* ctx is only const because all the implementations are const.
+         * This can be changed to non-const if a new shade proc needs to change the ctx.
+         */
+        typedef void (*ShadeProc)(const void* ctx, int x, int y, SkPMColor[], int count);
+        virtual ShadeProc asAShadeProc(void** ctx);
+
+        /**
+         *  Similar to shadeSpan, but only returns the alpha-channel for a span.
+         *  The default implementation calls shadeSpan() and then extracts the alpha
+         *  values from the returned colors.
+         */
+        virtual void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count);
+
+        // Notification from blitter::blitMask in case we need to see the non-alpha channels
+        virtual void set3DMask(const SkMask*) {}
+
+    protected:
+        // Reference to shader, so we don't have to dupe information.
+        const SkShaderBase& fShader;
+
+        enum MatrixClass {
+            kLinear_MatrixClass,            // no perspective
+            kFixedStepInX_MatrixClass,      // fast perspective, need to call fixedStepInX() each
+                                            // scanline
+            kPerspective_MatrixClass        // slow perspective, need to mappoints each pixel
+        };
+        static MatrixClass ComputeMatrixClass(const SkMatrix&);
+
+        uint8_t         getPaintAlpha() const { return fPaintAlpha; }
+        const SkMatrix& getTotalInverse() const { return fTotalInverse; }
+        MatrixClass     getInverseClass() const { return (MatrixClass)fTotalInverseClass; }
+        const SkMatrix& getCTM() const { return fCTM; }
+
+        virtual bool onChooseBlitProcs(const SkImageInfo&, BlitState*) { return false; }
+
+    private:
+        SkMatrix    fCTM;
+        SkMatrix    fTotalInverse;
+        uint8_t     fPaintAlpha;
+        uint8_t     fTotalInverseClass;
+
+        typedef SkNoncopyable INHERITED;
+    };
+
+    /**
+     * Make a context using the memory provided by the arena.
+     *
+     * @return pointer to context or nullptr if can't be created
+     */
+    Context* makeContext(const ContextRec&, SkArenaAlloc*) const;
+
+    /**
+     *  If the shader subclass is composed of two shaders, return true, and if rec is not NULL,
+     *  fill it out with info about the shader.
+     *
+     *  These are bare pointers; the ownership and reference count are unchanged.
+     */
+
+    struct ComposeRec {
+        const SkShader*     fShaderA;
+        const SkShader*     fShaderB;
+        SkBlendMode         fBlendMode;
+    };
+
+    virtual bool asACompose(ComposeRec*) const { return false; }
+
+#if SK_SUPPORT_GPU
+    struct AsFPArgs {
+        AsFPArgs() {}
+        AsFPArgs(GrContext* context,
+                 const SkMatrix* viewMatrix,
+                 const SkMatrix* localMatrix,
+                 SkFilterQuality filterQuality,
+                 SkColorSpace* dstColorSpace)
+            : fContext(context)
+            , fViewMatrix(viewMatrix)
+            , fLocalMatrix(localMatrix)
+            , fFilterQuality(filterQuality)
+            , fDstColorSpace(dstColorSpace) {}
+
+        GrContext*                    fContext;
+        const SkMatrix*               fViewMatrix;
+        const SkMatrix*               fLocalMatrix;
+        SkFilterQuality               fFilterQuality;
+        SkColorSpace*                 fDstColorSpace;
+    };
+
+    /**
+     *  Returns a GrFragmentProcessor that implements the shader for the GPU backend. NULL is
+     *  returned if there is no GPU implementation.
+     *
+     *  The GPU device does not call SkShader::createContext(), instead we pass the view matrix,
+     *  local matrix, and filter quality directly.
+     *
+     *  The GrContext may be used by the to create textures that are required by the returned
+     *  processor.
+     *
+     *  The returned GrFragmentProcessor should expect an unpremultiplied input color and
+     *  produce a premultiplied output.
+     */
+    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const;
+#endif
+
+    /**
+     *  If the shader can represent its "average" luminance in a single color, return true and
+     *  if color is not NULL, return that color. If it cannot, return false and ignore the color
+     *  parameter.
+     *
+     *  Note: if this returns true, the returned color will always be opaque, as only the RGB
+     *  components are used to compute luminance.
+     */
+    bool asLuminanceColor(SkColor*) const;
+
+    /**
+     *  Returns a shader transformed into a new color space via the |xformer|.
+     */
+    sk_sp<SkShader> makeColorSpace(SkColorSpaceXformer* xformer) const {
+        return this->onMakeColorSpace(xformer);
+    }
+
+    /**
+     *  If this shader can be represented by another shader + a localMatrix, return that shader and
+     *  the localMatrix. If not, return nullptr and ignore the localMatrix parameter.
+     */
+    virtual sk_sp<SkShader> makeAsALocalMatrixShader(SkMatrix* localMatrix) const;
+
+    virtual bool isRasterPipelineOnly() const { return false; }
+
+    bool appendStages(SkRasterPipeline*, SkColorSpace* dstCS, SkArenaAlloc*,
+                      const SkMatrix& ctm, const SkPaint&, const SkMatrix* localM=nullptr) const;
+
+    bool computeTotalInverse(const SkMatrix& ctm,
+                             const SkMatrix* outerLocalMatrix,
+                             SkMatrix* totalInverse) const;
+
+#ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP
+    virtual bool onIsABitmap(SkBitmap*, SkMatrix*, TileMode[2]) const {
+        return false;
+    }
+#endif
+
+    virtual SkImage* onIsAImage(SkMatrix*, TileMode[2]) const {
+        return nullptr;
+    }
+
+    SK_TO_STRING_VIRT()
+
+    SK_DEFINE_FLATTENABLE_TYPE(SkShaderBase)
+    SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
+
+protected:
+    void flatten(SkWriteBuffer&) const override;
+
+    /**
+     * Specialize creating a SkShader context using the supplied allocator.
+     * @return pointer to context owned by the arena allocator.
+     */
+    virtual Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const {
+        return nullptr;
+    }
+
+    virtual bool onAsLuminanceColor(SkColor*) const {
+        return false;
+    }
+
+    virtual sk_sp<SkShader> onMakeColorSpace(SkColorSpaceXformer*) const {
+        return sk_ref_sp(const_cast<SkShaderBase*>(this));
+    }
+
+    virtual bool onAppendStages(SkRasterPipeline*, SkColorSpace* dstCS, SkArenaAlloc*,
+                                const SkMatrix&, const SkPaint&, const SkMatrix* localM) const;
+
+private:
+    // This is essentially const, but not officially so it can be modified in constructors.
+    SkMatrix fLocalMatrix;
+
+    typedef SkShader INHERITED;
+};
+
+inline SkShaderBase* as_SB(SkShader* shader) {
+    return static_cast<SkShaderBase*>(shader);
+}
+
+inline const SkShaderBase* as_SB(const SkShader* shader) {
+    return static_cast<const SkShaderBase*>(shader);
+}
+
+inline const SkShaderBase* as_SB(const sk_sp<SkShader>& shader) {
+    return static_cast<SkShaderBase*>(shader.get());
+}
+
+#endif // SkShaderBase_DEFINED
diff --git a/src/effects/SkGaussianEdgeShader.cpp b/src/effects/SkGaussianEdgeShader.cpp
index 7bbbb79117..c710b949d3 100644
--- a/src/effects/SkGaussianEdgeShader.cpp
+++ b/src/effects/SkGaussianEdgeShader.cpp
@@ -21,7 +21,7 @@ class SkArenaAlloc;
  When not using implicit distance, then b in the input color represents the input to the
  blur function.
  */
-class SkGaussianEdgeShaderImpl : public SkShader {
+class SkGaussianEdgeShaderImpl : public SkShaderBase {
 public:
     SkGaussianEdgeShaderImpl() {}
 
@@ -42,7 +42,7 @@ protected:
 private:
     friend class SkGaussianEdgeShader;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////
diff --git a/src/effects/SkGaussianEdgeShader.h b/src/effects/SkGaussianEdgeShader.h
index ef54ece56e..f0554dd0a7 100644
--- a/src/effects/SkGaussianEdgeShader.h
+++ b/src/effects/SkGaussianEdgeShader.h
@@ -8,7 +8,7 @@
 #ifndef SkGaussianEdgeShader_DEFINED
 #define SkGaussianEdgeShader_DEFINED
 
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
 class SK_API SkGaussianEdgeShader {
 public:
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index f2877cf472..87f8967242 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -10,7 +10,7 @@
 #include "SkArenaAlloc.h"
 #include "SkColorFilter.h"
 #include "SkReadBuffer.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkString.h"
 #include "SkUnPreMultiply.h"
 #include "SkWriteBuffer.h"
@@ -50,7 +50,7 @@ inline SkScalar smoothCurve(SkScalar t) {
     return t * t * (3 - 2 * t);
 }
 
-class SkPerlinNoiseShaderImpl final : public SkShader {
+class SkPerlinNoiseShaderImpl final : public SkShaderBase {
 public:
     /**
      *  About the noise types : the difference between the 2 is just minor tweaks to the algorithm,
@@ -87,7 +87,7 @@ protected:
     Context* onMakeContext(const ContextRec&, SkArenaAlloc* storage) const override;
 
 private:
-    class PerlinNoiseShaderContext final : public SkShader::Context {
+    class PerlinNoiseShaderContext final : public Context {
     public:
         PerlinNoiseShaderContext(const SkPerlinNoiseShaderImpl& shader, const ContextRec&);
         ~PerlinNoiseShaderContext() override;
@@ -105,7 +105,7 @@ private:
         SkMatrix fMatrix;
         PaintingData* fPaintingData;
 
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     const Type     fType;
@@ -118,7 +118,7 @@ private:
 
     friend class ::SkPerlinNoiseShader;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 } // end namespace
@@ -503,7 +503,7 @@ SkPMColor SkPerlinNoiseShaderImpl::PerlinNoiseShaderContext::shade(
     return SkPreMultiplyARGB(rgba[3], rgba[0], rgba[1], rgba[2]);
 }
 
-SkShader::Context* SkPerlinNoiseShaderImpl::onMakeContext(
+SkShaderBase::Context* SkPerlinNoiseShaderImpl::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const {
     return alloc->make<PerlinNoiseShaderContext>(*this, rec);
 }
@@ -658,7 +658,7 @@ sk_sp<GrFragmentProcessor> GrPerlinNoiseEffect::TestCreate(GrProcessorTestData*
                                             stitchTiles ? &tileSize : nullptr));
 
     GrTest::TestAsFPArgs asFPArgs(d);
-    return shader->asFragmentProcessor(asFPArgs.args());
+    return as_SB(shader)->asFragmentProcessor(asFPArgs.args());
 }
 #endif
 
diff --git a/src/effects/gradients/Sk4fGradientBase.h b/src/effects/gradients/Sk4fGradientBase.h
index 9209a90637..a660d6bde5 100644
--- a/src/effects/gradients/Sk4fGradientBase.h
+++ b/src/effects/gradients/Sk4fGradientBase.h
@@ -14,7 +14,7 @@
 #include "SkMatrix.h"
 #include "SkNx.h"
 #include "SkPM4f.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkTArray.h"
 
 struct Sk4fGradientInterval {
@@ -53,7 +53,7 @@ private:
 };
 
 class SkGradientShaderBase::
-GradientShaderBase4fContext : public SkShader::Context {
+GradientShaderBase4fContext : public Context {
 public:
     GradientShaderBase4fContext(const SkGradientShaderBase&,
                                 const ContextRec&);
@@ -77,7 +77,7 @@ protected:
     bool                       fColorsArePremul;
 
 private:
-    using INHERITED = SkShader::Context;
+    using INHERITED = Context;
 
     void addMirrorIntervals(const SkGradientShaderBase&,
                             const Sk4f& componentScale, bool reverse);
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index 5a4a31c58f..137da84d0c 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -582,7 +582,7 @@ SkGradientShaderBase::GradientShaderBaseContext::GradientShaderBaseContext(
     fDstToIndex.setConcat(shader.fPtsToUnit, inverse);
 
     fDstToIndexProc = fDstToIndex.getMapXYProc();
-    fDstToIndexClass = (uint8_t)SkShader::Context::ComputeMatrixClass(fDstToIndex);
+    fDstToIndexClass = (uint8_t)SkShaderBase::Context::ComputeMatrixClass(fDstToIndex);
 
     // now convert our colors in to PMColors
     unsigned paintAlpha = this->getPaintAlpha();
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index 8c188de39b..7a66edaffc 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -20,7 +20,7 @@
 #include "SkPM4fPriv.h"
 #include "SkRasterPipeline.h"
 #include "SkReadBuffer.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkUtils.h"
 #include "SkWriteBuffer.h"
 
@@ -79,7 +79,7 @@ static const TileProc gTileProcs[] = {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class SkGradientShaderBase : public SkShader {
+class SkGradientShaderBase : public SkShaderBase {
 public:
     struct Descriptor {
         Descriptor() {
@@ -156,7 +156,7 @@ public:
                                     U8CPU alpha, uint32_t gradFlags, bool dither);
     };
 
-    class GradientShaderBaseContext : public SkShader::Context {
+    class GradientShaderBaseContext : public Context {
     public:
         GradientShaderBaseContext(const SkGradientShaderBase& shader, const ContextRec&);
 
@@ -174,7 +174,7 @@ public:
         sk_sp<GradientShaderCache> fCache;
 
     private:
-        typedef SkShader::Context INHERITED;
+        typedef Context INHERITED;
     };
 
     bool isOpaque() const override;
@@ -283,7 +283,7 @@ private:
 
     void initCommon();
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index bd46452fb2..17c4fd36a4 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -39,11 +39,11 @@ static SkMatrix pts_to_unit_matrix(const SkPoint pts[2]) {
     return matrix;
 }
 
-static bool use_4f_context(const SkShader::ContextRec& rec, uint32_t flags) {
+static bool use_4f_context(const SkShaderBase::ContextRec& rec, uint32_t flags) {
 #ifdef FORCE_4F_CONTEXT
     return true;
 #else
-    return rec.fPreferredDstType == SkShader::ContextRec::kPM4f_DstType
+    return rec.fPreferredDstType == SkShaderBase::ContextRec::kPM4f_DstType
         || SkToBool(flags & SkLinearGradient::kForce4fContext_PrivateFlag);
 #endif
 }
@@ -75,7 +75,7 @@ void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
     buffer.writePoint(fEnd);
 }
 
-SkShader::Context* SkLinearGradient::onMakeContext(
+SkShaderBase::Context* SkLinearGradient::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const
 {
     return use_4f_context(rec, fGradFlags)
@@ -436,7 +436,7 @@ sk_sp<GrFragmentProcessor> GrLinearGradient::TestCreate(GrProcessorTestData* d)
         SkGradientShader::MakeLinear(points, params.fColors, params.fStops,
                                      params.fColorCount, params.fTileMode);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 339c5ff473..d49b3dd8e1 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -40,7 +40,7 @@ SkRadialGradient::SkRadialGradient(const SkPoint& center, SkScalar radius, const
     , fRadius(radius) {
 }
 
-SkShader::Context* SkRadialGradient::onMakeContext(
+SkShaderBase::Context* SkRadialGradient::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const
 {
     return CheckedMakeContext<RadialGradientContext>(alloc, *this, rec);
@@ -318,7 +318,7 @@ sk_sp<GrFragmentProcessor> GrRadialGradient::TestCreate(GrProcessorTestData* d)
                                                         params.fTileMode);
     } while (!shader);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 66913c6b20..1e583c2ee0 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -52,7 +52,7 @@ void SkSweepGradient::flatten(SkWriteBuffer& buffer) const {
     buffer.writePoint(fCenter);
 }
 
-SkShader::Context* SkSweepGradient::onMakeContext(
+SkShaderBase::Context* SkSweepGradient::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const
 {
     return CheckedMakeContext<SweepGradientContext>(alloc, *this, rec);
@@ -210,7 +210,7 @@ sk_sp<GrFragmentProcessor> GrSweepGradient::TestCreate(GrProcessorTestData* d) {
         SkGradientShader::MakeSweep(center.fX, center.fY,  params.fColors,
                                     params.fStops, params.fColorCount);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index ced299ee23..4549527d51 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -210,7 +210,7 @@ bool SkTwoPointConicalGradient::isOpaque() const {
     return false;
 }
 
-SkShader::Context* SkTwoPointConicalGradient::onMakeContext(
+SkShaderBase::Context* SkTwoPointConicalGradient::onMakeContext(
     const ContextRec& rec, SkArenaAlloc* alloc) const {
     return CheckedMakeContext<TwoPointConicalGradientContext>(alloc, *this, rec);
 }
diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
index fedb445904..8402199362 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -207,7 +207,7 @@ sk_sp<GrFragmentProcessor> Edge2PtConicalEffect::TestCreate(GrProcessorTestData*
                                               params.fColors, params.fStops,
                                               params.fColorCount, params.fTileMode);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
@@ -486,7 +486,7 @@ sk_sp<GrFragmentProcessor> FocalOutside2PtConicalEffect::TestCreate(GrProcessorT
                                               params.fColors, params.fStops,
                                               params.fColorCount, params.fTileMode);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
@@ -690,7 +690,7 @@ sk_sp<GrFragmentProcessor> FocalInside2PtConicalEffect::TestCreate(GrProcessorTe
                                               params.fColors, params.fStops,
                                               params.fColorCount, params.fTileMode);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
@@ -936,7 +936,7 @@ sk_sp<GrFragmentProcessor> CircleInside2PtConicalEffect::TestCreate(GrProcessorT
                                               params.fColors, params.fStops,
                                               params.fColorCount, params.fTileMode);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
@@ -1170,7 +1170,7 @@ sk_sp<GrFragmentProcessor> CircleOutside2PtConicalEffect::TestCreate(GrProcessor
                                               params.fColors, params.fStops,
                                               params.fColorCount, params.fTileMode);
     GrTest::TestAsFPArgs asFPArgs(d);
-    sk_sp<GrFragmentProcessor> fp = shader->asFragmentProcessor(asFPArgs.args());
+    sk_sp<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
     GrAlwaysAssert(fp);
     return fp;
 }
diff --git a/src/gpu/GrTestUtils.h b/src/gpu/GrTestUtils.h
index 5bb1cc1738..fd9398d0c0 100644
--- a/src/gpu/GrTestUtils.h
+++ b/src/gpu/GrTestUtils.h
@@ -16,7 +16,7 @@
 #include "GrColorSpaceXform.h"
 #include "SkPathEffect.h"
 #include "SkRandom.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 #include "SkStrokeRec.h"
 #include "../private/SkTemplates.h"
 
@@ -50,10 +50,10 @@ sk_sp<GrColorSpaceXform> TestColorXform(SkRandom*);
 class TestAsFPArgs {
 public:
     TestAsFPArgs(GrProcessorTestData*);
-    const SkShader::AsFPArgs& args() const { return fArgs; }
+    const SkShaderBase::AsFPArgs& args() const { return fArgs; }
 
 private:
-    SkShader::AsFPArgs fArgs;
+    SkShaderBase::AsFPArgs fArgs;
     SkMatrix fViewMatrixStorage;
     sk_sp<SkColorSpace> fColorSpaceStorage;
 };
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 81fde3579d..fd9be57359 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -30,6 +30,7 @@
 #include "SkPM4fPriv.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
+#include "SkShaderBase.h"
 #include "SkTemplates.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrConstColorProcessor.h"
@@ -424,10 +425,10 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context,
     if (!primColorMode || blend_requires_shader(*primColorMode)) {
         if (shaderProcessor) {
             shaderFP = *shaderProcessor;
-        } else if (const SkShader* shader = skPaint.getShader()) {
-            shaderFP = shader->asFragmentProcessor(SkShader::AsFPArgs(context, &viewM, nullptr,
-                                                                      skPaint.getFilterQuality(),
-                                                                      rtc->getColorSpace()));
+        } else if (const auto* shader = as_SB(skPaint.getShader())) {
+            shaderFP = shader->asFragmentProcessor(
+                SkShaderBase::AsFPArgs(context, &viewM, nullptr, skPaint.getFilterQuality(),
+                                       rtc->getColorSpace()));
             if (!shaderFP) {
                 return false;
             }
@@ -599,12 +600,10 @@ bool SkPaintToGrPaintWithTexture(GrContext* context,
                                  GrPaint* grPaint) {
     sk_sp<GrFragmentProcessor> shaderFP;
     if (textureIsAlphaOnly) {
-        if (const SkShader* shader = paint.getShader()) {
-            shaderFP = shader->asFragmentProcessor(SkShader::AsFPArgs(context,
-                                                                      &viewM,
-                                                                      nullptr,
-                                                                      paint.getFilterQuality(),
-                                                                      rtc->getColorSpace()));
+        if (const auto* shader = as_SB(paint.getShader())) {
+            shaderFP = shader->asFragmentProcessor(
+                SkShaderBase::AsFPArgs(context, &viewM, nullptr, paint.getFilterQuality(),
+                                       rtc->getColorSpace()));
             if (!shaderFP) {
                 return false;
             }
diff --git a/src/image/SkImageShader.cpp b/src/image/SkImageShader.cpp
index 0dbf944948..751300e951 100644
--- a/src/image/SkImageShader.cpp
+++ b/src/image/SkImageShader.cpp
@@ -48,7 +48,8 @@ bool SkImageShader::isOpaque() const {
     return fImage->isOpaque();
 }
 
-SkShader::Context* SkImageShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
+SkShaderBase::Context* SkImageShader::onMakeContext(const ContextRec& rec,
+                                                    SkArenaAlloc* alloc) const {
     return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY,
                                                  SkBitmapProvider(fImage.get(), rec.fDstColorSpace),
                                                  rec, alloc);
@@ -204,9 +205,9 @@ static sk_sp<SkFlattenable> SkBitmapProcShader_CreateProc(SkReadBuffer& buffer)
     return image ? image->makeShader(mx, my, &lm) : nullptr;
 }
 
-SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShader)
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShaderBase)
 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkImageShader)
-SkFlattenable::Register("SkBitmapProcShader", SkBitmapProcShader_CreateProc, kSkShader_Type);
+SkFlattenable::Register("SkBitmapProcShader", SkBitmapProcShader_CreateProc, kSkShaderBase_Type);
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
 
 
diff --git a/src/image/SkImageShader.h b/src/image/SkImageShader.h
index 5274826e88..7be982c5c6 100644
--- a/src/image/SkImageShader.h
+++ b/src/image/SkImageShader.h
@@ -11,9 +11,9 @@
 #include "SkBitmapProcShader.h"
 #include "SkColorSpaceXformer.h"
 #include "SkImage.h"
-#include "SkShader.h"
+#include "SkShaderBase.h"
 
-class SkImageShader : public SkShader {
+class SkImageShader : public SkShaderBase {
 public:
     static sk_sp<SkShader> Make(sk_sp<SkImage>, TileMode tx, TileMode ty,
                                 const SkMatrix* localMatrix);
@@ -50,9 +50,9 @@ protected:
     const TileMode  fTileModeY;
 
 private:
-    friend class SkShader;
+    friend class SkShaderBase;
 
-    typedef SkShader INHERITED;
+    typedef SkShaderBase INHERITED;
 };
 
 #endif
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index bb49df0528..1212833c0e 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -18,6 +18,7 @@
 #include "SkNormalSource.h"
 #include "SkOSFile.h"
 #include "SkPictureRecorder.h"
+#include "SkShaderBase.h"
 #include "SkTableColorFilter.h"
 #include "SkTemplates.h"
 #include "SkTypeface.h"
@@ -610,22 +611,22 @@ DEF_TEST(Serialization, reporter) {
         sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuseShader,
                                                                 normalSource,
                                                                 fLights);
-        sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
+        sk_sp<SkShader>(TestFlattenableSerialization(as_SB(lightingShader.get()), true, reporter));
 
         lightingShader = SkLightingShader::Make(std::move(diffuseShader),
                                                 nullptr,
                                                 fLights);
-        sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
+        sk_sp<SkShader>(TestFlattenableSerialization(as_SB(lightingShader.get()), true, reporter));
 
         lightingShader = SkLightingShader::Make(nullptr,
                                                 std::move(normalSource),
                                                 fLights);
-        sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
+        sk_sp<SkShader>(TestFlattenableSerialization(as_SB(lightingShader.get()), true, reporter));
 
         lightingShader = SkLightingShader::Make(nullptr,
                                                 nullptr,
                                                 fLights);
-        sk_sp<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter));
+        sk_sp<SkShader>(TestFlattenableSerialization(as_SB(lightingShader.get()), true, reporter));
     }
 
     // Test NormalBevelSource serialization
diff --git a/tests/TessellatingPathRendererTests.cpp b/tests/TessellatingPathRendererTests.cpp
index 79385af956..f799bd7e91 100644
--- a/tests/TessellatingPathRendererTests.cpp
+++ b/tests/TessellatingPathRendererTests.cpp
@@ -13,6 +13,7 @@
 #include "GrClip.h"
 #include "GrContext.h"
 #include "SkGradientShader.h"
+#include "SkShaderBase.h"
 #include "ops/GrTessellatingPathRenderer.h"
 
 /*
@@ -279,9 +280,9 @@ static sk_sp<GrFragmentProcessor> create_linear_gradient_processor(GrContext* ct
     SkColor colors[2] = { SK_ColorGREEN, SK_ColorBLUE };
     sk_sp<SkShader> shader = SkGradientShader::MakeLinear(
         pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode);
-    SkShader::AsFPArgs args(
+    SkShaderBase::AsFPArgs args(
         ctx, &SkMatrix::I(), &SkMatrix::I(), SkFilterQuality::kLow_SkFilterQuality, nullptr);
-    return shader->asFragmentProcessor(args);
+    return as_SB(shader)->asFragmentProcessor(args);
 }
 
 static void test_path(GrContext* ctx,