Use SkArenaAlloc instead of SkSmallAllocator in the SkAutoBlitterChoose code.

TBR=reed@google.com
Change-Id: Iefb044bf7657fbf982f23aa91a3f4d013ce2c626
Reviewed-on: https://skia-review.googlesource.com/7786
Reviewed-by: Mike Klein <mtklein@chromium.org>
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Herb Derby <herb@google.com>

43 files changed, 198 insertions, 369 deletions

diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index a409517090..fe43ba24b6 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -326,6 +326,7 @@ void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
 
     USE_SHADER:
 
+    // TODO(herb): Move this over to SkArenaAlloc when arena alloc has a facility to return sk_sps.
     // Since the shader need only live for our stack-frame, pass in a custom allocator. This
     // can save malloc calls, and signals to SkMakeBitmapShader to not try to copy the bitmap
     // if its mutable, since that precaution is not needed (give the short lifetime of the shader).
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index 11deac4aed..8c648b6051 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -6,6 +6,8 @@
  */
 
 #include "SkBitmapProcShader.h"
+
+#include "SkArenaAlloc.h"
 #include "SkBitmapProcState.h"
 #include "SkBitmapProvider.h"
 #include "SkXfermodePriv.h"
@@ -33,10 +35,6 @@ public:
         }
     }
 
-    ~BitmapProcInfoContext() override {
-        fInfo->~SkBitmapProcInfo();
-    }
-
     uint32_t getFlags() const override { return fFlags; }
 
 private:
@@ -201,10 +199,10 @@ size_t SkBitmapProcLegacyShader::ContextSize(const ContextRec& rec, const SkImag
     return s;
 }
 
-SkShader::Context* SkBitmapProcLegacyShader::MakeContext(const SkShader& shader,
-                                                   TileMode tmx, TileMode tmy,
-                                                   const SkBitmapProvider& provider,
-                                                   const ContextRec& rec, void* storage) {
+SkShader::Context* SkBitmapProcLegacyShader::MakeContext(
+    const SkShader& shader, TileMode tmx, TileMode tmy,
+    const SkBitmapProvider& provider, const ContextRec& rec, SkArenaAlloc* alloc)
+{
     SkMatrix totalInverse;
     // Do this first, so we know the matrix can be inverted.
     if (!shader.computeTotalInverse(rec, &totalInverse)) {
@@ -215,21 +213,17 @@ SkShader::Context* SkBitmapProcLegacyShader::MakeContext(const SkShader& shader,
     bool useLinearPipeline = choose_linear_pipeline(rec, provider.info());
 
     if (useLinearPipeline) {
-        void* infoStorage = (char*)storage + sizeof(LinearPipelineContext);
-        SkBitmapProcInfo* info = new (infoStorage) SkBitmapProcInfo(provider, tmx, tmy);
+        SkBitmapProcInfo* info = alloc->make<SkBitmapProcInfo>(provider, tmx, tmy);
         if (!info->init(totalInverse, *rec.fPaint)) {
-            info->~SkBitmapProcInfo();
             return nullptr;
         }
 
-        return new (storage) LinearPipelineContext(shader, rec, info);
+        return alloc->make<LinearPipelineContext>(shader, rec, info);
     } else {
-        void* stateStorage = (char*)storage + sizeof(BitmapProcShaderContext);
-        SkBitmapProcState* state = new (stateStorage) SkBitmapProcState(provider, tmx, tmy);
+        SkBitmapProcState* state = alloc->make<SkBitmapProcState>(provider, tmx, tmy);
         if (!state->setup(totalInverse, *rec.fPaint)) {
-            state->~SkBitmapProcState();
             return nullptr;
         }
-        return new (storage) BitmapProcShaderContext(shader, rec, state);
+        return alloc->make<BitmapProcShaderContext>(shader, rec, state);
     }
 }
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 4b7447e52e..204b27dd4c 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -18,7 +18,7 @@ private:
 
     static size_t ContextSize(const ContextRec&, const SkImageInfo& srcInfo);
     static Context* MakeContext(const SkShader&, TileMode tmx, TileMode tmy,
-                                const SkBitmapProvider&, const ContextRec&, void* storage);
+                                const SkBitmapProvider&, const ContextRec&, SkArenaAlloc* alloc);
 
     typedef SkShader INHERITED;
 };
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index d8e3dfd664..a386904dcd 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -5,6 +5,7 @@
  * found in the LICENSE file.
  */
 
+#include "SkArenaAlloc.h"
 #include "SkBlitter.h"
 #include "SkAntiRun.h"
 #include "SkColor.h"
@@ -585,24 +586,15 @@ class Sk3DShader : public SkShader {
 public:
     Sk3DShader(sk_sp<SkShader> proxy) : fProxy(std::move(proxy)) {}
 
-    size_t onContextSize(const ContextRec& rec) const override {
-        size_t size = sizeof(Sk3DShaderContext);
-        if (fProxy) {
-            size += fProxy->contextSize(rec);
-        }
-        return size;
-    }
-
-    Context* onCreateContext(const ContextRec& rec, void* storage) const override {
+    Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const override {
         SkShader::Context* proxyContext = nullptr;
         if (fProxy) {
-            char* proxyContextStorage = (char*) storage + sizeof(Sk3DShaderContext);
-            proxyContext = fProxy->createContext(rec, proxyContextStorage);
+            proxyContext = fProxy->makeContext(rec, alloc);
             if (!proxyContext) {
                 return nullptr;
             }
         }
-        return new (storage) Sk3DShaderContext(*this, rec, proxyContext);
+        return alloc->make<Sk3DShaderContext>(*this, rec, proxyContext);
     }
 
     class Sk3DShaderContext : public SkShader::Context {
@@ -793,15 +785,15 @@ SkShader::ContextRec::DstType SkBlitter::PreferredShaderDest(const SkImageInfo&
 SkBlitter* SkBlitter::Choose(const SkPixmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
-                             SkTBlitterAllocator* allocator,
+                             SkArenaAlloc* alloc,
                              bool drawCoverage) {
-    SkASSERT(allocator != nullptr);
+    SkASSERT(alloc != nullptr);
 
     // which check, in case we're being called by a client with a dummy device
     // (e.g. they have a bounder that always aborts the draw)
     if (kUnknown_SkColorType == device.colorType() ||
             (drawCoverage && (kAlpha_8_SkColorType != device.colorType()))) {
-        return allocator->createT<SkNullBlitter>();
+        return alloc->make<SkNullBlitter>();
     }
 
     SkShader* shader = origPaint.getShader();
@@ -827,7 +819,7 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
                 paint.writable()->setBlendMode(mode);
                 break;
             case kSkipDrawing_SkXfermodeInterpretation:{
-                return allocator->createT<SkNullBlitter>();
+                return alloc->make<SkNullBlitter>();
             }
             default:
                 break;
@@ -852,10 +844,10 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     if (kAlpha_8_SkColorType == device.colorType() && drawCoverage) {
         SkASSERT(nullptr == shader);
         SkASSERT(paint->isSrcOver());
-        return allocator->createT<SkA8_Coverage_Blitter>(device, *paint);
+        return alloc->make<SkA8_Coverage_Blitter>(device, *paint);
     }
 
-    if (SkBlitter* blitter = SkCreateRasterPipelineBlitter(device, *paint, matrix, allocator)) {
+    if (SkBlitter* blitter = SkCreateRasterPipelineBlitter(device, *paint, matrix, alloc)) {
         return blitter;
     }
 
@@ -891,21 +883,12 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
         const SkShader::ContextRec rec(*paint, matrix, nullptr,
                                        PreferredShaderDest(device.info()),
                                        device.colorSpace());
-        size_t contextSize = shader->contextSize(rec);
-        if (contextSize) {
-            // Try to create the ShaderContext
-            shaderContext = allocator->createWithIniter(
-                contextSize,
-                [&rec, shader](void* storage) {
-                    return shader->createContext(rec, storage);
-                });
-            if (!shaderContext) {
-                return allocator->createT<SkNullBlitter>();
-            }
-            SkASSERT(shaderContext);
-        } else {
-            return allocator->createT<SkNullBlitter>();
+        // Try to create the ShaderContext
+        shaderContext = shader->makeContext(rec, alloc);
+        if (!shaderContext) {
+            return alloc->make<SkNullBlitter>();
         }
+        SkASSERT(shaderContext);
     }
 
     SkBlitter*  blitter = nullptr;
@@ -913,14 +896,14 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
         case kAlpha_8_SkColorType:
             SkASSERT(!drawCoverage);  // Handled above.
             if (shader) {
-                blitter = allocator->createT<SkA8_Shader_Blitter>(device, *paint, shaderContext);
+                blitter = alloc->make<SkA8_Shader_Blitter>(device, *paint, shaderContext);
             } else {
-                blitter = allocator->createT<SkA8_Blitter>(device, *paint);
+                blitter = alloc->make<SkA8_Blitter>(device, *paint);
             }
             break;
 
         case kRGB_565_SkColorType:
-            blitter = SkBlitter_ChooseD565(device, *paint, shaderContext, allocator);
+            blitter = SkBlitter_ChooseD565(device, *paint, shaderContext, alloc);
             break;
 
         case kN32_SkColorType:
@@ -930,23 +913,23 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
             if (device.info().gammaCloseToSRGB())
 #endif
             {
-                blitter = SkBlitter_ARGB32_Create(device, *paint, shaderContext, allocator);
+                blitter = SkBlitter_ARGB32_Create(device, *paint, shaderContext, alloc);
             } else {
                 if (shader) {
-                        blitter = allocator->createT<SkARGB32_Shader_Blitter>(
+                        blitter = alloc->make<SkARGB32_Shader_Blitter>(
                                 device, *paint, shaderContext);
                 } else if (paint->getColor() == SK_ColorBLACK) {
-                    blitter = allocator->createT<SkARGB32_Black_Blitter>(device, *paint);
+                    blitter = alloc->make<SkARGB32_Black_Blitter>(device, *paint);
                 } else if (paint->getAlpha() == 0xFF) {
-                    blitter = allocator->createT<SkARGB32_Opaque_Blitter>(device, *paint);
+                    blitter = alloc->make<SkARGB32_Opaque_Blitter>(device, *paint);
                 } else {
-                    blitter = allocator->createT<SkARGB32_Blitter>(device, *paint);
+                    blitter = alloc->make<SkARGB32_Blitter>(device, *paint);
                 }
             }
             break;
 
         case kRGBA_F16_SkColorType:
-            blitter = SkBlitter_F16_Create(device, *paint, shaderContext, allocator);
+            blitter = SkBlitter_F16_Create(device, *paint, shaderContext, alloc);
             break;
 
         default:
@@ -954,15 +937,16 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     }
 
     if (!blitter) {
-        blitter = allocator->createT<SkNullBlitter>();
+        blitter = alloc->make<SkNullBlitter>();
     }
 
     if (shader3D) {
         SkBlitter* innerBlitter = blitter;
+        // FIXME - comment about allocator
         // innerBlitter was allocated by allocator, which will delete it.
         // We know shaderContext or its proxies is of type Sk3DShaderContext, so we need to
         // wrapper the blitter to notify it when we see an emboss mask.
-        blitter = allocator->createT<Sk3DBlitter>(innerBlitter, shaderContext);
+        blitter = alloc->make<Sk3DBlitter>(innerBlitter, shaderContext);
     }
     return blitter;
 }
diff --git a/src/core/SkBlitter.h b/src/core/SkBlitter.h
index cab2afc974..4d34ce3e91 100644
--- a/src/core/SkBlitter.h
+++ b/src/core/SkBlitter.h
@@ -137,7 +137,7 @@ public:
     static SkBlitter* Choose(const SkPixmap& dst,
                              const SkMatrix& matrix,
                              const SkPaint& paint,
-                             SkTBlitterAllocator*,
+                             SkArenaAlloc*,
                              bool drawCoverage = false);
 
     static SkBlitter* ChooseSprite(const SkPixmap& dst,
diff --git a/src/core/SkBlitter_PM4f.cpp b/src/core/SkBlitter_PM4f.cpp
index ce66580659..61105ce2db 100644
--- a/src/core/SkBlitter_PM4f.cpp
+++ b/src/core/SkBlitter_PM4f.cpp
@@ -6,6 +6,8 @@
  */
 
 #include "SkCoreBlitters.h"
+
+#include "SkArenaAlloc.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
 #include "SkUtils.h"
@@ -403,8 +405,8 @@ struct StateF16 : State4f {
 
 template <typename State> SkBlitter* create(const SkPixmap& device, const SkPaint& paint,
                                             SkShader::Context* shaderContext,
-                                            SkTBlitterAllocator* allocator) {
-    SkASSERT(allocator != nullptr);
+                                            SkArenaAlloc* alloc) {
+    SkASSERT(alloc != nullptr);
 
     if (shaderContext) {
         SkShader::Context::BlitState bstate;
@@ -413,24 +415,24 @@ template <typename State> SkBlitter* create(const SkPixmap& device, const SkPain
         bstate.fMode = paint.getBlendMode();
 
         (void)shaderContext->chooseBlitProcs(device.info(), &bstate);
-        return allocator->createT<SkState_Shader_Blitter<State>>(device, paint, bstate);
+        return alloc->make<SkState_Shader_Blitter<State>>(device, paint, bstate);
     } else {
         SkColor color = paint.getColor();
         if (0 == SkColorGetA(color)) {
             return nullptr;
         }
-        return allocator->createT<SkState_Blitter<State>>(device, paint);
+        return alloc->make<SkState_Blitter<State>>(device, paint);
     }
 }
 
 SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint& paint,
                                    SkShader::Context* shaderContext,
-                                   SkTBlitterAllocator* allocator) {
-    return create<State32>(device, paint, shaderContext, allocator);
+                                   SkArenaAlloc* alloc) {
+    return create<State32>(device, paint, shaderContext, alloc);
 }
 
 SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint& paint,
                                 SkShader::Context* shaderContext,
-                                SkTBlitterAllocator* allocator) {
-    return create<StateF16>(device, paint, shaderContext, allocator);
+                                SkArenaAlloc* alloc) {
+    return create<StateF16>(device, paint, shaderContext, alloc);
 }
diff --git a/src/core/SkBlitter_RGB16.cpp b/src/core/SkBlitter_RGB16.cpp
index afa8cac184..e91e23fd69 100644
--- a/src/core/SkBlitter_RGB16.cpp
+++ b/src/core/SkBlitter_RGB16.cpp
@@ -5,6 +5,7 @@
  * found in the LICENSE file.
  */
 
+#include "SkArenaAlloc.h"
 #include "SkBlitRow.h"
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
@@ -880,8 +881,8 @@ void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y,
 
 SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
         SkShader::Context* shaderContext,
-        SkTBlitterAllocator* allocator) {
-    SkASSERT(allocator != nullptr);
+        SkArenaAlloc* alloc) {
+    SkASSERT(alloc != nullptr);
 
     SkBlitter* blitter;
     SkShader* shader = paint.getShader();
@@ -893,24 +894,24 @@ SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
     if (shader) {
         SkASSERT(shaderContext != nullptr);
         if (!is_srcover) {
-            blitter = allocator->createT<SkRGB16_Shader_Xfermode_Blitter>(device, paint,
+            blitter = alloc->make<SkRGB16_Shader_Xfermode_Blitter>(device, paint,
                                                                           shaderContext);
         } else {
-            blitter = allocator->createT<SkRGB16_Shader_Blitter>(device, paint, shaderContext);
+            blitter = alloc->make<SkRGB16_Shader_Blitter>(device, paint, shaderContext);
         }
     } else {
         // no shader, no xfermode, (and we always ignore colorfilter)
         SkColor color = paint.getColor();
         if (0 == SkColorGetA(color)) {
-            blitter = allocator->createT<SkNullBlitter>();
+            blitter = alloc->make<SkNullBlitter>();
 #ifdef USE_BLACK_BLITTER
         } else if (SK_ColorBLACK == color) {
-            blitter = allocator->createT<SkRGB16_Black_Blitter>(device, paint);
+            blitter = alloc->make<SkRGB16_Black_Blitter>(device, paint);
 #endif
         } else if (0xFF == SkColorGetA(color)) {
-            blitter = allocator->createT<SkRGB16_Opaque_Blitter>(device, paint);
+            blitter = alloc->make<SkRGB16_Opaque_Blitter>(device, paint);
         } else {
-            blitter = allocator->createT<SkRGB16_Blitter>(device, paint);
+            blitter = alloc->make<SkRGB16_Blitter>(device, paint);
         }
     }
 
diff --git a/src/core/SkColorFilterShader.cpp b/src/core/SkColorFilterShader.cpp
index 4090a18b45..5e96b24b41 100644
--- a/src/core/SkColorFilterShader.cpp
+++ b/src/core/SkColorFilterShader.cpp
@@ -5,6 +5,7 @@
  * found in the LICENSE file.
  */
 
+#include "SkArenaAlloc.h"
 #include "SkColorFilterShader.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ -52,19 +53,15 @@ uint32_t SkColorFilterShader::FilterShaderContext::getFlags() const {
     return shaderF;
 }
 
-SkShader::Context* SkColorFilterShader::onCreateContext(const ContextRec& rec,
-                                                        void* storage) const {
-    char* shaderContextStorage = (char*)storage + sizeof(FilterShaderContext);
-    SkShader::Context* shaderContext = fShader->createContext(rec, shaderContextStorage);
+SkShader::Context* SkColorFilterShader::onMakeContext(const ContextRec& rec,
+                                                      SkArenaAlloc* alloc) const {
+    SkShader::Context* shaderContext = fShader->makeContext(rec, alloc);
     if (nullptr == shaderContext) {
         return nullptr;
     }
-    return new (storage) FilterShaderContext(*this, shaderContext, rec);
+    return alloc->make<FilterShaderContext>(*this, shaderContext, rec);
 }
 
-size_t SkColorFilterShader::onContextSize(const ContextRec& rec) const {
-    return sizeof(FilterShaderContext) + fShader->contextSize(rec);
-}
 
 SkColorFilterShader::FilterShaderContext::FilterShaderContext(
                                                          const SkColorFilterShader& filterShader,
@@ -74,10 +71,6 @@ SkColorFilterShader::FilterShaderContext::FilterShaderContext(
     , fShaderContext(shaderContext)
 {}
 
-SkColorFilterShader::FilterShaderContext::~FilterShaderContext() {
-    fShaderContext->~Context();
-}
-
 void SkColorFilterShader::FilterShaderContext::shadeSpan(int x, int y, SkPMColor result[],
                                                          int count) {
     const SkColorFilterShader& filterShader = static_cast<const SkColorFilterShader&>(fShader);
diff --git a/src/core/SkColorFilterShader.h b/src/core/SkColorFilterShader.h
index 035acd8397..e697736ae8 100644
--- a/src/core/SkColorFilterShader.h
+++ b/src/core/SkColorFilterShader.h
@@ -11,6 +11,8 @@
 #include "SkColorFilter.h"
 #include "SkShader.h"
 
+class SkArenaAlloc;
+
 class SkColorFilterShader : public SkShader {
 public:
     SkColorFilterShader(sk_sp<SkShader> shader, sk_sp<SkColorFilter> filter);
@@ -23,7 +25,6 @@ public:
     public:
         // Takes ownership of shaderContext and calls its destructor.
         FilterShaderContext(const SkColorFilterShader&, SkShader::Context*, const ContextRec&);
-        virtual ~FilterShaderContext();
 
         uint32_t getFlags() const override;
 
@@ -46,8 +47,7 @@ public:
 
 protected:
     void flatten(SkWriteBuffer&) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc* alloc) const override;
 
 private:
     sk_sp<SkShader>      fShader;
diff --git a/src/core/SkColorShader.cpp b/src/core/SkColorShader.cpp
index ed2a26b931..32d9b430c7 100644
--- a/src/core/SkColorShader.cpp
+++ b/src/core/SkColorShader.cpp
@@ -31,8 +31,8 @@ uint32_t SkColorShader::ColorShaderContext::getFlags() const {
     return fFlags;
 }
 
-SkShader::Context* SkColorShader::onCreateContext(const ContextRec& rec, void* storage) const {
-    return new (storage) ColorShaderContext(*this, rec);
+SkShader::Context* SkColorShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
+    return alloc->make<ColorShaderContext>(*this, rec);
 }
 
 SkColorShader::ColorShaderContext::ColorShaderContext(const SkColorShader& shader,
@@ -149,8 +149,8 @@ uint32_t SkColor4Shader::Color4Context::getFlags() const {
     return fFlags;
 }
 
-SkShader::Context* SkColor4Shader::onCreateContext(const ContextRec& rec, void* storage) const {
-    return new (storage) Color4Context(*this, rec);
+SkShader::Context* SkColor4Shader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
+    return alloc->make<Color4Context>(*this, rec);
 }
 
 SkColor4Shader::Color4Context::Color4Context(const SkColor4Shader& shader,
diff --git a/src/core/SkColorShader.h b/src/core/SkColorShader.h
index 813fd3e892..b9db657b2b 100644
--- a/src/core/SkColorShader.h
+++ b/src/core/SkColorShader.h
@@ -59,12 +59,13 @@ public:
 protected:
     SkColorShader(SkReadBuffer&);
     void flatten(SkWriteBuffer&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
-    size_t onContextSize(const ContextRec&) const override { return sizeof(ColorShaderContext); }
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc* storage) const override;
+
     bool onAsLuminanceColor(SkColor* lum) const override {
         *lum = fColor;
         return true;
     }
+
     bool onAppendStages(SkRasterPipeline*, SkColorSpace*, SkArenaAlloc*,
                         const SkMatrix& ctm, const SkPaint&, const SkMatrix*) const override;
 
@@ -115,8 +116,7 @@ public:
 protected:
     SkColor4Shader(SkReadBuffer&);
     void flatten(SkWriteBuffer&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
-    size_t onContextSize(const ContextRec&) const override { return sizeof(Color4Context); }
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
     bool onAsLuminanceColor(SkColor* lum) const override {
         *lum = fCachedByteColor;
         return true;
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 5cbd23eb08..07bbd9a092 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -5,6 +5,7 @@
  * found in the LICENSE file.
  */
 
+#include "SkArenaAlloc.h"
 #include "SkComposeShader.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
@@ -29,12 +30,6 @@ sk_sp<SkShader> SkShader::MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-size_t SkComposeShader::onContextSize(const ContextRec& rec) const {
-    return sizeof(ComposeShaderContext)
-        + fShaderA->contextSize(rec)
-        + fShaderB->contextSize(rec);
-}
-
 class SkAutoAlphaRestore {
 public:
     SkAutoAlphaRestore(SkPaint* paint, uint8_t newAlpha) {
@@ -80,10 +75,9 @@ template <typename T> void safe_call_destructor(T* obj) {
     }
 }
 
-SkShader::Context* SkComposeShader::onCreateContext(const ContextRec& rec, void* storage) const {
-    char* aStorage = (char*) storage + sizeof(ComposeShaderContext);
-    char* bStorage = aStorage + fShaderA->contextSize(rec);
-
+SkShader::Context* SkComposeShader::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const
+{
     // we preconcat our localMatrix (if any) with the device matrix
     // before calling our sub-shaders
     SkMatrix tmpM;
@@ -99,15 +93,15 @@ SkShader::Context* SkComposeShader::onCreateContext(const ContextRec& rec, void*
     newRec.fMatrix = &tmpM;
     newRec.fPaint = &opaquePaint;
 
-    SkShader::Context* contextA = fShaderA->createContext(newRec, aStorage);
-    SkShader::Context* contextB = fShaderB->createContext(newRec, bStorage);
+    SkShader::Context* contextA = fShaderA->makeContext(newRec, alloc);
+    SkShader::Context* contextB = fShaderB->makeContext(newRec, alloc);
     if (!contextA || !contextB) {
         safe_call_destructor(contextA);
         safe_call_destructor(contextB);
         return nullptr;
     }
 
-    return new (storage) ComposeShaderContext(*this, rec, contextA, contextB);
+    return alloc->make<ComposeShaderContext>(*this, rec, contextA, contextB);
 }
 
 SkComposeShader::ComposeShaderContext::ComposeShaderContext(
@@ -117,11 +111,6 @@ SkComposeShader::ComposeShaderContext::ComposeShaderContext(
     , fShaderContextA(contextA)
     , fShaderContextB(contextB) {}
 
-SkComposeShader::ComposeShaderContext::~ComposeShaderContext() {
-    fShaderContextA->~Context();
-    fShaderContextB->~Context();
-}
-
 bool SkComposeShader::asACompose(ComposeRec* rec) const {
     if (rec) {
         rec->fShaderA   = fShaderA.get();
diff --git a/src/core/SkComposeShader.h b/src/core/SkComposeShader.h
index 7f9ff69ca8..be788af2af 100644
--- a/src/core/SkComposeShader.h
+++ b/src/core/SkComposeShader.h
@@ -45,8 +45,6 @@ public:
         ComposeShaderContext(const SkComposeShader&, const ContextRec&,
                              SkShader::Context* contextA, SkShader::Context* contextB);
 
-        virtual ~ComposeShaderContext();
-
         void shadeSpan(int x, int y, SkPMColor[], int count) override;
 
     private:
@@ -69,8 +67,7 @@ public:
 protected:
     SkComposeShader(SkReadBuffer&);
     void flatten(SkWriteBuffer&) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void*) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
 private:
     sk_sp<SkShader>     fShaderA;
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 62bf73e6a2..63ddda9b13 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -178,10 +178,10 @@ private:
 };
 
 SkBlitter* SkBlitter_ARGB32_Create(const SkPixmap& device, const SkPaint&, SkShader::Context*,
-                                   SkTBlitterAllocator*);
+                                   SkArenaAlloc*);
 
 SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint&, SkShader::Context*,
-                                SkTBlitterAllocator*);
+                                SkArenaAlloc*);
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -200,11 +200,11 @@ SkBlitter* SkBlitter_F16_Create(const SkPixmap& device, const SkPaint&, SkShader
 
 SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
                                 SkShader::Context* shaderContext,
-                                SkTBlitterAllocator* allocator);
+                                SkArenaAlloc* allocator);
 
 
 // Returns nullptr if no SkRasterPipeline blitter can be constructed for this paint.
 SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap&, const SkPaint&, const SkMatrix& ctm,
-                                         SkTBlitterAllocator*);
+                                         SkArenaAlloc*);
 
 #endif
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index dd39d9eb97..2891c95fdd 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -7,6 +7,8 @@
 #define __STDC_LIMIT_MACROS
 
 #include "SkDraw.h"
+
+#include "SkArenaAlloc.h"
 #include "SkBlendModePriv.h"
 #include "SkBlitter.h"
 #include "SkCanvas.h"
@@ -53,7 +55,7 @@ public:
     }
     SkAutoBlitterChoose(const SkPixmap& dst, const SkMatrix& matrix,
                         const SkPaint& paint, bool drawCoverage = false) {
-        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
+        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAlloc, drawCoverage);
     }
 
     SkBlitter*  operator->() { return fBlitter; }
@@ -62,13 +64,16 @@ public:
     void choose(const SkPixmap& dst, const SkMatrix& matrix,
                 const SkPaint& paint, bool drawCoverage = false) {
         SkASSERT(!fBlitter);
-        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
+        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAlloc, drawCoverage);
     }
 
 private:
     // Owned by fAllocator, which will handle the delete.
     SkBlitter*          fBlitter;
     SkTBlitterAllocator fAllocator;
+
+    // FIXME - pick a good inline and number.
+    SkArenaAlloc fAlloc{1024};
 };
 #define SkAutoBlitterChoose(...) SK_REQUIRE_LOCAL_VAR(SkAutoBlitterChoose)
 
@@ -82,6 +87,8 @@ public:
     SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint,
                               const SkMatrix* localMatrix = nullptr)
             : fPaint(paint) /* makes a copy of the paint */ {
+        // TODO(herb): Move this over to SkArenaAlloc when arena alloc has a
+        // facility to return sk_sps.
         fPaint.setShader(SkMakeBitmapShader(src, SkShader::kClamp_TileMode,
                                             SkShader::kClamp_TileMode, localMatrix,
                                             kNever_SkCopyPixelsMode,
@@ -1769,9 +1776,8 @@ public:
     }
 
 protected:
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec& rec, void* storage) const override {
-        return new (storage) TriColorShaderContext(*this, rec);
+    Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const override {
+        return alloc->make<TriColorShaderContext>(*this, rec);
     }
 
 private:
@@ -1827,10 +1833,6 @@ SkTriColorShader::TriColorShaderContext::TriColorShaderContext(const SkTriColorS
 
 SkTriColorShader::TriColorShaderContext::~TriColorShaderContext() {}
 
-size_t SkTriColorShader::onContextSize(const ContextRec&) const {
-    return sizeof(TriColorShaderContext);
-}
-
 void SkTriColorShader::TriColorShaderContext::shadeSpan(int x, int y, SkPMColor dstC[], int count) {
     SkTriColorShader* parent = static_cast<SkTriColorShader*>(const_cast<SkShader*>(&fShader));
     TriColorShaderData* set = parent->takeSetupData();
diff --git a/src/core/SkEmptyShader.h b/src/core/SkEmptyShader.h
index 528ceeabee..b2c9b76792 100644
--- a/src/core/SkEmptyShader.h
+++ b/src/core/SkEmptyShader.h
@@ -24,13 +24,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmptyShader)
 
 protected:
-    size_t onContextSize(const ContextRec&) const override {
-        // Even though createContext returns nullptr we have to return a value of at least
-        // sizeof(SkShader::Context) to satisfy SkSmallAllocator.
-        return sizeof(SkShader::Context);
-    }
-
-    SkShader::Context* onCreateContext(const ContextRec&, void*) const override {
+    SkShader::Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override {
         return nullptr;
     }
 
diff --git a/src/core/SkLightingShader.cpp b/src/core/SkLightingShader.cpp
index 4ed0057682..5bdaee5594 100644
--- a/src/core/SkLightingShader.cpp
+++ b/src/core/SkLightingShader.cpp
@@ -5,6 +5,7 @@
  * found in the LICENSE file.
  */
 
+#include "SkArenaAlloc.h"
 #include "SkBitmapProcShader.h"
 #include "SkBitmapProcState.h"
 #include "SkColor.h"
@@ -63,8 +64,6 @@ public:
                               SkShader::Context* diffuseContext, SkNormalSource::Provider*,
                               void* heapAllocated);
 
-        ~LightingShaderContext() override;
-
         void shadeSpan(int x, int y, SkPMColor[], int count) override;
 
         uint32_t getFlags() const override { return fFlags; }
@@ -75,8 +74,6 @@ public:
         SkColor                   fPaintColor;
         uint32_t                  fFlags;
 
-        void* fHeapAllocated;
-
         typedef SkShader::Context INHERITED;
     };
 
@@ -85,8 +82,7 @@ public:
 
 protected:
     void flatten(SkWriteBuffer&) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void*) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
 private:
     sk_sp<SkShader> fDiffuseShader;
@@ -309,8 +305,7 @@ SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(
         void* heapAllocated)
     : INHERITED(shader, rec)
     , fDiffuseContext(diffuseContext)
-    , fNormalProvider(normalProvider)
-    , fHeapAllocated(heapAllocated) {
+    , fNormalProvider(normalProvider) {
     bool isOpaque = shader.isOpaque();
 
     // update fFlags
@@ -323,17 +318,6 @@ SkLightingShaderImpl::LightingShaderContext::LightingShaderContext(
     fFlags = flags;
 }
 
-SkLightingShaderImpl::LightingShaderContext::~LightingShaderContext() {
-    // The dependencies have been created outside of the context on memory that was allocated by
-    // the onCreateContext() method. Call the destructors and free the memory.
-    if (fDiffuseContext) {
-        fDiffuseContext->~Context();
-    }
-    fNormalProvider->~Provider();
-
-    sk_free(fHeapAllocated);
-}
-
 static inline SkPMColor convert(SkColor3f color, U8CPU a) {
     if (color.fX <= 0.0f) {
         color.fX = 0.0f;
@@ -457,39 +441,23 @@ void SkLightingShaderImpl::flatten(SkWriteBuffer& buf) const {
     }
 }
 
-size_t SkLightingShaderImpl::onContextSize(const ContextRec& rec) const {
-    return sizeof(LightingShaderContext);
-}
-
-SkShader::Context* SkLightingShaderImpl::onCreateContext(const ContextRec& rec,
-                                                         void* storage) const {
-    size_t heapRequired = (fDiffuseShader ? fDiffuseShader->contextSize(rec) : 0) +
-                          fNormalSource->providerSize(rec);
-    void* heapAllocated = sk_malloc_throw(heapRequired);
-
-    void* diffuseContextStorage = heapAllocated;
-    void* normalProviderStorage = (char*) diffuseContextStorage +
-                                  (fDiffuseShader ? fDiffuseShader->contextSize(rec) : 0);
-
+SkShader::Context* SkLightingShaderImpl::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const
+{
     SkShader::Context *diffuseContext = nullptr;
     if (fDiffuseShader) {
-        diffuseContext = fDiffuseShader->createContext(rec, diffuseContextStorage);
+        diffuseContext = fDiffuseShader->makeContext(rec, alloc);
         if (!diffuseContext) {
-            sk_free(heapAllocated);
             return nullptr;
         }
     }
 
-    SkNormalSource::Provider* normalProvider = fNormalSource->asProvider(rec,
-                                                                         normalProviderStorage);
+    SkNormalSource::Provider* normalProvider = fNormalSource->asProvider(rec, alloc);
     if (!normalProvider) {
-        diffuseContext->~Context();
-        sk_free(heapAllocated);
         return nullptr;
     }
 
-    return new (storage) LightingShaderContext(*this, rec, diffuseContext, normalProvider,
-                                               heapAllocated);
+    return alloc->make<LightingShaderContext>(*this, rec, diffuseContext, normalProvider, nullptr);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp
index 7a0a3697bd..9d9e109fcb 100644
--- a/src/core/SkLocalMatrixShader.cpp
+++ b/src/core/SkLocalMatrixShader.cpp
@@ -37,8 +37,9 @@ void SkLocalMatrixShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeFlattenable(fProxyShader.get());
 }
 
-SkShader::Context* SkLocalMatrixShader::onCreateContext(const ContextRec& rec,
-                                                        void* storage) const {
+SkShader::Context* SkLocalMatrixShader::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const
+{
     ContextRec newRec(rec);
     SkMatrix tmp;
     if (rec.fLocalMatrix) {
@@ -47,7 +48,7 @@ SkShader::Context* SkLocalMatrixShader::onCreateContext(const ContextRec& rec,
     } else {
         newRec.fLocalMatrix = &this->getLocalMatrix();
     }
-    return fProxyShader->createContext(newRec, storage);
+    return fProxyShader->makeContext(newRec, alloc);
 }
 
 bool SkLocalMatrixShader::onAppendStages(SkRasterPipeline* p,
diff --git a/src/core/SkLocalMatrixShader.h b/src/core/SkLocalMatrixShader.h
index 0641abe461..5c0424053b 100644
--- a/src/core/SkLocalMatrixShader.h
+++ b/src/core/SkLocalMatrixShader.h
@@ -13,6 +13,7 @@
 #include "SkWriteBuffer.h"
 
 class GrFragmentProcessor;
+class SkArenaAlloc;
 
 class SkLocalMatrixShader : public SkShader {
 public:
@@ -41,11 +42,8 @@ public:
 
 protected:
     void flatten(SkWriteBuffer&) const override;
-    Context* onCreateContext(const ContextRec&, void*) const override;
 
-    size_t onContextSize(const ContextRec& rec) const override {
-        return fProxyShader->contextSize(rec);
-    }
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
     SkImage* onIsAImage(SkMatrix* matrix, TileMode* mode) const override {
         return fProxyShader->isAImage(matrix, mode);
diff --git a/src/core/SkNormalBevelSource.cpp b/src/core/SkNormalBevelSource.cpp
index 5d49253b01..5ff7d8231f 100644
--- a/src/core/SkNormalBevelSource.cpp
+++ b/src/core/SkNormalBevelSource.cpp
@@ -7,6 +7,7 @@
 
 #include "SkNormalBevelSource.h"
 
+#include "SkArenaAlloc.h"
 #include "SkNormalSource.h"
 #include "SkNormalSourcePriv.h"
 #include "SkPoint3.h"
@@ -263,12 +264,8 @@ SkNormalBevelSourceImpl::Provider::Provider() {}
 SkNormalBevelSourceImpl::Provider::~Provider() {}
 
 SkNormalSource::Provider* SkNormalBevelSourceImpl::asProvider(const SkShader::ContextRec &rec,
-                                                              void *storage) const {
-    return new (storage) Provider();
-}
-
-size_t SkNormalBevelSourceImpl::providerSize(const SkShader::ContextRec&) const {
-    return sizeof(Provider);
+                                                              SkArenaAlloc* alloc) const {
+    return alloc->make<Provider>();
 }
 
 // TODO Implement feature for the CPU pipeline
diff --git a/src/core/SkNormalBevelSource.h b/src/core/SkNormalBevelSource.h
index d133738bce..1d1983c66a 100644
--- a/src/core/SkNormalBevelSource.h
+++ b/src/core/SkNormalBevelSource.h
@@ -22,8 +22,7 @@ public:
 #endif
 
     SkNormalSource::Provider* asProvider(const SkShader::ContextRec& rec,
-                                         void* storage) const override;
-    size_t providerSize(const SkShader::ContextRec& rec) const override;
+                                         SkArenaAlloc*) const override;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNormalBevelSourceImpl)
 
diff --git a/src/core/SkNormalFlatSource.cpp b/src/core/SkNormalFlatSource.cpp
index b4ed977285..73ef549747 100644
--- a/src/core/SkNormalFlatSource.cpp
+++ b/src/core/SkNormalFlatSource.cpp
@@ -7,6 +7,7 @@
 
 #include "SkNormalFlatSource.h"
 
+#include "SkArenaAlloc.h"
 #include "SkNormalSource.h"
 #include "SkNormalSourcePriv.h"
 #include "SkPoint3.h"
@@ -77,12 +78,8 @@ SkNormalFlatSourceImpl::Provider::Provider() {}
 SkNormalFlatSourceImpl::Provider::~Provider() {}
 
 SkNormalSource::Provider* SkNormalFlatSourceImpl::asProvider(const SkShader::ContextRec &rec,
-                                                             void *storage) const {
-    return new (storage) Provider();
-}
-
-size_t SkNormalFlatSourceImpl::providerSize(const SkShader::ContextRec&) const {
-    return sizeof(Provider);
+                                                             SkArenaAlloc *alloc) const {
+    return alloc->make<Provider>();
 }
 
 void SkNormalFlatSourceImpl::Provider::fillScanLine(int x, int y, SkPoint3 output[],
diff --git a/src/core/SkNormalFlatSource.h b/src/core/SkNormalFlatSource.h
index e1295596b9..4a8f74304b 100644
--- a/src/core/SkNormalFlatSource.h
+++ b/src/core/SkNormalFlatSource.h
@@ -19,8 +19,7 @@ public:
 #endif
 
     SkNormalSource::Provider* asProvider(const SkShader::ContextRec& rec,
-                                         void* storage) const override;
-    size_t providerSize(const SkShader::ContextRec& rec) const override;
+                                         SkArenaAlloc* alloc) const override;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNormalFlatSourceImpl)
 
diff --git a/src/core/SkNormalMapSource.cpp b/src/core/SkNormalMapSource.cpp
index 3a9f9cf76f..2d3d24181d 100644
--- a/src/core/SkNormalMapSource.cpp
+++ b/src/core/SkNormalMapSource.cpp
@@ -7,6 +7,7 @@
 
 #include "SkNormalMapSource.h"
 
+#include "SkArenaAlloc.h"
 #include "SkLightingShader.h"
 #include "SkMatrix.h"
 #include "SkNormalSource.h"
@@ -136,42 +137,29 @@ sk_sp<GrFragmentProcessor> SkNormalMapSourceImpl::asFragmentProcessor(
 ////////////////////////////////////////////////////////////////////////////
 
 SkNormalMapSourceImpl::Provider::Provider(const SkNormalMapSourceImpl& source,
-                                          SkShader::Context* mapContext,
-                                          SkPaint* overridePaint)
+                                          SkShader::Context* mapContext)
     : fSource(source)
-    , fMapContext(mapContext)
-    , fOverridePaint(overridePaint) {}
-
-SkNormalMapSourceImpl::Provider::~Provider() {
-    fMapContext->~Context();
-    fOverridePaint->~SkPaint();
-}
+    , fMapContext(mapContext) {}
 
 SkNormalSource::Provider* SkNormalMapSourceImpl::asProvider(const SkShader::ContextRec &rec,
-                                                            void *storage) const {
+                                                            SkArenaAlloc* alloc) const {
     SkMatrix normTotalInv;
     if (!this->computeNormTotalInverse(rec, &normTotalInv)) {
         return nullptr;
     }
 
     // Overriding paint's alpha because we need the normal map's RGB channels to be unpremul'd
-    void* paintStorage = (char*)storage + sizeof(Provider);
-    SkPaint* overridePaint = new (paintStorage) SkPaint(*(rec.fPaint));
-    overridePaint->setAlpha(0xFF);
-    SkShader::ContextRec overrideRec(*overridePaint, *(rec.fMatrix), rec.fLocalMatrix,
+    SkPaint overridePaint {*(rec.fPaint)};
+    overridePaint.setAlpha(0xFF);
+    SkShader::ContextRec overrideRec(overridePaint, *(rec.fMatrix), rec.fLocalMatrix,
                                      rec.fPreferredDstType, rec.fDstColorSpace);
 
-    void* mapContextStorage = (char*) paintStorage + sizeof(SkPaint);
-    SkShader::Context* context = fMapShader->createContext(overrideRec, mapContextStorage);
+    SkShader::Context* context = fMapShader->makeContext(overrideRec, alloc);
     if (!context) {
         return nullptr;
     }
 
-    return new (storage) Provider(*this, context, overridePaint);
-}
-
-size_t SkNormalMapSourceImpl::providerSize(const SkShader::ContextRec& rec) const {
-    return sizeof(Provider) + sizeof(SkPaint) + fMapShader->contextSize(rec);
+    return alloc->make<Provider>(*this, context);
 }
 
 bool SkNormalMapSourceImpl::computeNormTotalInverse(const SkShader::ContextRec& rec,
diff --git a/src/core/SkNormalMapSource.h b/src/core/SkNormalMapSource.h
index 5908369fc7..f2b07f21e9 100644
--- a/src/core/SkNormalMapSource.h
+++ b/src/core/SkNormalMapSource.h
@@ -21,8 +21,7 @@ public:
 #endif
 
     SkNormalSource::Provider* asProvider(const SkShader::ContextRec& rec,
-                                         void* storage) const override;
-    size_t providerSize(const SkShader::ContextRec& rec) const override;
+                                         SkArenaAlloc* alloc) const override;
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNormalMapSourceImpl)
 
@@ -34,10 +33,7 @@ protected:
 private:
     class Provider : public SkNormalSource::Provider {
     public:
-        Provider(const SkNormalMapSourceImpl& source, SkShader::Context* mapContext,
-                 SkPaint* overridePaint);
-
-        virtual ~Provider() override;
+        Provider(const SkNormalMapSourceImpl& source, SkShader::Context* mapContext);
 
         void fillScanLine(int x, int y, SkPoint3 output[], int count) const override;
 
@@ -45,8 +41,6 @@ private:
         const SkNormalMapSourceImpl& fSource;
         SkShader::Context* fMapContext;
 
-        SkPaint* fOverridePaint;
-
         typedef SkNormalSource::Provider INHERITED;
     };
 
diff --git a/src/core/SkNormalSource.h b/src/core/SkNormalSource.h
index 32ef08ce52..221c09db99 100644
--- a/src/core/SkNormalSource.h
+++ b/src/core/SkNormalSource.h
@@ -44,11 +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&, void* storage) const = 0;
-
-    /** Amount of memory needed to store a provider object and its dependencies.
-     */
-    virtual size_t providerSize(const SkShader::ContextRec&) const = 0;
+    virtual Provider* asProvider(const SkShader::ContextRec&, SkArenaAlloc*) const = 0;
 
     /** Returns a normal source that provides normals sourced from the the normal map argument.
 
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index bdb6d060a7..71026824cd 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -243,19 +243,6 @@ sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, con
     return tileShader;
 }
 
-size_t SkPictureShader::onContextSize(const ContextRec&) const {
-    return sizeof(PictureShaderContext);
-}
-
-SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
-    sk_sp<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix,
-                                                       rec.fDstColorSpace));
-    if (!bitmapShader) {
-        return nullptr;
-    }
-    return PictureShaderContext::Create(storage, *this, rec, bitmapShader);
-}
-
 bool SkPictureShader::onAppendStages(SkRasterPipeline* p, SkColorSpace* cs, SkArenaAlloc* alloc,
                                      const SkMatrix& ctm, const SkPaint& paint,
                                      const SkMatrix* localMatrix) const {
@@ -266,36 +253,34 @@ bool SkPictureShader::onAppendStages(SkRasterPipeline* p, SkColorSpace* cs, SkAr
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
+SkShader::Context* SkPictureShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc)
+const {
+    sk_sp<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix,
+                                                       rec.fDstColorSpace));
+    if (!bitmapShader) {
+        return nullptr;
+    }
 
-SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage,
-                   const SkPictureShader& shader, const ContextRec& rec,
-                                                                 sk_sp<SkShader> bitmapShader) {
-    PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec,
-                                                                   std::move(bitmapShader));
+    PictureShaderContext* ctx =
+        alloc->make<PictureShaderContext>(*this, rec, std::move(bitmapShader), alloc);
     if (nullptr == ctx->fBitmapShaderContext) {
-        ctx->~PictureShaderContext();
         ctx = nullptr;
     }
     return ctx;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////
+
 SkPictureShader::PictureShaderContext::PictureShaderContext(
-        const SkPictureShader& shader, const ContextRec& rec, sk_sp<SkShader> bitmapShader)
+        const SkPictureShader& shader, const ContextRec& rec, sk_sp<SkShader> bitmapShader,
+        SkArenaAlloc* alloc)
     : INHERITED(shader, rec)
     , fBitmapShader(std::move(bitmapShader))
 {
-    fBitmapShaderContextStorage = sk_malloc_throw(fBitmapShader->contextSize(rec));
-    fBitmapShaderContext = fBitmapShader->createContext(rec, fBitmapShaderContextStorage);
+    fBitmapShaderContext = fBitmapShader->makeContext(rec, alloc);
     //if fBitmapShaderContext is null, we are invalid
 }
 
-SkPictureShader::PictureShaderContext::~PictureShaderContext() {
-    if (fBitmapShaderContext) {
-        fBitmapShaderContext->~Context();
-    }
-    sk_free(fBitmapShaderContextStorage);
-}
-
 uint32_t SkPictureShader::PictureShaderContext::getFlags() const {
     SkASSERT(fBitmapShaderContext);
     return fBitmapShaderContext->getFlags();
diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h
index ff83fa3bb8..9807cd9482 100644
--- a/src/core/SkPictureShader.h
+++ b/src/core/SkPictureShader.h
@@ -10,6 +10,7 @@
 
 #include "SkShader.h"
 
+class SkArenaAlloc;
 class SkBitmap;
 class SkPicture;
 
@@ -34,10 +35,9 @@ public:
 protected:
     SkPictureShader(SkReadBuffer&);
     void flatten(SkWriteBuffer&) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
     bool onAppendStages(SkRasterPipeline*, SkColorSpace*, SkArenaAlloc*,
                         const SkMatrix&, const SkPaint&, const SkMatrix*) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
 private:
     SkPictureShader(sk_sp<SkPicture>, TileMode, TileMode, const SkMatrix*, const SkRect*);
@@ -52,20 +52,14 @@ private:
 
     class PictureShaderContext : public SkShader::Context {
     public:
-        static Context* Create(void* storage, const SkPictureShader&, const ContextRec&,
-                               sk_sp<SkShader> bitmapShader);
-
-        virtual ~PictureShaderContext();
+        PictureShaderContext(
+            const SkPictureShader&, const ContextRec&, sk_sp<SkShader> bitmapShader, SkArenaAlloc*);
 
         uint32_t getFlags() const override;
 
         ShadeProc asAShadeProc(void** ctx) override;
         void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
 
-    private:
-        PictureShaderContext(const SkPictureShader&, const ContextRec&,
-                             sk_sp<SkShader> bitmapShader);
-
         sk_sp<SkShader>     fBitmapShader;
         SkShader::Context*  fBitmapShaderContext;
         void*               fBitmapShaderContextStorage;
diff --git a/src/core/SkRasterPipelineBlitter.cpp b/src/core/SkRasterPipelineBlitter.cpp
index bb89f76b8f..1a00009734 100644
--- a/src/core/SkRasterPipelineBlitter.cpp
+++ b/src/core/SkRasterPipelineBlitter.cpp
@@ -21,7 +21,7 @@
 class SkRasterPipelineBlitter : public SkBlitter {
 public:
     static SkBlitter* Create(const SkPixmap&, const SkPaint&, const SkMatrix& ctm,
-                             SkTBlitterAllocator*);
+                             SkArenaAlloc*);
 
     SkRasterPipelineBlitter(SkPixmap dst, SkBlendMode blend, SkPM4f paintColor)
         : fDst(dst)
@@ -71,7 +71,7 @@ private:
 SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
                                          const SkPaint& paint,
                                          const SkMatrix& ctm,
-                                         SkTBlitterAllocator* alloc) {
+                                         SkArenaAlloc* alloc) {
     return SkRasterPipelineBlitter::Create(dst, paint, ctm, alloc);
 }
 
@@ -88,16 +88,12 @@ static bool supported(const SkImageInfo& info) {
 SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
                                            const SkPaint& paint,
                                            const SkMatrix& ctm,
-                                           SkTBlitterAllocator* alloc) {
-    auto blitter = alloc->createT<SkRasterPipelineBlitter>(
+                                           SkArenaAlloc* alloc) {
+    auto blitter = alloc->make<SkRasterPipelineBlitter>(
             dst,
             paint.getBlendMode(),
             SkPM4f_from_SkColor(paint.getColor(), dst.colorSpace()));
 
-    auto earlyOut = [&] {
-        alloc->deleteLast();
-        return nullptr;
-    };
 
     SkBlendMode*      blend       = &blitter->fBlend;
     SkPM4f*           paintColor  = &blitter->fPaintColor;
@@ -108,7 +104,7 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
 
     // TODO: all temporary
     if (!supported(dst.info()) || !SkBlendMode_AppendStages(*blend)) {
-        return earlyOut();
+        return nullptr;
     }
 
     bool is_opaque   = paintColor->a() == 1.0f,
@@ -117,7 +113,7 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
         pipeline->append(SkRasterPipeline::seed_shader, &blitter->fCurrentY);
         if (!shader->appendStages(pipeline, dst.colorSpace(), &blitter->fArena,
                                   ctm, paint)) {
-            return earlyOut();
+            return nullptr;
         }
         if (!is_opaque) {
             pipeline->append(SkRasterPipeline::scale_1_float,
@@ -133,7 +129,7 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
     if (colorFilter) {
         if (!colorFilter->appendStages(pipeline, dst.colorSpace(), &blitter->fArena,
                                        is_opaque)) {
-            return earlyOut();
+            return nullptr;
         }
         is_opaque = is_opaque && (colorFilter->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
     }
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 9f97a7a74a..9da760f843 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -90,23 +90,11 @@ bool SkShader::asLuminanceColor(SkColor* colorPtr) const {
     return false;
 }
 
-SkShader::Context* SkShader::createContext(const ContextRec& rec, void* storage) const {
+SkShader::Context* SkShader::makeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
     if (!this->computeTotalInverse(rec, nullptr)) {
         return nullptr;
     }
-    return this->onCreateContext(rec, storage);
-}
-
-SkShader::Context* SkShader::onCreateContext(const ContextRec& rec, void*) const {
-    return nullptr;
-}
-
-size_t SkShader::contextSize(const ContextRec& rec) const {
-    return this->onContextSize(rec);
-}
-
-size_t SkShader::onContextSize(const ContextRec&) const {
-    return 0;
+    return this->onMakeContext(rec, alloc);
 }
 
 SkShader::Context::Context(const SkShader& shader, const ContextRec& rec)
@@ -286,16 +274,7 @@ bool SkShader::onAppendStages(SkRasterPipeline* p,
     }
 
     ContextRec rec(*opaquePaint, ctm, localM, ContextRec::kPM4f_DstType, cs);
-    if (auto* ctx = this->createContext(rec,
-                                        alloc->makeArrayDefault<char>(this->contextSize(rec)))) {
-        struct ContextDestroyer {
-            ContextDestroyer(Context* ctx) : fContext(ctx) {}
-            ~ContextDestroyer() { fContext->~Context(); }
-
-            Context* fContext;
-        };
-
-        alloc->make<ContextDestroyer>(ctx);
+    if (auto* ctx = this->makeContext(rec, alloc)) {
         p->append(SkRasterPipeline::shader_adapter, ctx);
 
         // Legacy shaders aren't aware of color spaces. We can pretty
diff --git a/src/effects/SkGaussianEdgeShader.cpp b/src/effects/SkGaussianEdgeShader.cpp
index be05e54711..7bbbb79117 100644
--- a/src/effects/SkGaussianEdgeShader.cpp
+++ b/src/effects/SkGaussianEdgeShader.cpp
@@ -9,6 +9,8 @@
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 
+class SkArenaAlloc;
+
  /** \class SkGaussianEdgeShaderImpl
  This subclass of shader applies a Gaussian to shadow edge
 
@@ -34,7 +36,9 @@ public:
 
 protected:
     void flatten(SkWriteBuffer&) const override;
-
+    Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* storage) const override {
+        return nullptr;
+    }
 private:
     friend class SkGaussianEdgeShader;
 
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index 92f2946c74..7582196573 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -6,6 +6,8 @@
  */
 
 #include "SkPerlinNoiseShader.h"
+
+#include "SkArenaAlloc.h"
 #include "SkColorFilter.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ -434,13 +436,9 @@ SkPMColor SkPerlinNoiseShader::PerlinNoiseShaderContext::shade(
     return SkPreMultiplyARGB(rgba[3], rgba[0], rgba[1], rgba[2]);
 }
 
-SkShader::Context* SkPerlinNoiseShader::onCreateContext(const ContextRec& rec,
-                                                        void* storage) const {
-    return new (storage) PerlinNoiseShaderContext(*this, rec);
-}
-
-size_t SkPerlinNoiseShader::onContextSize(const ContextRec&) const {
-    return sizeof(PerlinNoiseShaderContext);
+SkShader::Context* SkPerlinNoiseShader::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const {
+    return alloc->make<PerlinNoiseShaderContext>(*this, rec);
 }
 
 SkPerlinNoiseShader::PerlinNoiseShaderContext::PerlinNoiseShaderContext(
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index 75b6595926..a9eef7df0e 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -11,6 +11,7 @@
 #include "SkGradientBitmapCache.h"
 #include "SkGradientShader.h"
 
+#include "SkArenaAlloc.h"
 #include "SkAutoMalloc.h"
 #include "SkClampRange.h"
 #include "SkColorPriv.h"
@@ -237,10 +238,9 @@ protected:
                                    int count);
 
     template <typename T, typename... Args>
-    static Context* CheckedCreateContext(void* storage, Args&&... args) {
-        auto* ctx = new (storage) T(std::forward<Args>(args)...);
+    static Context* CheckedMakeContext(SkArenaAlloc* alloc, Args&&... args) {
+        auto* ctx = alloc->make<T>(std::forward<Args>(args)...);
         if (!ctx->isValid()) {
-            ctx->~T();
             return nullptr;
         }
         return ctx;
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 5a74bfd7b9..73247cb113 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -74,16 +74,12 @@ void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
     buffer.writePoint(fEnd);
 }
 
-size_t SkLinearGradient::onContextSize(const ContextRec& rec) const {
-    return use_4f_context(rec, fGradFlags)
-        ? sizeof(LinearGradient4fContext)
-        : sizeof(LinearGradientContext);
-}
-
-SkShader::Context* SkLinearGradient::onCreateContext(const ContextRec& rec, void* storage) const {
+SkShader::Context* SkLinearGradient::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const
+{
     return use_4f_context(rec, fGradFlags)
-        ? CheckedCreateContext<LinearGradient4fContext>(storage, *this, rec)
-        : CheckedCreateContext<  LinearGradientContext>(storage, *this, rec);
+           ? CheckedMakeContext<LinearGradient4fContext>(alloc, *this, rec)
+           : CheckedMakeContext<  LinearGradientContext>(alloc, *this, rec);
 }
 
 // For now, only a 2-stop raster pipeline specialization.
diff --git a/src/effects/gradients/SkLinearGradient.h b/src/effects/gradients/SkLinearGradient.h
index f13599da8a..4118deeae5 100644
--- a/src/effects/gradients/SkLinearGradient.h
+++ b/src/effects/gradients/SkLinearGradient.h
@@ -66,8 +66,7 @@ public:
 protected:
     SkLinearGradient(SkReadBuffer& buffer);
     void flatten(SkWriteBuffer& buffer) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
     bool onAppendStages(SkRasterPipeline*, SkColorSpace*, SkArenaAlloc*,
                         const SkMatrix&, const SkPaint&, const SkMatrix*) const override;
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index a7dca764d5..7e56863993 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -39,12 +39,10 @@ SkRadialGradient::SkRadialGradient(const SkPoint& center, SkScalar radius, const
     , fRadius(radius) {
 }
 
-size_t SkRadialGradient::onContextSize(const ContextRec&) const {
-    return sizeof(RadialGradientContext);
-}
-
-SkShader::Context* SkRadialGradient::onCreateContext(const ContextRec& rec, void* storage) const {
-    return CheckedCreateContext<RadialGradientContext>(storage, *this, rec);
+SkShader::Context* SkRadialGradient::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const
+{
+    return CheckedMakeContext<RadialGradientContext>(alloc, *this, rec);
 }
 
 SkRadialGradient::RadialGradientContext::RadialGradientContext(
diff --git a/src/effects/gradients/SkRadialGradient.h b/src/effects/gradients/SkRadialGradient.h
index 0b239039ee..f92fbb3b72 100644
--- a/src/effects/gradients/SkRadialGradient.h
+++ b/src/effects/gradients/SkRadialGradient.h
@@ -35,8 +35,7 @@ public:
 protected:
     SkRadialGradient(SkReadBuffer& buffer);
     void flatten(SkWriteBuffer& buffer) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
 private:
     const SkPoint fCenter;
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 27d5dbeb7b..928de4c42c 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -45,12 +45,10 @@ void SkSweepGradient::flatten(SkWriteBuffer& buffer) const {
     buffer.writePoint(fCenter);
 }
 
-size_t SkSweepGradient::onContextSize(const ContextRec&) const {
-    return sizeof(SweepGradientContext);
-}
-
-SkShader::Context* SkSweepGradient::onCreateContext(const ContextRec& rec, void* storage) const {
-    return CheckedCreateContext<SweepGradientContext>(storage, *this, rec);
+SkShader::Context* SkSweepGradient::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const
+{
+    return CheckedMakeContext<SweepGradientContext>(alloc, *this, rec);
 }
 
 SkSweepGradient::SweepGradientContext::SweepGradientContext(
diff --git a/src/effects/gradients/SkSweepGradient.h b/src/effects/gradients/SkSweepGradient.h
index f132118b39..30ebb1ad4e 100644
--- a/src/effects/gradients/SkSweepGradient.h
+++ b/src/effects/gradients/SkSweepGradient.h
@@ -35,8 +35,7 @@ public:
 
 protected:
     void flatten(SkWriteBuffer& buffer) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
 private:
     const SkPoint fCenter;
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index 599fd4c9fd..a9740aa455 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -210,13 +210,9 @@ bool SkTwoPointConicalGradient::isOpaque() const {
     return false;
 }
 
-size_t SkTwoPointConicalGradient::onContextSize(const ContextRec&) const {
-    return sizeof(TwoPointConicalGradientContext);
-}
-
-SkShader::Context* SkTwoPointConicalGradient::onCreateContext(const ContextRec& rec,
-                                                              void* storage) const {
-    return CheckedCreateContext<TwoPointConicalGradientContext>(storage, *this, rec);
+SkShader::Context* SkTwoPointConicalGradient::onMakeContext(
+    const ContextRec& rec, SkArenaAlloc* alloc) const {
+    return CheckedMakeContext<TwoPointConicalGradientContext>(alloc, *this, rec);
 }
 
 SkTwoPointConicalGradient::TwoPointConicalGradientContext::TwoPointConicalGradientContext(
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.h b/src/effects/gradients/SkTwoPointConicalGradient.h
index d16e4bc3c5..e509f92703 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.h
+++ b/src/effects/gradients/SkTwoPointConicalGradient.h
@@ -75,8 +75,7 @@ public:
 protected:
     SkTwoPointConicalGradient(SkReadBuffer& buffer);
     void flatten(SkWriteBuffer& buffer) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc*) const override;
 
 private:
     SkPoint fCenter1;
diff --git a/src/image/SkImageShader.cpp b/src/image/SkImageShader.cpp
index 90ae830116..64a09dd2dc 100644
--- a/src/image/SkImageShader.cpp
+++ b/src/image/SkImageShader.cpp
@@ -48,14 +48,10 @@ bool SkImageShader::isOpaque() const {
     return fImage->isOpaque();
 }
 
-size_t SkImageShader::onContextSize(const ContextRec& rec) const {
-    return SkBitmapProcLegacyShader::ContextSize(rec, as_IB(fImage)->onImageInfo());
-}
-
-SkShader::Context* SkImageShader::onCreateContext(const ContextRec& rec, void* storage) const {
+SkShader::Context* SkImageShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const {
     return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY,
                                                  SkBitmapProvider(fImage.get(), rec.fDstColorSpace),
-                                                 rec, storage);
+                                                 rec, alloc);
 }
 
 SkImage* SkImageShader::onIsAImage(SkMatrix* texM, TileMode xy[]) const {
diff --git a/src/image/SkImageShader.h b/src/image/SkImageShader.h
index d065a1e296..ef5e87c66d 100644
--- a/src/image/SkImageShader.h
+++ b/src/image/SkImageShader.h
@@ -30,8 +30,7 @@ public:
 
 protected:
     void flatten(SkWriteBuffer&) const override;
-    size_t onContextSize(const ContextRec&) const override;
-    Context* onCreateContext(const ContextRec&, void* storage) const override;
+    Context* onMakeContext(const ContextRec&, SkArenaAlloc* storage) const override;
 #ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP
     bool onIsABitmap(SkBitmap*, SkMatrix*, TileMode*) const override;
 #endif