diff --git a/RELEASE_NOTES.txt b/RELEASE_NOTES.txt
index 82366e9..ddde299 100644
--- a/RELEASE_NOTES.txt
+++ b/RELEASE_NOTES.txt
@@ -6,6 +6,8 @@
 
 Milestone 83
 
+  * Remove localmatrix option from SkShaders::[Blend, Lerp]
+
   * Fill out Direct3D parameters for backend textures and backend rendertargets.
 
   * SkImage::makeTextureImage() takes an optional SkBudgeted param
diff --git a/gm/composeshader.cpp b/gm/composeshader.cpp
index 907bf36..8ef0824 100644
--- a/gm/composeshader.cpp
+++ b/gm/composeshader.cpp
@@ -192,23 +192,24 @@
     void onDraw(SkCanvas* canvas) override {
         SkBlendMode mode = SkBlendMode::kDstOver;
 
-        SkTLazy<SkMatrix> lm;
-        if (fUseLocalMatrix) {
-            lm.set(SkMatrix::MakeTrans(0, squareLength * 0.5f));
-        }
+        SkMatrix lm = SkMatrix::MakeTrans(0, squareLength * 0.5f);
 
         sk_sp<SkShader> shaders[] = {
             // gradient should appear over color bitmap
-            SkShaders::Blend(mode, fLinearGradientShader, fColorBitmapShader, lm.getMaybeNull()),
+            SkShaders::Blend(mode, fLinearGradientShader, fColorBitmapShader),
             // gradient should appear over alpha8 bitmap colorized by the paint color
-            SkShaders::Blend(mode, fLinearGradientShader, fAlpha8BitmapShader, lm.getMaybeNull()),
+            SkShaders::Blend(mode, fLinearGradientShader, fAlpha8BitmapShader),
         };
+        if (fUseLocalMatrix) {
+            for (unsigned i = 0; i < SK_ARRAY_COUNT(shaders); ++i) {
+                shaders[i] = shaders[i]->makeWithLocalMatrix(lm);
+            }
+        }
 
         SkPaint paint;
         paint.setColor(SK_ColorYELLOW);
 
-        const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength),
-                                          SkIntToScalar(squareLength));
+        const SkRect r = SkRect::MakeIWH(squareLength, squareLength);
 
         for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
             canvas->save();
diff --git a/include/core/SkShader.h b/include/core/SkShader.h
index 45f9db0..211a6f8 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -139,10 +139,8 @@
     static sk_sp<SkShader> Empty();
     static sk_sp<SkShader> Color(SkColor);
     static sk_sp<SkShader> Color(const SkColor4f&, sk_sp<SkColorSpace>);
-    static sk_sp<SkShader> Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                 const SkMatrix* localMatrix = nullptr);
-    static sk_sp<SkShader> Lerp(float t, sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                const SkMatrix* localMatrix = nullptr);
+    static sk_sp<SkShader> Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src);
+    static sk_sp<SkShader> Lerp(float t, sk_sp<SkShader> dst, sk_sp<SkShader> src);
 
 private:
     SkShaders() = delete;
diff --git a/modules/canvaskit/CHANGELOG.md b/modules/canvaskit/CHANGELOG.md
index 6848f0f..bfce278 100644
--- a/modules/canvaskit/CHANGELOG.md
+++ b/modules/canvaskit/CHANGELOG.md
@@ -6,6 +6,9 @@
 
 ## [Unreleased]
 
+### Removed
+ - localmatrix option for `SkShader.Lerp` and `SkShader.Blend`.
+
 ## [0.14.0] - 2020-03-18
 
 ### Added
diff --git a/modules/canvaskit/canvaskit_bindings.cpp b/modules/canvaskit/canvaskit_bindings.cpp
index c527688..1831f7d 100644
--- a/modules/canvaskit/canvaskit_bindings.cpp
+++ b/modules/canvaskit/canvaskit_bindings.cpp
@@ -1464,23 +1464,9 @@
 
     class_<SkShader>("SkShader")
         .smart_ptr<sk_sp<SkShader>>("sk_sp<SkShader>")
-        .class_function("_Blend", optional_override([](SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src)->sk_sp<SkShader> {
-            return SkShaders::Blend(mode, dst, src, nullptr);
-        }))
-        .class_function("_Blend", optional_override([](SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                                       SimpleMatrix sm)->sk_sp<SkShader> {
-            auto m = toSkMatrix(sm);
-            return SkShaders::Blend(mode, dst, src, &m);
-        }))
+        .class_function("Blend", select_overload<sk_sp<SkShader>(SkBlendMode, sk_sp<SkShader>, sk_sp<SkShader>)>(&SkShaders::Blend))
         .class_function("Color", select_overload<sk_sp<SkShader>(SkColor)>(&SkShaders::Color))
-        .class_function("_Lerp", optional_override([](float t, sk_sp<SkShader> dst, sk_sp<SkShader> src)->sk_sp<SkShader> {
-            return SkShaders::Lerp(t, dst, src, nullptr);
-        }))
-        .class_function("_Lerp", optional_override([](float t, sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                                      SimpleMatrix sm)->sk_sp<SkShader> {
-            auto m = toSkMatrix(sm);
-            return SkShaders::Lerp(t, dst, src, &m);
-        }));
+        .class_function("Lerp", select_overload<sk_sp<SkShader>(float, sk_sp<SkShader>, sk_sp<SkShader>)>(&SkShaders::Lerp));
 
 #ifdef SK_INCLUDE_RUNTIME_EFFECT
     class_<SkRuntimeEffect>("SkRuntimeEffect")
diff --git a/modules/canvaskit/externs.js b/modules/canvaskit/externs.js
index 154efdf..ddc2b3c 100644
--- a/modules/canvaskit/externs.js
+++ b/modules/canvaskit/externs.js
@@ -471,9 +471,6 @@
     MakeRadialGradient: function() {},
     MakeTwoPointConicalGradient: function() {},
     MakeSweepGradient: function() {},
-
-    _Blend: function() {},
-    _Lerp: function() {},
   },
 
   SkSurface: {
diff --git a/modules/canvaskit/interface.js b/modules/canvaskit/interface.js
index 91cc51d..495fb9d 100644
--- a/modules/canvaskit/interface.js
+++ b/modules/canvaskit/interface.js
@@ -1001,20 +1001,6 @@
     return m;
   }
 
-  CanvasKit.SkShader.Blend = function(mode, dst, src, localMatrix) {
-    if (!localMatrix) {
-      return this._Blend(mode, dst, src);
-    }
-    return this._Blend(mode, dst, src, localMatrix);
-  }
-
-  CanvasKit.SkShader.Lerp = function(t, dst, src, localMatrix) {
-    if (!localMatrix) {
-      return this._Lerp(t, dst, src);
-    }
-    return this._Lerp(t, dst, src, localMatrix);
-  }
-
   CanvasKit.SkSurface.prototype.captureFrameAsSkPicture = function(drawFrame) {
     // Set up SkPictureRecorder
     var spr = new CanvasKit.SkPictureRecorder();
diff --git a/modules/skottie/src/effects/MotionTileEffect.cpp b/modules/skottie/src/effects/MotionTileEffect.cpp
index b693c4e..bc2c31f 100644
--- a/modules/skottie/src/effects/MotionTileEffect.cpp
+++ b/modules/skottie/src/effects/MotionTileEffect.cpp
@@ -113,8 +113,8 @@
             // First drawing pass: in-place masked layer content.
             fMainPassShader  = SkShaders::Blend(SkBlendMode::kSrcIn , mask_shader, layer_shader);
             // Second pass: phased-shifted layer content, with an inverse mask.
-            fPhasePassShader = SkShaders::Blend(SkBlendMode::kSrcOut, mask_shader, layer_shader,
-                                                &phase_shader_matrix);
+            fPhasePassShader = SkShaders::Blend(SkBlendMode::kSrcOut, mask_shader, layer_shader)
+                               ->makeWithLocalMatrix(phase_shader_matrix);
         } else {
             fMainPassShader  = std::move(layer_shader);
             fPhasePassShader = nullptr;
diff --git a/src/core/SkDraw_vertices.cpp b/src/core/SkDraw_vertices.cpp
index 35fab6c..dc3361a 100644
--- a/src/core/SkDraw_vertices.cpp
+++ b/src/core/SkDraw_vertices.cpp
@@ -355,8 +355,7 @@
                                                       usePerspective);
         if (shader) {
             shader = outerAlloc->make<SkShader_Blend>(bmode,
-                                                     sk_ref_sp(triShader), sk_ref_sp(shader),
-                                                     nullptr);
+                                                     sk_ref_sp(triShader), sk_ref_sp(shader));
         } else {
             shader = triShader;
         }
diff --git a/src/shaders/SkComposeShader.cpp b/src/shaders/SkComposeShader.cpp
index bd6cffe..96ebf79 100644
--- a/src/shaders/SkComposeShader.cpp
+++ b/src/shaders/SkComposeShader.cpp
@@ -19,10 +19,6 @@
 
 namespace {
 
-sk_sp<SkShader> wrap_lm(sk_sp<SkShader> shader, const SkMatrix* lm) {
-    return (shader && lm) ? shader->makeWithLocalMatrix(*lm) : shader;
-}
-
 struct LocalMatrixStageRec final : public SkStageRec {
     LocalMatrixStageRec(const SkStageRec& rec, const SkMatrix& lm)
         : INHERITED(rec) {
@@ -44,29 +40,27 @@
 
 } // namespace
 
-sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                 const SkMatrix* lm) {
+sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
     switch (mode) {
         case SkBlendMode::kClear: return Color(0);
-        case SkBlendMode::kDst:   return wrap_lm(std::move(dst), lm);
-        case SkBlendMode::kSrc:   return wrap_lm(std::move(src), lm);
+        case SkBlendMode::kDst:   return dst;
+        case SkBlendMode::kSrc:   return src;
         default: break;
     }
-    return sk_sp<SkShader>(new SkShader_Blend(mode, std::move(dst), std::move(src), lm));
+    return sk_sp<SkShader>(new SkShader_Blend(mode, std::move(dst), std::move(src)));
 }
 
-sk_sp<SkShader> SkShaders::Lerp(float weight, sk_sp<SkShader> dst, sk_sp<SkShader> src,
-                                const SkMatrix* lm) {
+sk_sp<SkShader> SkShaders::Lerp(float weight, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
     if (SkScalarIsNaN(weight)) {
         return nullptr;
     }
     if (dst == src || weight <= 0) {
-        return wrap_lm(std::move(dst), lm);
+        return dst;
     }
     if (weight >= 1) {
-        return wrap_lm(std::move(src), lm);
+        return src;
     }
-    return sk_sp<SkShader>(new SkShader_Lerp(weight, std::move(dst), std::move(src), lm));
+    return sk_sp<SkShader>(new SkShader_Lerp(weight, std::move(dst), std::move(src)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/shaders/SkComposeShader.h b/src/shaders/SkComposeShader.h
index f022592..dd36d38 100644
--- a/src/shaders/SkComposeShader.h
+++ b/src/shaders/SkComposeShader.h
@@ -13,9 +13,8 @@
 
 class SkShader_Blend final : public SkShaderBase {
 public:
-    SkShader_Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src, const SkMatrix* lm)
-        : INHERITED(lm)
-        , fDst(std::move(dst))
+    SkShader_Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src)
+        : fDst(std::move(dst))
         , fSrc(std::move(src))
         , fMode(mode)
     {}
@@ -45,9 +44,8 @@
 
 class SkShader_Lerp final : public SkShaderBase {
 public:
-    SkShader_Lerp(float weight, sk_sp<SkShader> dst, sk_sp<SkShader> src, const SkMatrix* lm)
-        : INHERITED(lm)
-        , fDst(std::move(dst))
+    SkShader_Lerp(float weight, sk_sp<SkShader> dst, sk_sp<SkShader> src)
+        : fDst(std::move(dst))
         , fSrc(std::move(src))
         , fWeight(weight)
     {