diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index b495520..3bef299 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -1192,7 +1192,8 @@
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 Error NullSink::draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const {
-    return src.draw(SkMakeNullCanvas().get());
+    std::unique_ptr<SkCanvas> canvas(SkCreateNullCanvas());
+    return src.draw(canvas.get());
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
@@ -1355,7 +1356,7 @@
     if (!err.isEmpty()) {
         return err;
     }
-    std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
+    sk_sp<SkCanvas> nullCanvas(SkCreateNullCanvas());
     UrlDataManager dataManager(SkString("data"));
     Json::Value json = debugCanvas.toJSON(
             dataManager, debugCanvas.getSize(), nullCanvas.get());
@@ -1370,9 +1371,10 @@
 Error SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
 #if defined(SK_XML)
     std::unique_ptr<SkXMLWriter> xmlWriter(new SkXMLStreamWriter(dst));
-    return src.draw(SkSVGCanvas::Make(SkRect::MakeWH(SkIntToScalar(src.size().width()),
-                                                     SkIntToScalar(src.size().height())),
-                                      xmlWriter.get()).get());
+    sk_sp<SkCanvas> canvas(SkSVGCanvas::Create(
+        SkRect::MakeWH(SkIntToScalar(src.size().width()), SkIntToScalar(src.size().height())),
+        xmlWriter.get()));
+    return src.draw(canvas.get());
 #else
     return Error("SVG sink is disabled.");
 #endif // SK_XML
diff --git a/gm/aaclip.cpp b/gm/aaclip.cpp
index 683f5ff..dd83b7c 100644
--- a/gm/aaclip.cpp
+++ b/gm/aaclip.cpp
@@ -8,7 +8,6 @@
 #include "gm.h"
 #include "SkCanvas.h"
 #include "SkPath.h"
-#include "SkMakeUnique.h"
 
 static void do_draw(SkCanvas* canvas, const SkRect& r) {
     SkPaint paint;
@@ -167,14 +166,14 @@
 
 #ifdef SK_BUILD_FOR_MAC
 
-static std::unique_ptr<SkCanvas> make_canvas(const SkBitmap& bm) {
+static SkCanvas* make_canvas(const SkBitmap& bm) {
     const SkImageInfo& info = bm.info();
     if (info.bytesPerPixel() == 4) {
-        return SkCanvas::MakeRasterDirectN32(info.width(), info.height(),
-                                             (SkPMColor*)bm.getPixels(),
-                                             bm.rowBytes());
+        return SkCanvas::NewRasterDirectN32(info.width(), info.height(),
+                                            (SkPMColor*)bm.getPixels(),
+                                            bm.rowBytes());
     } else {
-        return skstd::make_unique<SkCanvas>(bm);
+        return new SkCanvas(bm);
     }
 }
 
@@ -183,6 +182,7 @@
     SkBitmap bm;
     bm.allocPixels(info);
 
+    sk_sp<SkCanvas> newc(make_canvas(bm));
     if (info.isOpaque()) {
         bm.eraseColor(SK_ColorGREEN);
     } else {
@@ -192,7 +192,7 @@
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setColor(SK_ColorBLUE);
-    make_canvas(bm)->drawCircle(50, 50, 49, paint);
+    newc->drawCircle(50, 50, 49, paint);
     canvas->drawBitmap(bm, 10, 10);
 
     CGImageRef image = SkCreateCGImageRefWithColorspace(bm, nullptr);
diff --git a/gn/android_framework_defines.gni b/gn/android_framework_defines.gni
index 90fea2f..12e3b11 100644
--- a/gn/android_framework_defines.gni
+++ b/gn/android_framework_defines.gni
@@ -12,7 +12,6 @@
   "SK_SUPPORT_LEGACY_GRADIENT_DITHERING",
   "SK_SUPPORT_LEGACY_DRAWFILTER",
   "SK_IGNORE_GPU_DITHER",
-  "SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT",
   "SK_SUPPORT_LEGACY_CLIP_REGIONOPS",
   "SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
 ]
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index ba8a383..ab47edd 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -60,13 +60,7 @@
     color, typeface, textSize, strokeWidth, shader (e.g. gradients, patterns),
     etc.
 */
-class SK_API SkCanvas
-#ifdef SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-: public SkRefCnt
-#else
-: SkNoncopyable
-#endif
-{
+class SK_API SkCanvas : public SkRefCnt {
     enum PrivateSaveLayerFlags {
         kDontClipToLayer_PrivateSaveLayerFlag   = 1U << 31,
     };
@@ -106,22 +100,11 @@
      *  Note: it is valid to request a supported ImageInfo, but with zero
      *  dimensions.
      */
-    static std::unique_ptr<SkCanvas> MakeRasterDirect(const SkImageInfo&, void*, size_t);
-
-    static std::unique_ptr<SkCanvas> MakeRasterDirectN32(int width, int height, SkPMColor* pixels,
-                                                         size_t rowBytes) {
-        return MakeRasterDirect(SkImageInfo::MakeN32Premul(width, height), pixels, rowBytes);
-    }
-
-#ifdef SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-    static SkCanvas* NewRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes) {
-        return MakeRasterDirect(info, pixels, rowBytes).release();
-    }
+    static SkCanvas* NewRasterDirect(const SkImageInfo&, void*, size_t);
 
     static SkCanvas* NewRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes) {
-        return MakeRasterDirectN32(width, height, pixels, rowBytes).release();
+        return NewRasterDirect(SkImageInfo::MakeN32Premul(width, height), pixels, rowBytes);
     }
-#endif
 
     /**
      *  Creates an empty canvas with no backing device/pixels, and zero
diff --git a/include/core/SkMultiPictureDraw.h b/include/core/SkMultiPictureDraw.h
index 9995721..cd46a30 100644
--- a/include/core/SkMultiPictureDraw.h
+++ b/include/core/SkMultiPictureDraw.h
@@ -57,7 +57,7 @@
 
 private:
     struct DrawData {
-        SkCanvas*        fCanvas;
+        SkCanvas*        fCanvas;  // reffed
         const SkPicture* fPicture; // reffed
         SkMatrix         fMatrix;
         SkPaint*         fPaint;   // owned
diff --git a/include/core/SkPictureRecorder.h b/include/core/SkPictureRecorder.h
index a440790..59e8f14 100644
--- a/include/core/SkPictureRecorder.h
+++ b/include/core/SkPictureRecorder.h
@@ -111,13 +111,13 @@
     friend class SkPictureRecorderReplayTester; // for unit testing
     void partialReplay(SkCanvas* canvas) const;
 
-    bool                        fActivelyRecording;
-    uint32_t                    fFlags;
-    SkRect                      fCullRect;
-    sk_sp<SkBBoxHierarchy>      fBBH;
-    std::unique_ptr<SkRecorder> fRecorder;
-    sk_sp<SkRecord>             fRecord;
-    SkMiniRecorder              fMiniRecorder;
+    bool                   fActivelyRecording;
+    uint32_t               fFlags;
+    SkRect                 fCullRect;
+    sk_sp<SkBBoxHierarchy> fBBH;
+    sk_sp<SkRecorder>      fRecorder;
+    sk_sp<SkRecord>        fRecord;
+    SkMiniRecorder         fMiniRecorder;
 
     typedef SkNoncopyable INHERITED;
 };
diff --git a/include/svg/SkSVGCanvas.h b/include/svg/SkSVGCanvas.h
index b72f273..e285faa 100644
--- a/include/svg/SkSVGCanvas.h
+++ b/include/svg/SkSVGCanvas.h
@@ -25,13 +25,7 @@
      *  The 'bounds' parameter defines an initial SVG viewport (viewBox attribute on the root
      *  SVG element).
      */
-    static std::unique_ptr<SkCanvas> Make(const SkRect& bounds, SkXMLWriter*);
-
-#ifdef SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-    static SkCanvas* Create(const SkRect& bounds, SkXMLWriter* writer) {
-        return Make(bounds, writer).release();
-    }
-#endif
+    static SkCanvas* Create(const SkRect& bounds, SkXMLWriter*);
 };
 
 #endif
diff --git a/include/utils/SkCanvasStateUtils.h b/include/utils/SkCanvasStateUtils.h
index fbc3a6f..3071c75 100644
--- a/include/utils/SkCanvasStateUtils.h
+++ b/include/utils/SkCanvasStateUtils.h
@@ -62,12 +62,7 @@
      *         identical to the captured canvas. The caller is responsible for
      *         calling unref on the SkCanvas.
      */
-    static std::unique_ptr<SkCanvas> MakeFromCanvasState(const SkCanvasState* state);
-#ifdef SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-    static SkCanvas* CreateFromCanvasState(const SkCanvasState* state) {
-        return MakeFromCanvasState(state).release();
-    }
-#endif
+    static SkCanvas* CreateFromCanvasState(const SkCanvasState* state);
 
     /**
      * Free the memory associated with the captured canvas state.  The state
diff --git a/include/utils/SkNullCanvas.h b/include/utils/SkNullCanvas.h
index 884b68b..99a26da 100644
--- a/include/utils/SkNullCanvas.h
+++ b/include/utils/SkNullCanvas.h
@@ -15,12 +15,6 @@
 /**
  * Creates a canvas that draws nothing. This is useful for performance testing.
  */
-SK_API std::unique_ptr<SkCanvas> SkMakeNullCanvas();
-
-#ifdef SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-static inline SkCanvas* SkCreateNullCanvas() {
-    return SkMakeNullCanvas().release();
-}
-#endif
+SK_API SkCanvas* SkCreateNullCanvas();
 
 #endif
diff --git a/public.bzl b/public.bzl
index 734aaaf..de3d6f2 100644
--- a/public.bzl
+++ b/public.bzl
@@ -600,7 +600,6 @@
     "GOOGLE3",
     # Staging flags for API changes
     "SK_SUPPORT_LEGACY_ACCESSBITMAP",
-    "SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT",
     "SK_SUPPORT_LEGACY_CLIP_REGIONOPS",
 ]
 
diff --git a/samplecode/SamplePathFuzz.cpp b/samplecode/SamplePathFuzz.cpp
index b66b881..05eb76f 100644
--- a/samplecode/SamplePathFuzz.cpp
+++ b/samplecode/SamplePathFuzz.cpp
@@ -629,8 +629,8 @@
         const SkPath& path = fuzzPath.getPath();
         const SkPaint& paint = fuzzPath.getPaint();
         const SkImageInfo& info = bitmap->info();
-        std::unique_ptr<SkCanvas> canvas(
-            SkCanvas::MakeRasterDirect(info, bitmap->getPixels(), bitmap->rowBytes()));
+        SkCanvas* canvas(
+            SkCanvas::NewRasterDirect(info, bitmap->getPixels(), bitmap->rowBytes()));
         int w = info.width() / 4;
         int h = info.height() / 4;
         int x = localSeed / 4 % 4;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index a8d73a9..cd4dcbc 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -19,7 +19,6 @@
 #include "SkImageFilter.h"
 #include "SkImageFilterCache.h"
 #include "SkLatticeIter.h"
-#include "SkMakeUnique.h"
 #include "SkMatrixUtils.h"
 #include "SkMetaData.h"
 #include "SkNx.h"
@@ -3324,8 +3323,7 @@
     return true;
 }
 
-std::unique_ptr<SkCanvas> SkCanvas::MakeRasterDirect(const SkImageInfo& info, void* pixels,
-                                                     size_t rowBytes) {
+SkCanvas* SkCanvas::NewRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes) {
     if (!supported_for_raster_canvas(info)) {
         return nullptr;
     }
@@ -3334,7 +3332,7 @@
     if (!bitmap.installPixels(info, pixels, rowBytes)) {
         return nullptr;
     }
-    return skstd::make_unique<SkCanvas>(bitmap);
+    return new SkCanvas(bitmap);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkConfig8888.cpp b/src/core/SkConfig8888.cpp
index fd945cf..639a444 100644
--- a/src/core/SkConfig8888.cpp
+++ b/src/core/SkConfig8888.cpp
@@ -354,8 +354,8 @@
         if (!bm.installPixels(srcInfo, const_cast<void*>(srcPixels), srcRB, ctable, nullptr, nullptr)) {
             return false;
         }
-        std::unique_ptr<SkCanvas> canvas = SkCanvas::MakeRasterDirect(dstInfo, dstPixels, dstRB);
-        if (!canvas) {
+        sk_sp<SkCanvas> canvas(SkCanvas::NewRasterDirect(dstInfo, dstPixels, dstRB));
+        if (nullptr == canvas.get()) {
             return false;
         }
 
diff --git a/src/core/SkMultiPictureDraw.cpp b/src/core/SkMultiPictureDraw.cpp
index 1df27ff..b3c6368 100644
--- a/src/core/SkMultiPictureDraw.cpp
+++ b/src/core/SkMultiPictureDraw.cpp
@@ -18,7 +18,7 @@
 void SkMultiPictureDraw::DrawData::init(SkCanvas* canvas, const SkPicture* picture,
                                         const SkMatrix* matrix, const SkPaint* paint) {
     fPicture = SkRef(picture);
-    fCanvas = canvas;
+    fCanvas = SkRef(canvas);
     if (matrix) {
         fMatrix = *matrix;
     } else {
@@ -34,6 +34,7 @@
 void SkMultiPictureDraw::DrawData::Reset(SkTDArray<DrawData>& data) {
     for (int i = 0; i < data.count(); ++i) {
         data[i].fPicture->unref();
+        data[i].fCanvas->unref();
         delete data[i].fPaint;
     }
     data.rewind();
diff --git a/src/core/SkSpecialSurface.cpp b/src/core/SkSpecialSurface.cpp
index b490421..beba915 100644
--- a/src/core/SkSpecialSurface.cpp
+++ b/src/core/SkSpecialSurface.cpp
@@ -29,7 +29,7 @@
     virtual sk_sp<SkSpecialImage> onMakeImageSnapshot() = 0;
 
 protected:
-    std::unique_ptr<SkCanvas> fCanvas;   // initialized by derived classes in ctors
+    sk_sp<SkCanvas> fCanvas;   // initialized by derived classes in ctors
 
 private:
     typedef SkSpecialSurface INHERITED;
diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp
index 3d6670f..38bab9e 100644
--- a/src/image/SkSurface.cpp
+++ b/src/image/SkSurface.cpp
@@ -58,12 +58,14 @@
 SkSurface_Base::SkSurface_Base(int width, int height, const SkSurfaceProps* props)
     : INHERITED(width, height, props)
 {
+    fCachedCanvas = nullptr;
     fCachedImage = nullptr;
 }
 
 SkSurface_Base::SkSurface_Base(const SkImageInfo& info, const SkSurfaceProps* props)
     : INHERITED(info, props)
 {
+    fCachedCanvas = nullptr;
     fCachedImage = nullptr;
 }
 
@@ -74,6 +76,7 @@
     }
 
     SkSafeUnref(fCachedImage);
+    SkSafeUnref(fCachedCanvas);
 }
 
 void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) {
diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h
index a8c1d8f..8351bb8 100644
--- a/src/image/SkSurface_Base.h
+++ b/src/image/SkSurface_Base.h
@@ -89,8 +89,8 @@
     uint32_t newGenerationID();
 
 private:
-    std::unique_ptr<SkCanvas>   fCachedCanvas;
-    SkImage*                    fCachedImage;
+    SkCanvas*   fCachedCanvas;
+    SkImage*    fCachedImage;
 
     void aboutToDraw(ContentChangeMode mode);
 
@@ -106,12 +106,12 @@
 
 SkCanvas* SkSurface_Base::getCachedCanvas() {
     if (nullptr == fCachedCanvas) {
-        fCachedCanvas = std::unique_ptr<SkCanvas>(this->onNewCanvas());
+        fCachedCanvas = this->onNewCanvas();
         if (fCachedCanvas) {
             fCachedCanvas->setSurfaceBase(this);
         }
     }
-    return fCachedCanvas.get();
+    return fCachedCanvas;
 }
 
 sk_sp<SkImage> SkSurface_Base::refCachedImage(SkBudgeted budgeted, ForceUnique unique) {
diff --git a/src/pdf/SkPDFDocument.cpp b/src/pdf/SkPDFDocument.cpp
index 92e82fc..ab5f465 100644
--- a/src/pdf/SkPDFDocument.cpp
+++ b/src/pdf/SkPDFDocument.cpp
@@ -217,7 +217,7 @@
             SkScalarRoundToInt(width), SkScalarRoundToInt(height));
     fPageDevice.reset(
             SkPDFDevice::Create(pageSize, fRasterDpi, this));
-    fCanvas.reset(new SkPDFCanvas(fPageDevice));
+    fCanvas = sk_make_sp<SkPDFCanvas>(fPageDevice);
     fCanvas->clipRect(trimBox);
     fCanvas->translate(trimBox.x(), trimBox.y());
     return fCanvas.get();
diff --git a/src/pdf/SkPDFDocument.h b/src/pdf/SkPDFDocument.h
index 15e1479..b62a7a5 100644
--- a/src/pdf/SkPDFDocument.h
+++ b/src/pdf/SkPDFDocument.h
@@ -76,7 +76,7 @@
     SkTHashSet<SkPDFFont*> fFonts;
     sk_sp<SkPDFDict> fDests;
     sk_sp<SkPDFDevice> fPageDevice;
-    std::unique_ptr<SkCanvas> fCanvas;
+    sk_sp<SkCanvas> fCanvas;
     sk_sp<SkPDFObject> fID;
     sk_sp<SkPDFObject> fXMP;
     SkScalar fRasterDpi;
diff --git a/src/svg/SkSVGCanvas.cpp b/src/svg/SkSVGCanvas.cpp
index 95a4625..d3511c0 100644
--- a/src/svg/SkSVGCanvas.cpp
+++ b/src/svg/SkSVGCanvas.cpp
@@ -7,12 +7,11 @@
 
 #include "SkSVGCanvas.h"
 #include "SkSVGDevice.h"
-#include "SkMakeUnique.h"
 
-std::unique_ptr<SkCanvas> SkSVGCanvas::Make(const SkRect& bounds, SkXMLWriter* writer) {
+SkCanvas* SkSVGCanvas::Create(const SkRect& bounds, SkXMLWriter* writer) {
     // TODO: pass full bounds to the device
     SkISize size = bounds.roundOut().size();
     sk_sp<SkBaseDevice> device(SkSVGDevice::Create(size, writer));
 
-    return skstd::make_unique<SkCanvas>(device.get());
+    return new SkCanvas(device.get());
 }
diff --git a/src/utils/SkCanvasStateUtils.cpp b/src/utils/SkCanvasStateUtils.cpp
index 58f26b6..062dc13 100644
--- a/src/utils/SkCanvasStateUtils.cpp
+++ b/src/utils/SkCanvasStateUtils.cpp
@@ -100,12 +100,14 @@
 public:
     static const int32_t kVersion = 1;
 
-    SkCanvasState_v1(SkCanvas* canvas) : INHERITED(kVersion, canvas) {
+    SkCanvasState_v1(SkCanvas* canvas)
+    : INHERITED(kVersion, canvas)
+    {
         layerCount = 0;
         layers = nullptr;
         mcState.clipRectCount = 0;
         mcState.clipRects = nullptr;
-        originalCanvas = canvas;
+        originalCanvas = SkRef(canvas);
     }
 
     ~SkCanvasState_v1() {
@@ -116,6 +118,10 @@
 
         sk_free(mcState.clipRects);
         sk_free(layers);
+
+        // it is now safe to free the canvas since there should be no remaining
+        // references to the content that is referenced by this canvas (e.g. pixels)
+        originalCanvas->unref();
     }
 
     SkMCState mcState;
@@ -278,8 +284,7 @@
     canvas->clipRegion(clip, SkCanvas::kReplace_Op);
 }
 
-static std::unique_ptr<SkCanvas>
-make_canvas_from_canvas_layer(const SkCanvasLayerState& layerState) {
+static SkCanvas* create_canvas_from_canvas_layer(const SkCanvasLayerState& layerState) {
     SkASSERT(kRaster_CanvasBackend == layerState.type);
 
     SkBitmap bitmap;
@@ -299,15 +304,15 @@
     SkASSERT(!bitmap.empty());
     SkASSERT(!bitmap.isNull());
 
-    std::unique_ptr<SkCanvas> canvas(new SkCanvas(bitmap));
+    sk_sp<SkCanvas> canvas(new SkCanvas(bitmap));
 
     // setup the matrix and clip
     setup_canvas_from_MC_state(layerState.mcState, canvas.get());
 
-    return canvas;
+    return canvas.release();
 }
 
-std::unique_ptr<SkCanvas> SkCanvasStateUtils::MakeFromCanvasState(const SkCanvasState* state) {
+SkCanvas* SkCanvasStateUtils::CreateFromCanvasState(const SkCanvasState* state) {
     SkASSERT(state);
     // Currently there is only one possible version.
     SkASSERT(SkCanvasState_v1::kVersion == state->version);
@@ -318,14 +323,14 @@
         return nullptr;
     }
 
-    std::unique_ptr<SkCanvasStack> canvas(new SkCanvasStack(state->width, state->height));
+    sk_sp<SkCanvasStack> canvas(new SkCanvasStack(state->width, state->height));
 
     // setup the matrix and clip on the n-way canvas
     setup_canvas_from_MC_state(state_v1->mcState, canvas.get());
 
     // Iterate over the layers and add them to the n-way canvas
     for (int i = state_v1->layerCount - 1; i >= 0; --i) {
-        std::unique_ptr<SkCanvas> canvasLayer = make_canvas_from_canvas_layer(state_v1->layers[i]);
+        sk_sp<SkCanvas> canvasLayer(create_canvas_from_canvas_layer(state_v1->layers[i]));
         if (!canvasLayer.get()) {
             return nullptr;
         }
@@ -333,7 +338,7 @@
                                                              state_v1->layers[i].y));
     }
 
-    return std::move(canvas);
+    return canvas.release();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 27127df..a223456 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -73,13 +73,6 @@
     lua_setmetatable(L, -2);
 }
 
-template <typename T> T* push_ptr(lua_State* L, T* ptr) {
-    *(T**)lua_newuserdata(L, sizeof(T*)) = ptr;
-    luaL_getmetatable(L, get_mtname<T>());
-    lua_setmetatable(L, -2);
-    return ptr;
-}
-
 template <typename T> T* push_ref(lua_State* L, T* ref) {
     *(T**)lua_newuserdata(L, sizeof(T*)) = SkSafeRef(ref);
     luaL_getmetatable(L, get_mtname<T>());
@@ -340,7 +333,7 @@
 }
 
 void SkLua::pushCanvas(SkCanvas* canvas, const char key[]) {
-    push_ptr(fL, canvas);
+    push_ref(fL, canvas);
     CHECK_SETFIELD(key);
 }
 
@@ -722,7 +715,7 @@
 }
 
 static int lcanvas_gc(lua_State* L) {
-    // don't know how to track a ptr...
+    get_ref<SkCanvas>(L, 1)->unref();
     return 0;
 }
 
@@ -764,7 +757,7 @@
 
 static int ldocument_beginPage(lua_State* L) {
     const SkRect* contentPtr = nullptr;
-    push_ptr(L, get_ref<SkDocument>(L, 1)->beginPage(lua2scalar(L, 2),
+    push_ref(L, get_ref<SkDocument>(L, 1)->beginPage(lua2scalar(L, 2),
                                                      lua2scalar(L, 3),
                                                      contentPtr));
     return 1;
@@ -1757,7 +1750,7 @@
     if (nullptr == canvas) {
         lua_pushnil(L);
     } else {
-        push_ptr(L, canvas);
+        push_ref(L, canvas);
         // note: we don't unref canvas, since getCanvas did not ref it.
         // warning: this is weird: now Lua owns a ref on this canvas, but what if they let
         // the real owner (the surface) go away, but still hold onto the canvas?
@@ -1821,7 +1814,7 @@
         return 1;
     }
 
-    push_ptr(L, canvas);
+    push_ref(L, canvas);
     return 1;
 }
 
@@ -1831,7 +1824,7 @@
         lua_pushnil(L);
         return 1;
     }
-    push_ptr(L, canvas);
+    push_ref(L, canvas);
     return 1;
 }
 
diff --git a/src/utils/SkNWayCanvas.cpp b/src/utils/SkNWayCanvas.cpp
index a910284..b2d71d2 100644
--- a/src/utils/SkNWayCanvas.cpp
+++ b/src/utils/SkNWayCanvas.cpp
@@ -15,6 +15,7 @@
 
 void SkNWayCanvas::addCanvas(SkCanvas* canvas) {
     if (canvas) {
+        canvas->ref();
         *fList.append() = canvas;
     }
 }
@@ -22,11 +23,13 @@
 void SkNWayCanvas::removeCanvas(SkCanvas* canvas) {
     int index = fList.find(canvas);
     if (index >= 0) {
+        canvas->unref();
         fList.removeShuffle(index);
     }
 }
 
 void SkNWayCanvas::removeAll() {
+    fList.unrefAll();
     fList.reset();
 }
 
diff --git a/src/utils/SkNullCanvas.cpp b/src/utils/SkNullCanvas.cpp
index 1f28706..b5ee8d3 100644
--- a/src/utils/SkNullCanvas.cpp
+++ b/src/utils/SkNullCanvas.cpp
@@ -9,10 +9,10 @@
 
 #include "SkCanvas.h"
 #include "SkNWayCanvas.h"
-#include "SkMakeUnique.h"
 
-std::unique_ptr<SkCanvas> SkMakeNullCanvas() {
+
+SkCanvas* SkCreateNullCanvas() {
     // An N-Way canvas forwards calls to N canvas's. When N == 0 it's
     // effectively a null canvas.
-    return std::unique_ptr<SkCanvas>(new SkNWayCanvas(0, 0));
+    return new SkNWayCanvas(0, 0);
 }
diff --git a/src/xps/SkDocument_XPS.cpp b/src/xps/SkDocument_XPS.cpp
index d05764a..e333b5a 100644
--- a/src/xps/SkDocument_XPS.cpp
+++ b/src/xps/SkDocument_XPS.cpp
@@ -58,7 +58,7 @@
 
 private:
     SkXPSDevice fDevice;
-    std::unique_ptr<SkCanvas> fCanvas;
+    sk_sp<SkCanvas> fCanvas;
     SkVector fUnitsPerMeter;
     SkVector fPixelsPerMeter;
 };
diff --git a/tests/CanvasStateHelpers.cpp b/tests/CanvasStateHelpers.cpp
index 98b5d23..801eaea 100644
--- a/tests/CanvasStateHelpers.cpp
+++ b/tests/CanvasStateHelpers.cpp
@@ -27,11 +27,12 @@
 
 extern "C" bool complex_layers_draw_from_canvas_state(SkCanvasState* state,
         float left, float top, float right, float bottom, int32_t spacer) {
-    std::unique_ptr<SkCanvas> canvas = SkCanvasStateUtils::MakeFromCanvasState(state);
+    SkCanvas* canvas = SkCanvasStateUtils::CreateFromCanvasState(state);
     if (!canvas) {
         return false;
     }
-    complex_layers_draw(canvas.get(), left, top, right, bottom, spacer);
+    complex_layers_draw(canvas, left, top, right, bottom, spacer);
+    canvas->unref();
     return true;
 }
 
@@ -51,7 +52,7 @@
 extern "C" bool complex_clips_draw_from_canvas_state(SkCanvasState* state,
         int32_t left, int32_t top, int32_t right, int32_t bottom, int32_t clipOp,
         int32_t regionRects, int32_t* rectCoords) {
-    std::unique_ptr<SkCanvas> canvas = SkCanvasStateUtils::MakeFromCanvasState(state);
+    SkCanvas* canvas = SkCanvasStateUtils::CreateFromCanvasState(state);
     if (!canvas) {
         return false;
     }
@@ -63,7 +64,8 @@
         rectCoords += 4;
     }
 
-    complex_clips_draw(canvas.get(), left, top, right, bottom, clipOp, localRegion);
+    complex_clips_draw(canvas, left, top, right, bottom, clipOp, localRegion);
+    canvas->unref();
     return true;
 }
 #endif // SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
diff --git a/tests/CanvasStateTest.cpp b/tests/CanvasStateTest.cpp
index 2c7c590..890e85d 100644
--- a/tests/CanvasStateTest.cpp
+++ b/tests/CanvasStateTest.cpp
@@ -278,12 +278,13 @@
 
     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
     REPORTER_ASSERT(reporter, state);
-    std::unique_ptr<SkCanvas> tmpCanvas = SkCanvasStateUtils::MakeFromCanvasState(state);
+    SkCanvas* tmpCanvas = SkCanvasStateUtils::CreateFromCanvasState(state);
     REPORTER_ASSERT(reporter, tmpCanvas);
 
     REPORTER_ASSERT(reporter, canvas.getDrawFilter());
     REPORTER_ASSERT(reporter, nullptr == tmpCanvas->getDrawFilter());
 
+    tmpCanvas->unref();
     SkCanvasStateUtils::ReleaseCanvasState(state);
 }
 
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 3f418db..c062e6c 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -542,7 +542,7 @@
     SkPMColor* baseAddr = storage.get();
     sk_bzero(baseAddr, size);
 
-    std::unique_ptr<SkCanvas> canvas = SkCanvas::MakeRasterDirect(info, baseAddr, minRowBytes);
+    SkCanvas* canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
     REPORTER_ASSERT(reporter, canvas);
 
     SkPixmap pmap;
@@ -556,23 +556,25 @@
         }
         addr = (const SkPMColor*)((const char*)addr + pmap.rowBytes());
     }
+    delete canvas;
 
     // now try a deliberately bad info
     info = info.makeWH(-1, info.height());
-    REPORTER_ASSERT(reporter, nullptr == SkCanvas::MakeRasterDirect(info, baseAddr, minRowBytes));
+    REPORTER_ASSERT(reporter, nullptr == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
 
     // too big
     info = info.makeWH(1 << 30, 1 << 30);
-    REPORTER_ASSERT(reporter, nullptr == SkCanvas::MakeRasterDirect(info, baseAddr, minRowBytes));
+    REPORTER_ASSERT(reporter, nullptr == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
 
     // not a valid pixel type
     info = SkImageInfo::Make(10, 10, kUnknown_SkColorType, info.alphaType());
-    REPORTER_ASSERT(reporter, nullptr == SkCanvas::MakeRasterDirect(info, baseAddr, minRowBytes));
+    REPORTER_ASSERT(reporter, nullptr == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
 
     // We should succeed with a zero-sized valid info
     info = SkImageInfo::MakeN32Premul(0, 0);
-    canvas = SkCanvas::MakeRasterDirect(info, baseAddr, minRowBytes);
+    canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
     REPORTER_ASSERT(reporter, canvas);
+    delete canvas;
 }
 
 DEF_TEST(Canvas, reporter) {
diff --git a/tests/PipeTest.cpp b/tests/PipeTest.cpp
index e5d2f09..3b89441 100644
--- a/tests/PipeTest.cpp
+++ b/tests/PipeTest.cpp
@@ -18,7 +18,7 @@
 #include "SkPictureRecorder.h"
 
 static void drain(SkPipeDeserializer* deserial, SkDynamicMemoryWStream* stream) {
-    std::unique_ptr<SkCanvas> canvas = SkMakeNullCanvas();
+    std::unique_ptr<SkCanvas> canvas(SkCreateNullCanvas());
     sk_sp<SkData> data = stream->detachAsData();
     deserial->playback(data->data(), data->size(), canvas.get());
 }
diff --git a/tests/SVGDeviceTest.cpp b/tests/SVGDeviceTest.cpp
index 715dbc7..b010e57 100644
--- a/tests/SVGDeviceTest.cpp
+++ b/tests/SVGDeviceTest.cpp
@@ -91,7 +91,7 @@
 
     {
         SkXMLParserWriter writer(dom.beginParsing());
-        std::unique_ptr<SkCanvas> svgCanvas = SkSVGCanvas::Make(SkRect::MakeWH(100, 100), &writer);
+        sk_sp<SkCanvas> svgCanvas(SkSVGCanvas::Create(SkRect::MakeWH(100, 100), &writer));
         svgCanvas->drawText(txt, len, offset.x(), offset.y(), paint);
     }
     check_text_node(reporter, dom, dom.finishParsing(), offset, 0, expected);
@@ -103,7 +103,7 @@
         }
 
         SkXMLParserWriter writer(dom.beginParsing());
-        std::unique_ptr<SkCanvas> svgCanvas = SkSVGCanvas::Make(SkRect::MakeWH(100, 100), &writer);
+        sk_sp<SkCanvas> svgCanvas(SkSVGCanvas::Create(SkRect::MakeWH(100, 100), &writer));
         svgCanvas->drawPosTextH(txt, len, xpos, offset.y(), paint);
     }
     check_text_node(reporter, dom, dom.finishParsing(), offset, 1, expected);
@@ -115,7 +115,7 @@
         }
 
         SkXMLParserWriter writer(dom.beginParsing());
-        std::unique_ptr<SkCanvas> svgCanvas = SkSVGCanvas::Make(SkRect::MakeWH(100, 100), &writer);
+        sk_sp<SkCanvas> svgCanvas(SkSVGCanvas::Create(SkRect::MakeWH(100, 100), &writer));
         svgCanvas->drawPosText(txt, len, pos, paint);
     }
     check_text_node(reporter, dom, dom.finishParsing(), offset, 2, expected);
diff --git a/tools/lua/lua_pictures.cpp b/tools/lua/lua_pictures.cpp
index 639a522..bd8fda1 100644
--- a/tools/lua/lua_pictures.cpp
+++ b/tools/lua/lua_pictures.cpp
@@ -145,7 +145,7 @@
 
             auto pic(load_picture(path));
             if (pic.get()) {
-                std::unique_ptr<SkLuaCanvas> canvas(
+                sk_sp<SkLuaCanvas> canvas(
                                     new SkLuaCanvas(SkScalarCeilToInt(pic->cullRect().width()),
                                                     SkScalarCeilToInt(pic->cullRect().height()),
                                                     L.get(), gAccumulateFunc));
diff --git a/tools/skiaserve/Request.h b/tools/skiaserve/Request.h
index 4058d7c..6b065a2 100644
--- a/tools/skiaserve/Request.h
+++ b/tools/skiaserve/Request.h
@@ -63,7 +63,7 @@
     SkColor getPixel(int x, int y);
 
     UploadContext* fUploadContext;
-    std::unique_ptr<SkDebugCanvas> fDebugCanvas;
+    sk_sp<SkDebugCanvas> fDebugCanvas;
     UrlDataManager fUrlDataManager;
 
 private:
diff --git a/tools/skp_parser.cpp b/tools/skp_parser.cpp
index 887c50d..d242524 100644
--- a/tools/skp_parser.cpp
+++ b/tools/skp_parser.cpp
@@ -34,7 +34,7 @@
     SkISize size = pic->cullRect().roundOut().size();
     SkDebugCanvas debugCanvas(size.width(), size.height());
     pic->playback(&debugCanvas);
-    std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
+    sk_sp<SkCanvas> nullCanvas(SkCreateNullCanvas());
     UrlDataManager dataManager(SkString("data"));
     Json::Value json = debugCanvas.toJSON(
             dataManager, debugCanvas.getSize(), nullCanvas.get());