diff --git a/android_webview/native/java_browser_view_renderer_helper.cc b/android_webview/native/java_browser_view_renderer_helper.cc
index 8d8ee8da7662..70eca1dd2276 100644
--- a/android_webview/native/java_browser_view_renderer_helper.cc
+++ b/android_webview/native/java_browser_view_renderer_helper.cc
@@ -8,6 +8,7 @@
 
 #include "android_webview/public/browser/draw_sw.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "jni/JavaBrowserViewRendererHelper_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -35,7 +36,7 @@ class JavaCanvasHolder : public SoftwareCanvasHolder {
 
  private:
   AwPixelInfo* pixels_;
-  sk_sp<SkCanvas> canvas_;
+  std::unique_ptr<SkCanvas> canvas_;
   DISALLOW_COPY_AND_ASSIGN(JavaCanvasHolder);
 };
 
@@ -49,8 +50,7 @@ JavaCanvasHolder::JavaCanvasHolder(JNIEnv* env,
   if (!pixels_ || !pixels_->state)
     return;
 
-  canvas_ = sk_sp<SkCanvas>(
-      SkCanvasStateUtils::CreateFromCanvasState(pixels_->state));
+  canvas_ = SkCanvasStateUtils::MakeFromCanvasState(pixels_->state);
   // Workarounds for http://crbug.com/271096: SW draw only supports
   // translate & scale transforms, and a simple rectangular clip.
   if (canvas_ && (!canvas_->isClipRect() ||
@@ -88,7 +88,7 @@ class AuxiliaryCanvasHolder : public SoftwareCanvasHolder {
   ScopedJavaLocalRef<jobject> jbitmap_;
   gfx::Vector2d scroll_;
   std::unique_ptr<SkBitmap> bitmap_;
-  sk_sp<SkCanvas> canvas_;
+  std::unique_ptr<SkCanvas> canvas_;
   DISALLOW_COPY_AND_ASSIGN(AuxiliaryCanvasHolder);
 };
 
@@ -121,7 +121,7 @@ AuxiliaryCanvasHolder::AuxiliaryCanvasHolder(
       SkImageInfo::MakeN32Premul(bitmap_info.width, bitmap_info.height);
   bitmap_.reset(new SkBitmap);
   bitmap_->installPixels(info, pixels, bitmap_info.stride);
-  canvas_ = sk_make_sp<SkCanvas>(*bitmap_);
+  canvas_ = base::MakeUnique<SkCanvas>(*bitmap_);
 }
 
 AuxiliaryCanvasHolder::~AuxiliaryCanvasHolder() {
diff --git a/blimp/test/support/compositor/picture_cache_test_support.cc b/blimp/test/support/compositor/picture_cache_test_support.cc
index 1f2b35c8b4a6..58cd52fd2933 100644
--- a/blimp/test/support/compositor/picture_cache_test_support.cc
+++ b/blimp/test/support/compositor/picture_cache_test_support.cc
@@ -22,8 +22,7 @@ namespace blimp {
 
 sk_sp<const SkPicture> CreateSkPicture(SkColor color) {
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas =
-      sk_ref_sp(recorder.beginRecording(SkRect::MakeWH(1, 1)));
+  SkCanvas* canvas = recorder.beginRecording(SkRect::MakeWH(1, 1));
   canvas->drawColor(color);
   return recorder.finishRecordingAsPicture();
 }
diff --git a/cc/blimp/compositor_state_deserializer_unittest.cc b/cc/blimp/compositor_state_deserializer_unittest.cc
index 46472928b422..e044e66f878f 100644
--- a/cc/blimp/compositor_state_deserializer_unittest.cc
+++ b/cc/blimp/compositor_state_deserializer_unittest.cc
@@ -339,11 +339,11 @@ TEST_F(CompositorStateDeserializerTest, PictureLayer) {
 
   gfx::PointF offset(2.f, 3.f);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
+  SkCanvas* canvas;
   SkPaint red_paint;
   red_paint.setColor(SK_ColorRED);
-  canvas = sk_ref_sp(recorder.beginRecording(SkRect::MakeXYWH(
-      offset.x(), offset.y(), layer_size.width(), layer_size.height())));
+  canvas = recorder.beginRecording(SkRect::MakeXYWH(
+      offset.x(), offset.y(), layer_size.width(), layer_size.height()));
   canvas->translate(offset.x(), offset.y());
   canvas->drawRectCoords(0.f, 0.f, 4.f, 4.f, red_paint);
   sk_sp<SkPicture> test_picture = recorder.finishRecordingAsPicture();
diff --git a/cc/blimp/picture_data_conversions_unittest.cc b/cc/blimp/picture_data_conversions_unittest.cc
index f3e64db53843..535b312fb166 100644
--- a/cc/blimp/picture_data_conversions_unittest.cc
+++ b/cc/blimp/picture_data_conversions_unittest.cc
@@ -23,9 +23,7 @@ namespace cc {
 namespace {
 sk_sp<const SkPicture> CreateSkPicture(SkColor color) {
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas =
-      sk_ref_sp(recorder.beginRecording(SkRect::MakeWH(1, 1)));
-  canvas->drawColor(color);
+  recorder.beginRecording(SkRect::MakeWH(1, 1))->drawColor(color);
   return recorder.finishRecordingAsPicture();
 }
 
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 4a4d89097ff3..d14526eb5f2d 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -128,7 +128,7 @@ bool SoftwareRenderer::BindFramebufferToTexture(
       base::MakeUnique<ResourceProvider::ScopedWriteLockSoftware>(
           resource_provider_, texture->id());
   current_framebuffer_canvas_ =
-      sk_make_sp<SkCanvas>(current_framebuffer_lock_->sk_bitmap());
+      base::MakeUnique<SkCanvas>(current_framebuffer_lock_->sk_bitmap());
   current_canvas_ = current_framebuffer_canvas_.get();
   return true;
 }
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index 28effca5ad1a..ef919a2fcbf1 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -104,7 +104,7 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
   SkPaint current_paint_;
   std::unique_ptr<ResourceProvider::ScopedWriteLockSoftware>
       current_framebuffer_lock_;
-  sk_sp<SkCanvas> current_framebuffer_canvas_;
+  std::unique_ptr<SkCanvas> current_framebuffer_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareRenderer);
 };
diff --git a/cc/playback/discardable_image_map.cc b/cc/playback/discardable_image_map.cc
index 7082e4a0cb56..e4ae644e2275 100644
--- a/cc/playback/discardable_image_map.cc
+++ b/cc/playback/discardable_image_map.cc
@@ -10,6 +10,7 @@
 #include <limits>
 
 #include "base/containers/adapters.h"
+#include "base/memory/ptr_util.h"
 #include "cc/base/math_util.h"
 #include "cc/playback/display_item_list.h"
 #include "third_party/skia/include/utils/SkNWayCanvas.h"
@@ -189,10 +190,10 @@ DiscardableImageMap::DiscardableImageMap() {}
 
 DiscardableImageMap::~DiscardableImageMap() {}
 
-sk_sp<SkCanvas> DiscardableImageMap::BeginGeneratingMetadata(
+std::unique_ptr<SkCanvas> DiscardableImageMap::BeginGeneratingMetadata(
     const gfx::Size& bounds) {
   DCHECK(all_images_.empty());
-  return sk_make_sp<DiscardableImagesMetadataCanvas>(
+  return base::MakeUnique<DiscardableImagesMetadataCanvas>(
       bounds.width(), bounds.height(), &all_images_);
 }
 
diff --git a/cc/playback/discardable_image_map.h b/cc/playback/discardable_image_map.h
index adae86248074..00506809a5fc 100644
--- a/cc/playback/discardable_image_map.h
+++ b/cc/playback/discardable_image_map.h
@@ -36,7 +36,7 @@ class CC_EXPORT DiscardableImageMap {
 
    private:
     DiscardableImageMap* image_map_;
-    sk_sp<SkCanvas> metadata_canvas_;
+    std::unique_ptr<SkCanvas> metadata_canvas_;
   };
 
   DiscardableImageMap();
@@ -51,7 +51,7 @@ class CC_EXPORT DiscardableImageMap {
   friend class ScopedMetadataGenerator;
   friend class DiscardableImageMapTest;
 
-  sk_sp<SkCanvas> BeginGeneratingMetadata(const gfx::Size& bounds);
+  std::unique_ptr<SkCanvas> BeginGeneratingMetadata(const gfx::Size& bounds);
   void EndGeneratingMetadata();
 
   std::vector<std::pair<DrawImage, gfx::Rect>> all_images_;
diff --git a/cc/playback/display_item_list_unittest.cc b/cc/playback/display_item_list_unittest.cc
index bcee1202839a..9bbc5d92fe78 100644
--- a/cc/playback/display_item_list_unittest.cc
+++ b/cc/playback/display_item_list_unittest.cc
@@ -52,9 +52,7 @@ scoped_refptr<DisplayItemList> CreateDefaultList() {
 
 sk_sp<const SkPicture> CreateRectPicture(const gfx::Rect& bounds) {
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
-
-  canvas = sk_ref_sp(recorder.beginRecording(bounds.width(), bounds.height()));
+  SkCanvas* canvas = recorder.beginRecording(bounds.width(), bounds.height());
   canvas->drawRect(
       SkRect::MakeXYWH(bounds.x(), bounds.y(), bounds.width(), bounds.height()),
       SkPaint());
@@ -65,13 +63,12 @@ void AppendFirstSerializationTestPicture(scoped_refptr<DisplayItemList> list,
                                          const gfx::Size& layer_size) {
   gfx::PointF offset(2.f, 3.f);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
 
   SkPaint red_paint;
   red_paint.setColor(SK_ColorRED);
 
-  canvas = sk_ref_sp(recorder.beginRecording(SkRect::MakeXYWH(
-      offset.x(), offset.y(), layer_size.width(), layer_size.height())));
+  SkCanvas* canvas = recorder.beginRecording(SkRect::MakeXYWH(
+      offset.x(), offset.y(), layer_size.width(), layer_size.height()));
   canvas->translate(offset.x(), offset.y());
   canvas->drawRectCoords(0.f, 0.f, 4.f, 4.f, red_paint);
   list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -82,13 +79,12 @@ void AppendSecondSerializationTestPicture(scoped_refptr<DisplayItemList> list,
                                           const gfx::Size& layer_size) {
   gfx::PointF offset(2.f, 2.f);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
 
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
 
-  canvas = sk_ref_sp(recorder.beginRecording(SkRect::MakeXYWH(
-      offset.x(), offset.y(), layer_size.width(), layer_size.height())));
+  SkCanvas* canvas = recorder.beginRecording(SkRect::MakeXYWH(
+      offset.x(), offset.y(), layer_size.width(), layer_size.height()));
   canvas->translate(offset.x(), offset.y());
   canvas->drawRectCoords(3.f, 3.f, 7.f, 7.f, blue_paint);
   list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -295,7 +291,6 @@ TEST(DisplayItemListTest, SerializeTransformItem) {
 TEST(DisplayItemListTest, SingleDrawingItem) {
   gfx::Rect layer_rect(100, 100);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   SkPaint red_paint;
@@ -307,8 +302,8 @@ TEST(DisplayItemListTest, SingleDrawingItem) {
 
   gfx::PointF offset(8.f, 9.f);
   gfx::RectF recording_rect(offset, gfx::SizeF(layer_rect.size()));
-  canvas =
-      sk_ref_sp(recorder.beginRecording(gfx::RectFToSkRect(recording_rect)));
+  SkCanvas* canvas =
+      recorder.beginRecording(gfx::RectFToSkRect(recording_rect));
   canvas->translate(offset.x(), offset.y());
   canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
   canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
@@ -337,7 +332,6 @@ TEST(DisplayItemListTest, SingleDrawingItem) {
 TEST(DisplayItemListTest, ClipItem) {
   gfx::Rect layer_rect(100, 100);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   SkPaint red_paint;
@@ -349,8 +343,8 @@ TEST(DisplayItemListTest, ClipItem) {
 
   gfx::PointF first_offset(8.f, 9.f);
   gfx::RectF first_recording_rect(first_offset, gfx::SizeF(layer_rect.size()));
-  canvas = sk_ref_sp(
-      recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect)));
+  SkCanvas* canvas =
+      recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect));
   canvas->translate(first_offset.x(), first_offset.y());
   canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
   list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -363,8 +357,7 @@ TEST(DisplayItemListTest, ClipItem) {
   gfx::PointF second_offset(2.f, 3.f);
   gfx::RectF second_recording_rect(second_offset,
                                    gfx::SizeF(layer_rect.size()));
-  canvas = sk_ref_sp(
-      recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect)));
+  canvas = recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect));
   canvas->translate(second_offset.x(), second_offset.y());
   canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
   list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -396,7 +389,6 @@ TEST(DisplayItemListTest, ClipItem) {
 TEST(DisplayItemListTest, TransformItem) {
   gfx::Rect layer_rect(100, 100);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   SkPaint red_paint;
@@ -408,8 +400,8 @@ TEST(DisplayItemListTest, TransformItem) {
 
   gfx::PointF first_offset(8.f, 9.f);
   gfx::RectF first_recording_rect(first_offset, gfx::SizeF(layer_rect.size()));
-  canvas = sk_ref_sp(
-      recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect)));
+  SkCanvas* canvas =
+      recorder.beginRecording(gfx::RectFToSkRect(first_recording_rect));
   canvas->translate(first_offset.x(), first_offset.y());
   canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
   list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -422,8 +414,7 @@ TEST(DisplayItemListTest, TransformItem) {
   gfx::PointF second_offset(2.f, 3.f);
   gfx::RectF second_recording_rect(second_offset,
                                    gfx::SizeF(layer_rect.size()));
-  canvas = sk_ref_sp(
-      recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect)));
+  canvas = recorder.beginRecording(gfx::RectFToSkRect(second_recording_rect));
   canvas->translate(second_offset.x(), second_offset.y());
   canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
   list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -485,13 +476,12 @@ TEST(DisplayItemListTest, FilterItem) {
   // Include a rect drawing so that filter is actually applied to something.
   {
     SkPictureRecorder recorder;
-    sk_sp<SkCanvas> canvas;
 
     SkPaint red_paint;
     red_paint.setColor(SK_ColorRED);
 
-    canvas = sk_ref_sp(recorder.beginRecording(
-        SkRect::MakeXYWH(0, 0, layer_rect.width(), layer_rect.height())));
+    SkCanvas* canvas = recorder.beginRecording(
+        SkRect::MakeXYWH(0, 0, layer_rect.width(), layer_rect.height()));
     canvas->drawRectCoords(filter_bounds.x(), filter_bounds.y(),
                            filter_bounds.right(), filter_bounds.bottom(),
                            red_paint);
@@ -520,7 +510,6 @@ TEST(DisplayItemListTest, FilterItem) {
 TEST(DisplayItemListTest, CompactingItems) {
   gfx::Rect layer_rect(100, 100);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   SkPaint red_paint;
@@ -534,8 +523,8 @@ TEST(DisplayItemListTest, CompactingItems) {
   scoped_refptr<DisplayItemList> list_without_caching =
       DisplayItemList::Create(no_caching_settings);
 
-  canvas =
-      sk_ref_sp(recorder.beginRecording(gfx::RectFToSkRect(recording_rect)));
+  SkCanvas* canvas =
+      recorder.beginRecording(gfx::RectFToSkRect(recording_rect));
   canvas->translate(offset.x(), offset.y());
   canvas->drawRectCoords(0.f, 0.f, 60.f, 60.f, red_paint);
   canvas->drawRectCoords(50.f, 50.f, 75.f, 75.f, blue_paint);
diff --git a/cc/raster/gpu_raster_buffer_provider.cc b/cc/raster/gpu_raster_buffer_provider.cc
index dbe72d62dc03..aaf2ea4ff317 100644
--- a/cc/raster/gpu_raster_buffer_provider.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc
@@ -60,8 +60,8 @@ static sk_sp<SkPicture> PlaybackToPicture(
 
   // Play back raster_source into temp SkPicture.
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas = sk_ref_sp(
-      recorder.beginRecording(resource_size.width(), resource_size.height()));
+  SkCanvas* canvas =
+      recorder.beginRecording(resource_size.width(), resource_size.height());
   canvas->save();
 
   // The GPU image decode controller assumes that Skia is done with an image
@@ -73,7 +73,7 @@ static sk_sp<SkPicture> PlaybackToPicture(
   // later picture rasterization.
   RasterSource::PlaybackSettings settings = playback_settings;
   settings.use_image_hijack_canvas = false;
-  raster_source->PlaybackToCanvas(canvas.get(), raster_full_rect, playback_rect,
+  raster_source->PlaybackToCanvas(canvas, raster_full_rect, playback_rect,
                                   scales, settings);
   canvas->restore();
   return recorder.finishRecordingAsPicture();
diff --git a/cc/test/fake_content_layer_client.cc b/cc/test/fake_content_layer_client.cc
index 11c8b3e6cae7..e192e3a3f091 100644
--- a/cc/test/fake_content_layer_client.cc
+++ b/cc/test/fake_content_layer_client.cc
@@ -58,13 +58,12 @@ FakeContentLayerClient::PaintContentsToDisplayList(
       DisplayItemList::Create(settings);
   display_list->SetRetainVisualRectsForTesting(true);
   SkPictureRecorder recorder;
-  sk_sp<SkCanvas> canvas;
 
   for (RectPaintVector::const_iterator it = draw_rects_.begin();
        it != draw_rects_.end(); ++it) {
     const gfx::RectF& draw_rect = it->first;
     const SkPaint& paint = it->second;
-    canvas = sk_ref_sp(recorder.beginRecording(gfx::RectFToSkRect(draw_rect)));
+    SkCanvas* canvas = recorder.beginRecording(gfx::RectFToSkRect(draw_rect));
     canvas->drawRect(gfx::RectFToSkRect(draw_rect), paint);
     display_list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
         ToEnclosingRect(draw_rect), recorder.finishRecordingAsPicture());
@@ -76,8 +75,8 @@ FakeContentLayerClient::PaintContentsToDisplayList(
       display_list->CreateAndAppendPairedBeginItem<TransformDisplayItem>(
           it->transform);
     }
-    canvas = sk_ref_sp(
-        recorder.beginRecording(it->image->width(), it->image->height()));
+    SkCanvas* canvas =
+        recorder.beginRecording(it->image->width(), it->image->height());
     canvas->drawImage(it->image.get(), it->point.x(), it->point.y(),
                       &it->paint);
     display_list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
@@ -93,7 +92,7 @@ FakeContentLayerClient::PaintContentsToDisplayList(
     while (!draw_rect.IsEmpty()) {
       SkPaint paint;
       paint.setColor(red ? SK_ColorRED : SK_ColorBLUE);
-      canvas = sk_ref_sp(recorder.beginRecording(gfx::RectToSkRect(draw_rect)));
+      SkCanvas* canvas = recorder.beginRecording(gfx::RectToSkRect(draw_rect));
       canvas->drawIRect(gfx::RectToSkIRect(draw_rect), paint);
       display_list->CreateAndAppendDrawingItem<DrawingDisplayItem>(
           draw_rect, recorder.finishRecordingAsPicture());
diff --git a/cc/test/solid_color_content_layer_client.cc b/cc/test/solid_color_content_layer_client.cc
index b7138f2729b6..58e4ad271cd9 100644
--- a/cc/test/solid_color_content_layer_client.cc
+++ b/cc/test/solid_color_content_layer_client.cc
@@ -26,8 +26,7 @@ SolidColorContentLayerClient::PaintContentsToDisplayList(
     PaintingControlSetting painting_control) {
   SkPictureRecorder recorder;
   gfx::Rect clip(PaintableRegion());
-  sk_sp<SkCanvas> canvas =
-      sk_ref_sp(recorder.beginRecording(gfx::RectToSkRect(clip)));
+  SkCanvas* canvas = recorder.beginRecording(gfx::RectToSkRect(clip));
 
   canvas->clear(SK_ColorTRANSPARENT);
 
diff --git a/cc/trees/layer_tree_host_pixeltest_masks.cc b/cc/trees/layer_tree_host_pixeltest_masks.cc
index 87e92a43553e..0ce262cb50a7 100644
--- a/cc/trees/layer_tree_host_pixeltest_masks.cc
+++ b/cc/trees/layer_tree_host_pixeltest_masks.cc
@@ -40,8 +40,8 @@ class MaskContentLayerClient : public ContentLayerClient {
   scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
       PaintingControlSetting picture_control) override {
     SkPictureRecorder recorder;
-    sk_sp<SkCanvas> canvas = sk_ref_sp(
-        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(bounds_))));
+    SkCanvas* canvas =
+        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(bounds_)));
 
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
@@ -163,8 +163,8 @@ class CheckerContentLayerClient : public ContentLayerClient {
   scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
       PaintingControlSetting picture_control) override {
     SkPictureRecorder recorder;
-    sk_sp<SkCanvas> canvas = sk_ref_sp(
-        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(bounds_))));
+    SkCanvas* canvas =
+        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(bounds_)));
 
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
@@ -207,8 +207,8 @@ class CircleContentLayerClient : public ContentLayerClient {
   scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
       PaintingControlSetting picture_control) override {
     SkPictureRecorder recorder;
-    sk_sp<SkCanvas> canvas = sk_ref_sp(
-        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(bounds_))));
+    SkCanvas* canvas =
+        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(bounds_)));
 
     SkPaint paint;
     paint.setStyle(SkPaint::kFill_Style);
diff --git a/cc/trees/layer_tree_host_pixeltest_tiles.cc b/cc/trees/layer_tree_host_pixeltest_tiles.cc
index 9a649dcece9c..b569208f0188 100644
--- a/cc/trees/layer_tree_host_pixeltest_tiles.cc
+++ b/cc/trees/layer_tree_host_pixeltest_tiles.cc
@@ -115,8 +115,8 @@ class BlueYellowClient : public ContentLayerClient {
         DisplayItemList::Create(settings);
 
     SkPictureRecorder recorder;
-    sk_sp<SkCanvas> canvas =
-        sk_ref_sp(recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(size_))));
+    SkCanvas* canvas =
+        recorder.beginRecording(gfx::RectToSkRect(gfx::Rect(size_)));
     gfx::Rect top(0, 0, size_.width(), size_.height() / 2);
     gfx::Rect bottom(0, size_.height() / 2, size_.width(), size_.height() / 2);
 
diff --git a/chrome/browser/android/compositor/layer/crushed_sprite_layer.cc b/chrome/browser/android/compositor/layer/crushed_sprite_layer.cc
index 3a6e604908cd..f7799bc50140 100644
--- a/chrome/browser/android/compositor/layer/crushed_sprite_layer.cc
+++ b/chrome/browser/android/compositor/layer/crushed_sprite_layer.cc
@@ -53,13 +53,13 @@ void CrushedSpriteLayer::DrawSpriteFrame(
     SkBitmap bitmap;
     bitmap.allocN32Pixels(resource->GetUnscaledSpriteSize().width(),
                           resource->GetUnscaledSpriteSize().height());
-    sk_sp<SkCanvas> canvas = sk_make_sp<SkCanvas>(bitmap);
+    SkCanvas canvas(bitmap);
 
     if (previous_frame_ == -1 ||
         sprite_frame == resource->GetFrameCount() - 1) {
       // The newly allocated pixels for the SkBitmap need to be cleared if this
       // is the first frame being drawn or the last frame. See crbug.com/549453.
-      canvas->clear(SK_ColorTRANSPARENT);
+      canvas.clear(SK_ColorTRANSPARENT);
     }
 
     // If this isn't the first or last frame, draw the previous frame(s).
@@ -70,17 +70,17 @@ void CrushedSpriteLayer::DrawSpriteFrame(
     if (sprite_frame != 0 && sprite_frame != resource->GetFrameCount() - 1) {
       // Draw the previous frame.
       if (previous_frame_ != -1) {
-        canvas->drawBitmap(previous_frame_bitmap_, 0, 0, nullptr);
+        canvas.drawBitmap(previous_frame_bitmap_, 0, 0, nullptr);
       }
 
       // Draw any skipped frames.
       for (int i = previous_frame_ + 1; i < sprite_frame; ++i) {
-        DrawRectanglesForFrame(resource, i, canvas);
+        DrawRectanglesForFrame(resource, i, &canvas);
       }
     }
 
     // Draw the current frame.
-    DrawRectanglesForFrame(resource, sprite_frame, canvas);
+    DrawRectanglesForFrame(resource, sprite_frame, &canvas);
 
     // Set the bitmap on layer_.
     bitmap.setImmutable();
@@ -103,7 +103,7 @@ void CrushedSpriteLayer::DrawSpriteFrame(
 void CrushedSpriteLayer::DrawRectanglesForFrame(
     ui::CrushedSpriteResource* resource,
     int frame,
-    sk_sp<SkCanvas> canvas) {
+    SkCanvas* canvas) {
   ui::CrushedSpriteResource::FrameSrcDstRects src_dst_rects =
        resource->GetRectanglesForFrame(frame);
   for (const auto& rect : src_dst_rects) {
diff --git a/chrome/browser/android/compositor/layer/crushed_sprite_layer.h b/chrome/browser/android/compositor/layer/crushed_sprite_layer.h
index 5dbc5cb9275d..0b425f10dce7 100644
--- a/chrome/browser/android/compositor/layer/crushed_sprite_layer.h
+++ b/chrome/browser/android/compositor/layer/crushed_sprite_layer.h
@@ -49,7 +49,7 @@ class CrushedSpriteLayer : public Layer {
   // Draws the rectangles for |frame| to |canvas|.
   void DrawRectanglesForFrame(ui::CrushedSpriteResource* resource,
                               int frame,
-                              sk_sp<SkCanvas> canvas);
+                              SkCanvas* canvas);
 
   scoped_refptr<cc::UIResourceLayer> layer_;
   int frame_count_;
diff --git a/components/test_runner/pixel_dump.cc b/components/test_runner/pixel_dump.cc
index de2316a71aa9..67881c94b300 100644
--- a/components/test_runner/pixel_dump.cc
+++ b/components/test_runner/pixel_dump.cc
@@ -96,8 +96,8 @@ void CapturePixelsForPrinting(std::unique_ptr<PixelsDumpRequest> dump_request) {
   int totalHeight = page_count * (page_size_in_pixels.height + 1) - 1;
 
   bool is_opaque = false;
-  sk_sp<SkCanvas> canvas(skia::TryCreateBitmapCanvas(
-      page_size_in_pixels.width, totalHeight, is_opaque));
+  std::unique_ptr<SkCanvas> canvas = skia::TryCreateBitmapCanvas(
+      page_size_in_pixels.width, totalHeight, is_opaque);
   if (!canvas) {
     LOG(ERROR) << "Failed to create canvas width="
                << page_size_in_pixels.width << " height=" << totalHeight;
diff --git a/content/browser/compositor/software_output_device_mac.h b/content/browser/compositor/software_output_device_mac.h
index e0a1b1f0c499..a0bc91098679 100644
--- a/content/browser/compositor/software_output_device_mac.h
+++ b/content/browser/compositor/software_output_device_mac.h
@@ -66,7 +66,7 @@ class SoftwareOutputDeviceMac :
 
   // The SkCanvas wrapps the mapped current IOSurface. It is valid only between
   // BeginPaint and EndPaint.
-  sk_sp<SkCanvas> canvas_;
+  std::unique_ptr<SkCanvas> canvas_;
 
   gfx::VSyncProvider::UpdateVSyncCallback update_vsync_callback_;
 
diff --git a/content/browser/compositor/software_output_device_mac.mm b/content/browser/compositor/software_output_device_mac.mm
index bff1570c1fe1..1db33824c81f 100644
--- a/content/browser/compositor/software_output_device_mac.mm
+++ b/content/browser/compositor/software_output_device_mac.mm
@@ -114,8 +114,8 @@
       IOSurfaceGetBaseAddress(io_surfaces_[current_index_]));
   size_t stride = IOSurfaceGetBytesPerRow(io_surfaces_[current_index_]);
 
-  canvas_ = sk_sp<SkCanvas>(SkCanvas::NewRasterDirectN32(
-      pixel_size_.width(), pixel_size_.height(), pixels, stride));
+  canvas_ = SkCanvas::MakeRasterDirectN32(pixel_size_.width(),
+                                          pixel_size_.height(), pixels, stride);
 
   CopyPreviousBufferDamage(SkRegion(gfx::RectToSkIRect(new_damage_rect)));
 
diff --git a/content/browser/compositor/software_output_device_win.cc b/content/browser/compositor/software_output_device_win.cc
index c48bed4fa0eb..2edf325b360a 100644
--- a/content/browser/compositor/software_output_device_win.cc
+++ b/content/browser/compositor/software_output_device_win.cc
@@ -139,9 +139,9 @@ SkCanvas* SoftwareOutputDeviceWin::BeginPaint(const gfx::Rect& damage_rect) {
       }
     }
     if (can_create_contents) {
-      contents_ = sk_sp<SkCanvas>(skia::CreatePlatformCanvas(
+      contents_ = skia::CreatePlatformCanvas(
           viewport_pixel_size_.width(), viewport_pixel_size_.height(), true,
-          shared_section, skia::CRASH_ON_FAILURE));
+          shared_section, skia::CRASH_ON_FAILURE);
     }
   }
 
@@ -192,7 +192,6 @@ void SoftwareOutputDeviceWin::EndPaint() {
 }
 
 void SoftwareOutputDeviceWin::ReleaseContents() {
-  DCHECK(!contents_ || contents_->unique());
   DCHECK(!in_paint_);
   contents_.reset();
 }
diff --git a/content/browser/compositor/software_output_device_win.h b/content/browser/compositor/software_output_device_win.h
index 61066ceaa948..2c0780faec3e 100644
--- a/content/browser/compositor/software_output_device_win.h
+++ b/content/browser/compositor/software_output_device_win.h
@@ -63,7 +63,7 @@ class SoftwareOutputDeviceWin : public cc::SoftwareOutputDevice {
 
  private:
   HWND hwnd_;
-  sk_sp<SkCanvas> contents_;
+  std::unique_ptr<SkCanvas> contents_;
   bool is_hwnd_composited_;
   OutputDeviceBacking* backing_;
   bool in_paint_;
diff --git a/content/renderer/pepper/pepper_plugin_instance_impl.cc b/content/renderer/pepper/pepper_plugin_instance_impl.cc
index bb02dbee9f4b..367fa644a0a5 100644
--- a/content/renderer/pepper/pepper_plugin_instance_impl.cc
+++ b/content/renderer/pepper/pepper_plugin_instance_impl.cc
@@ -1798,7 +1798,7 @@ int PepperPluginInstanceImpl::PrintBegin(const WebPrintParams& print_params) {
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
-  canvas_.reset();
+  canvas_ = nullptr;
   ranges_.clear();
   return num_pages;
 }
@@ -1817,7 +1817,7 @@ void PepperPluginInstanceImpl::PrintPage(int page_number,
 #endif  // defined(OS_MACOSX)
   if (save_for_later) {
     ranges_.push_back(page_range);
-    canvas_ = sk_ref_sp(canvas);
+    canvas_ = canvas;
   } else {
     PrintPageHelper(&page_range, 1, canvas);
   }
@@ -1849,8 +1849,8 @@ void PepperPluginInstanceImpl::PrintEnd() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   if (!ranges_.empty())
-    PrintPageHelper(&(ranges_.front()), ranges_.size(), canvas_.get());
-  canvas_.reset();
+    PrintPageHelper(&(ranges_.front()), ranges_.size(), canvas_);
+  canvas_ = nullptr;
   ranges_.clear();
 
   DCHECK(plugin_print_interface_);
diff --git a/content/renderer/pepper/pepper_plugin_instance_impl.h b/content/renderer/pepper/pepper_plugin_instance_impl.h
index dc08cfff6c7d..dade2ee2e635 100644
--- a/content/renderer/pepper/pepper_plugin_instance_impl.h
+++ b/content/renderer/pepper/pepper_plugin_instance_impl.h
@@ -839,8 +839,9 @@ class CONTENT_EXPORT PepperPluginInstanceImpl
   // is preserved in PrintWebViewHelper::PrintPages. This makes it possible
   // to generate the entire PDF given the variables below:
   //
-  // The most recently used WebCanvas, guaranteed to be valid.
-  sk_sp<blink::WebCanvas> canvas_;
+  // The most recently used WebCanvas to be used in printEnd(). Caller must
+  // ensure that it remains valid until that point.
+  blink::WebCanvas* canvas_;
   // An array of page ranges.
   std::vector<PP_PrintPageNumberRange_Dev> ranges_;
 
diff --git a/content/renderer/pepper/ppb_image_data_impl.cc b/content/renderer/pepper/ppb_image_data_impl.cc
index 7b8740b1ebd3..edf80694df95 100644
--- a/content/renderer/pepper/ppb_image_data_impl.cc
+++ b/content/renderer/pepper/ppb_image_data_impl.cc
@@ -171,8 +171,7 @@ TransportDIB* ImageDataPlatformBackend::GetTransportDIB() const {
 void* ImageDataPlatformBackend::Map() {
   if (!mapped_canvas_) {
     const bool is_opaque = false;
-    mapped_canvas_ =
-        sk_sp<SkCanvas>(dib_->GetPlatformCanvas(width_, height_, is_opaque));
+    mapped_canvas_ = dib_->GetPlatformCanvas(width_, height_, is_opaque);
     if (!mapped_canvas_)
       return NULL;
   }
@@ -250,7 +249,7 @@ void* ImageDataSimpleBackend::Map() {
     skia_bitmap_.setPixels(shared_memory_->memory());
     // Our platform bitmaps are set to opaque by default, which we don't want.
     skia_bitmap_.setAlphaType(kPremul_SkAlphaType);
-    skia_canvas_ = sk_make_sp<SkCanvas>(skia_bitmap_);
+    skia_canvas_ = base::MakeUnique<SkCanvas>(skia_bitmap_);
     return skia_bitmap_.getAddr32(0, 0);
   }
   return shared_memory_->memory();
diff --git a/content/renderer/pepper/ppb_image_data_impl.h b/content/renderer/pepper/ppb_image_data_impl.h
index 28fa33bd89f5..81c9a5a68ebd 100644
--- a/content/renderer/pepper/ppb_image_data_impl.h
+++ b/content/renderer/pepper/ppb_image_data_impl.h
@@ -149,7 +149,7 @@ class ImageDataPlatformBackend : public PPB_ImageData_Impl::Backend {
   std::unique_ptr<TransportDIB> dib_;
 
   // When the device is mapped, this is the image. Null when umapped.
-  sk_sp<SkCanvas> mapped_canvas_;
+  std::unique_ptr<SkCanvas> mapped_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDataPlatformBackend);
 };
@@ -179,7 +179,7 @@ class ImageDataSimpleBackend : public PPB_ImageData_Impl::Backend {
   std::unique_ptr<base::SharedMemory> shared_memory_;
   // skia_bitmap_ is backed by shared_memory_.
   SkBitmap skia_bitmap_;
-  sk_sp<SkCanvas> skia_canvas_;
+  std::unique_ptr<SkCanvas> skia_canvas_;
   uint32_t map_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDataSimpleBackend);
diff --git a/ppapi/proxy/ppb_image_data_proxy.cc b/ppapi/proxy/ppb_image_data_proxy.cc
index bde81b43fb62..b4415fdada0f 100644
--- a/ppapi/proxy/ppb_image_data_proxy.cc
+++ b/ppapi/proxy/ppb_image_data_proxy.cc
@@ -391,10 +391,8 @@ void* PlatformImageData::Map() {
       return NULL;
 
     const bool is_opaque = false;
-    mapped_canvas_ =
-        sk_sp<SkCanvas>(transport_dib_->GetPlatformCanvas(desc_.size.width,
-                                                          desc_.size.height,
-                                                          is_opaque));
+    mapped_canvas_ = transport_dib_->GetPlatformCanvas(
+        desc_.size.width, desc_.size.height, is_opaque);
     if (!mapped_canvas_.get())
       return NULL;
   }
diff --git a/ppapi/proxy/ppb_image_data_proxy.h b/ppapi/proxy/ppb_image_data_proxy.h
index 2e5554d57088..2b39aa0c8bae 100644
--- a/ppapi/proxy/ppb_image_data_proxy.h
+++ b/ppapi/proxy/ppb_image_data_proxy.h
@@ -104,7 +104,7 @@ class PPAPI_PROXY_EXPORT PlatformImageData : public ImageData {
   std::unique_ptr<TransportDIB> transport_dib_;
 
   // Null when the image isn't mapped.
-  sk_sp<SkCanvas> mapped_canvas_;
+  std::unique_ptr<SkCanvas> mapped_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformImageData);
 };
diff --git a/skia/config/SkUserConfig.h b/skia/config/SkUserConfig.h
index ad0bf69e1872..ebf1e6d5d7d9 100644
--- a/skia/config/SkUserConfig.h
+++ b/skia/config/SkUserConfig.h
@@ -212,10 +212,6 @@ SK_API void SkDebugf_FileLine(const char* file, int line, bool fatal,
 #   define SK_SUPPORT_LEGACY_ANISOTROPIC_MIPMAP_SCALE
 #endif
 
-#ifndef    SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-#   define SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT
-#endif
-
 #ifndef    SK_IGNORE_ETC1_SUPPORT
 #   define SK_IGNORE_ETC1_SUPPORT
 #endif
diff --git a/skia/ext/analysis_canvas_unittest.cc b/skia/ext/analysis_canvas_unittest.cc
index f64722a5dec9..9d9eb1c77262 100644
--- a/skia/ext/analysis_canvas_unittest.cc
+++ b/skia/ext/analysis_canvas_unittest.cc
@@ -329,7 +329,7 @@ TEST(AnalysisCanvasTest, EarlyOutNotSolid) {
   SkPictureRecorder recorder;
 
   // Create a picture with 3 commands, last of which is non-solid.
-  sk_sp<SkCanvas> record_canvas = sk_ref_sp(recorder.beginRecording(256, 256, &factory));
+  SkCanvas* record_canvas = recorder.beginRecording(256, 256, &factory);
 
   std::string text = "text";
   SkPoint point = SkPoint::Make(SkIntToScalar(25), SkIntToScalar(25));
diff --git a/skia/ext/bitmap_platform_device_cairo.cc b/skia/ext/bitmap_platform_device_cairo.cc
index 231c3a8b4a40..093719e1cad9 100644
--- a/skia/ext/bitmap_platform_device_cairo.cc
+++ b/skia/ext/bitmap_platform_device_cairo.cc
@@ -166,8 +166,11 @@ cairo_t* BitmapPlatformDevice::BeginPlatformPaint(
 
 // PlatformCanvas impl
 
-SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
-                               uint8_t* data, OnFailureType failureType) {
+std::unique_ptr<SkCanvas> CreatePlatformCanvas(int width,
+                                               int height,
+                                               bool is_opaque,
+                                               uint8_t* data,
+                                               OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(width, height, is_opaque, data));
   return CreateCanvas(dev, failureType);
diff --git a/skia/ext/bitmap_platform_device_mac.cc b/skia/ext/bitmap_platform_device_mac.cc
index 06a41390b5db..bf02a89a5e1b 100644
--- a/skia/ext/bitmap_platform_device_mac.cc
+++ b/skia/ext/bitmap_platform_device_mac.cc
@@ -260,16 +260,22 @@ SkBaseDevice* BitmapPlatformDevice::onCreateDevice(const CreateInfo& cinfo,
 
 // PlatformCanvas impl
 
-SkCanvas* CreatePlatformCanvas(CGContextRef ctx, int width, int height,
-                               bool is_opaque, OnFailureType failureType) {
+std::unique_ptr<SkCanvas> CreatePlatformCanvas(CGContextRef ctx,
+                                               int width,
+                                               int height,
+                                               bool is_opaque,
+                                               OnFailureType failureType) {
   const bool do_clear = false;
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(ctx, width, height, is_opaque, do_clear));
   return CreateCanvas(dev, failureType);
 }
 
-SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
-                               uint8_t* data, OnFailureType failureType) {
+std::unique_ptr<SkCanvas> CreatePlatformCanvas(int width,
+                                               int height,
+                                               bool is_opaque,
+                                               uint8_t* data,
+                                               OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::CreateWithData(data, width, height, is_opaque));
   return CreateCanvas(dev, failureType);
diff --git a/skia/ext/bitmap_platform_device_mac_unittest.cc b/skia/ext/bitmap_platform_device_mac_unittest.cc
index b1f6ee74dab1..9d8020b0d699 100644
--- a/skia/ext/bitmap_platform_device_mac_unittest.cc
+++ b/skia/ext/bitmap_platform_device_mac_unittest.cc
@@ -32,7 +32,8 @@ TEST_F(BitmapPlatformDeviceMacTest, ClipRectTransformWithTranslate) {
   SkMatrix transform;
   transform.setTranslate(50, 140);
 
-  sk_sp<SkCanvas> canvas(skia::CreateCanvas(bitmap_, CRASH_ON_FAILURE));
+  std::unique_ptr<SkCanvas> canvas =
+      skia::CreateCanvas(bitmap_, CRASH_ON_FAILURE);
   canvas->setMatrix(transform);
 
   ScopedPlatformPaint p(canvas.get());
@@ -50,7 +51,8 @@ TEST_F(BitmapPlatformDeviceMacTest, ClipRectTransformWithScale) {
   SkMatrix transform;
   transform.setScale(0.5, 0.5);
 
-  sk_sp<SkCanvas> canvas(skia::CreateCanvas(bitmap_, CRASH_ON_FAILURE));
+  std::unique_ptr<SkCanvas> canvas =
+      skia::CreateCanvas(bitmap_, CRASH_ON_FAILURE);
   canvas->setMatrix(transform);
 
   ScopedPlatformPaint p(canvas.get());
diff --git a/skia/ext/bitmap_platform_device_skia.cc b/skia/ext/bitmap_platform_device_skia.cc
index 77957af919be..d19810badac5 100644
--- a/skia/ext/bitmap_platform_device_skia.cc
+++ b/skia/ext/bitmap_platform_device_skia.cc
@@ -60,8 +60,11 @@ NativeDrawingContext BitmapPlatformDevice::BeginPlatformPaint(
 
 // PlatformCanvas impl
 
-SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
-                               uint8_t* data, OnFailureType failureType) {
+std::unique_ptr<SkCanvas> CreatePlatformCanvas(int width,
+                                               int height,
+                                               bool is_opaque,
+                                               uint8_t* data,
+                                               OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(width, height, is_opaque, data));
   return CreateCanvas(dev, failureType);
diff --git a/skia/ext/bitmap_platform_device_win.cc b/skia/ext/bitmap_platform_device_win.cc
index 4687c920b32c..44a3ea5705e9 100644
--- a/skia/ext/bitmap_platform_device_win.cc
+++ b/skia/ext/bitmap_platform_device_win.cc
@@ -207,11 +207,11 @@ SkBaseDevice* BitmapPlatformDevice::onCreateDevice(const CreateInfo& cinfo,
 
 // PlatformCanvas impl
 
-SkCanvas* CreatePlatformCanvas(int width,
-                               int height,
-                               bool is_opaque,
-                               HANDLE shared_section,
-                               OnFailureType failureType) {
+std::unique_ptr<SkCanvas> CreatePlatformCanvas(int width,
+                                               int height,
+                                               bool is_opaque,
+                                               HANDLE shared_section,
+                                               OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(width, height, is_opaque, shared_section));
   return CreateCanvas(dev, failureType);
diff --git a/skia/ext/platform_canvas.cc b/skia/ext/platform_canvas.cc
index cf78a4ea925d..ec99dfe92a8f 100644
--- a/skia/ext/platform_canvas.cc
+++ b/skia/ext/platform_canvas.cc
@@ -5,6 +5,7 @@
 #include "skia/ext/platform_canvas.h"
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "skia/ext/platform_device.h"
 #include "third_party/skia/include/core/SkMetaData.h"
@@ -65,14 +66,14 @@ size_t PlatformCanvasStrideForWidth(unsigned width) {
   return 4 * width;
 }
 
-SkCanvas* CreateCanvas(const sk_sp<SkBaseDevice>& device,
-                       OnFailureType failureType) {
+std::unique_ptr<SkCanvas> CreateCanvas(const sk_sp<SkBaseDevice>& device,
+                                       OnFailureType failureType) {
   if (!device) {
     if (CRASH_ON_FAILURE == failureType)
       SK_CRASH();
     return nullptr;
   }
-  return new SkCanvas(device.get());
+  return base::MakeUnique<SkCanvas>(device.get());
 }
 
 SkMetaData& GetMetaData(const SkCanvas& canvas) {
diff --git a/skia/ext/platform_canvas.h b/skia/ext/platform_canvas.h
index c71c0dc702a0..04a4d177ab96 100644
--- a/skia/ext/platform_canvas.h
+++ b/skia/ext/platform_canvas.h
@@ -45,64 +45,68 @@ enum OnFailureType {
 #if defined(WIN32)
   // The shared_section parameter is passed to gfx::PlatformDevice::create.
   // See it for details.
-  SK_API SkCanvas* CreatePlatformCanvas(int width,
-                                        int height,
-                                        bool is_opaque,
-                                        HANDLE shared_section,
-                                        OnFailureType failure_type);
-
-  // Draws the top layer of the canvas into the specified HDC. Only works
-  // with a SkCanvas with a BitmapPlatformDevice. Will create a temporary
-  // HDC to back the canvas if one doesn't already exist, tearing it down
-  // before returning. If |src_rect| is null, copies the entire canvas.
-  SK_API void DrawToNativeContext(SkCanvas* canvas,
-                                  HDC hdc,
-                                  int x,
-                                  int y,
-                                  const RECT* src_rect);
+SK_API std::unique_ptr<SkCanvas> CreatePlatformCanvas(
+    int width,
+    int height,
+    bool is_opaque,
+    HANDLE shared_section,
+    OnFailureType failure_type);
+
+// Draws the top layer of the canvas into the specified HDC. Only works
+// with a SkCanvas with a BitmapPlatformDevice. Will create a temporary
+// HDC to back the canvas if one doesn't already exist, tearing it down
+// before returning. If |src_rect| is null, copies the entire canvas.
+SK_API void DrawToNativeContext(SkCanvas* canvas,
+                                HDC hdc,
+                                int x,
+                                int y,
+                                const RECT* src_rect);
 #elif defined(__APPLE__)
-  SK_API SkCanvas* CreatePlatformCanvas(CGContextRef context,
-                                        int width,
-                                        int height,
-                                        bool is_opaque,
-                                        OnFailureType failure_type);
-
-  SK_API SkCanvas* CreatePlatformCanvas(int width,
-                                        int height,
-                                        bool is_opaque,
-                                        uint8_t* context,
-                                        OnFailureType failure_type);
+SK_API std::unique_ptr<SkCanvas> CreatePlatformCanvas(
+    CGContextRef context,
+    int width,
+    int height,
+    bool is_opaque,
+    OnFailureType failure_type);
+
+SK_API std::unique_ptr<SkCanvas> CreatePlatformCanvas(
+    int width,
+    int height,
+    bool is_opaque,
+    uint8_t* context,
+    OnFailureType failure_type);
 #elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
       defined(__sun) || defined(ANDROID)
   // Linux ---------------------------------------------------------------------
 
   // Construct a canvas from the given memory region. The memory is not cleared
   // first. @data must be, at least, @height * StrideForWidth(@width) bytes.
-  SK_API SkCanvas* CreatePlatformCanvas(int width,
-                                        int height,
-                                        bool is_opaque,
-                                        uint8_t* data,
-                                        OnFailureType failure_type);
+SK_API std::unique_ptr<SkCanvas> CreatePlatformCanvas(
+    int width,
+    int height,
+    bool is_opaque,
+    uint8_t* data,
+    OnFailureType failure_type);
 #endif
 
-static inline SkCanvas* CreatePlatformCanvas(int width,
-                                             int height,
-                                             bool is_opaque) {
+static inline std::unique_ptr<SkCanvas> CreatePlatformCanvas(int width,
+                                                             int height,
+                                                             bool is_opaque) {
   return CreatePlatformCanvas(width, height, is_opaque, 0, CRASH_ON_FAILURE);
 }
 
-SK_API SkCanvas* CreateCanvas(const sk_sp<SkBaseDevice>& device,
-                              OnFailureType failure_type);
+SK_API std::unique_ptr<SkCanvas> CreateCanvas(const sk_sp<SkBaseDevice>& device,
+                                              OnFailureType failure_type);
 
-static inline SkCanvas* CreateBitmapCanvas(int width,
-                                           int height,
-                                           bool is_opaque) {
+static inline std::unique_ptr<SkCanvas> CreateBitmapCanvas(int width,
+                                                           int height,
+                                                           bool is_opaque) {
   return CreatePlatformCanvas(width, height, is_opaque, 0, CRASH_ON_FAILURE);
 }
 
-static inline SkCanvas* TryCreateBitmapCanvas(int width,
-                                              int height,
-                                              bool is_opaque) {
+static inline std::unique_ptr<SkCanvas> TryCreateBitmapCanvas(int width,
+                                                              int height,
+                                                              bool is_opaque) {
   return CreatePlatformCanvas(width, height, is_opaque, 0,
                               RETURN_NULL_ON_FAILURE);
 }
diff --git a/skia/ext/platform_canvas_unittest.cc b/skia/ext/platform_canvas_unittest.cc
index 67c7c8f045f3..38d574f48805 100644
--- a/skia/ext/platform_canvas_unittest.cc
+++ b/skia/ext/platform_canvas_unittest.cc
@@ -233,7 +233,7 @@ const int kInnerH = 3;
 // regular skia primitives.
 TEST(PlatformCanvas, SkLayer) {
   // Create the canvas initialized to opaque white.
-  sk_sp<SkCanvas> canvas(CreatePlatformCanvas(16, 16, true));
+  std::unique_ptr<SkCanvas> canvas = CreatePlatformCanvas(16, 16, true);
   canvas->drawColor(SK_ColorWHITE);
 
   // Make a layer and fill it completely to make sure that the bounds are
@@ -248,7 +248,7 @@ TEST(PlatformCanvas, SkLayer) {
 // Test native clipping.
 TEST(PlatformCanvas, ClipRegion) {
   // Initialize a white canvas
-  sk_sp<SkCanvas> canvas(CreatePlatformCanvas(16, 16, true));
+  std::unique_ptr<SkCanvas> canvas = CreatePlatformCanvas(16, 16, true);
   canvas->drawColor(SK_ColorWHITE);
   EXPECT_TRUE(VerifyCanvasColor(*canvas, SK_ColorWHITE));
 
@@ -273,7 +273,7 @@ TEST(PlatformCanvas, ClipRegion) {
 // Test the layers get filled properly by native rendering.
 TEST(PlatformCanvas, FillLayer) {
   // Create the canvas initialized to opaque white.
-  sk_sp<SkCanvas> canvas(CreatePlatformCanvas(16, 16, true));
+  std::unique_ptr<SkCanvas> canvas(CreatePlatformCanvas(16, 16, true));
 
   // Make a layer and fill it completely to make sure that the bounds are
   // correct.
@@ -322,7 +322,7 @@ TEST(PlatformCanvas, FillLayer) {
 // Test that translation + make layer works properly.
 TEST(PlatformCanvas, TranslateLayer) {
   // Create the canvas initialized to opaque white.
-  sk_sp<SkCanvas> canvas(CreatePlatformCanvas(16, 16, true));
+  std::unique_ptr<SkCanvas> canvas = CreatePlatformCanvas(16, 16, true);
 
   // Make a layer and fill it completely to make sure that the bounds are
   // correct.
diff --git a/skia/ext/skia_utils_mac.mm b/skia/ext/skia_utils_mac.mm
index 9ebdd7a227c8..57fb7076ba21 100644
--- a/skia/ext/skia_utils_mac.mm
+++ b/skia/ext/skia_utils_mac.mm
@@ -190,7 +190,7 @@ SkBitmap CGImageToSkBitmap(CGImageRef image) {
   int width = CGImageGetWidth(image);
   int height = CGImageGetHeight(image);
 
-  sk_sp<SkCanvas> canvas(skia::CreatePlatformCanvas(
+  std::unique_ptr<SkCanvas> canvas(skia::CreatePlatformCanvas(
       nullptr, width, height, false, RETURN_NULL_ON_FAILURE));
   ScopedPlatformPaint p(canvas.get());
   CGContextRef context = p.GetNativeDrawingContext();
diff --git a/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp b/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp
index 9ac7b526814c..3ffba59d7c30 100644
--- a/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp
+++ b/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp
@@ -27,7 +27,7 @@ class SVGImageTest : public ::testing::Test {
 
   void pumpFrame() {
     Image* image = m_image.get();
-    sk_sp<SkCanvas> nullCanvas(SkCreateNullCanvas());
+    std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
     SkPaint paint;
     FloatRect dummyRect(0, 0, 100, 100);
     image->draw(nullCanvas.get(), paint, dummyRect, dummyRect,
diff --git a/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp b/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp
index fe833dd1b166..457772162501 100644
--- a/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp
+++ b/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp
@@ -78,7 +78,7 @@ GraphicsContext::GraphicsContext(PaintController& paintController,
   m_paintState = m_paintStateStack.last().get();
 
   if (contextDisabled()) {
-    DEFINE_STATIC_LOCAL(SkCanvas*, nullCanvas, (SkCreateNullCanvas()));
+    DEFINE_STATIC_LOCAL(SkCanvas*, nullCanvas, (SkMakeNullCanvas().release()));
     m_canvas = nullCanvas;
   }
 }
diff --git a/ui/compositor/paint_recorder.cc b/ui/compositor/paint_recorder.cc
index 2c01e5c43d9c..b48717dc307a 100644
--- a/ui/compositor/paint_recorder.cc
+++ b/ui/compositor/paint_recorder.cc
@@ -14,15 +14,15 @@
 
 namespace ui {
 
+// This class records a reference to the context, the canvas returned
+// by its recorder_, and the cache. Thus all 3 of these must remain
+// valid for the lifetime of this object.
 PaintRecorder::PaintRecorder(const PaintContext& context,
                              const gfx::Size& recording_size,
                              PaintCache* cache)
     : context_(context),
-      // The SkCanvas reference returned by beginRecording is shared with
-      // the recorder_ so no need to store a RefPtr to it on this class, we just
-      // store the gfx::Canvas.
-      canvas_(sk_ref_sp(context.recorder_->beginRecording(
-                        gfx::RectToSkRect(gfx::Rect(recording_size)))),
+      canvas_(context.recorder_->beginRecording(
+                  gfx::RectToSkRect(gfx::Rect(recording_size))),
               context.device_scale_factor_),
       cache_(cache),
       bounds_in_layer_(context.ToLayerSpaceBounds(recording_size)) {
diff --git a/ui/gfx/blit_unittest.cc b/ui/gfx/blit_unittest.cc
index 7598ef658289..50e7952265ad 100644
--- a/ui/gfx/blit_unittest.cc
+++ b/ui/gfx/blit_unittest.cc
@@ -64,8 +64,8 @@ void VerifyCanvasValues(SkCanvas* canvas, uint8_t values[h][w]) {
 TEST(Blit, ScrollCanvas) {
   static const int kCanvasWidth = 5;
   static const int kCanvasHeight = 5;
-  sk_sp<SkCanvas> canvas(
-      skia::CreatePlatformCanvas(kCanvasWidth, kCanvasHeight, true));
+  std::unique_ptr<SkCanvas> canvas =
+      skia::CreatePlatformCanvas(kCanvasWidth, kCanvasHeight, true);
   uint8_t initial_values[kCanvasHeight][kCanvasWidth] = {
       {0x00, 0x01, 0x02, 0x03, 0x04},
       {0x10, 0x11, 0x12, 0x13, 0x14},
@@ -152,9 +152,9 @@ TEST(Blit, WithSharedMemory) {
   base::SharedMemory shared_mem;
   ASSERT_TRUE(shared_mem.CreateAnonymous(kCanvasWidth * kCanvasHeight));
   base::SharedMemoryHandle section = shared_mem.handle();
-  sk_sp<SkCanvas> canvas(skia::CreatePlatformCanvas(
+  std::unique_ptr<SkCanvas> canvas = skia::CreatePlatformCanvas(
       kCanvasWidth, kCanvasHeight, true, section.GetHandle(),
-      skia::RETURN_NULL_ON_FAILURE));
+      skia::RETURN_NULL_ON_FAILURE);
   ASSERT_TRUE(canvas);
   shared_mem.Close();
 
diff --git a/ui/gfx/canvas.cc b/ui/gfx/canvas.cc
index df386f7da584..73a7a669700c 100644
--- a/ui/gfx/canvas.cc
+++ b/ui/gfx/canvas.cc
@@ -28,9 +28,10 @@ namespace gfx {
 Canvas::Canvas(const Size& size, float image_scale, bool is_opaque)
     : image_scale_(image_scale) {
   Size pixel_size = ScaleToCeiledSize(size, image_scale);
-  canvas_ = sk_sp<SkCanvas>(skia::CreatePlatformCanvas(pixel_size.width(),
-                                                       pixel_size.height(),
-                                                       is_opaque));
+  canvas_owner_ = skia::CreatePlatformCanvas(pixel_size.width(),
+                                             pixel_size.height(), is_opaque);
+  canvas_ = canvas_owner_.get();
+
 #if !defined(USE_CAIRO)
   // skia::PlatformCanvas instances are initialized to 0 by Cairo, but
   // uninitialized on other platforms.
@@ -44,10 +45,11 @@ Canvas::Canvas(const Size& size, float image_scale, bool is_opaque)
 
 Canvas::Canvas()
     : image_scale_(1.f),
-      canvas_(sk_sp<SkCanvas>(skia::CreatePlatformCanvas(0, 0, false))) {}
+      canvas_owner_(skia::CreatePlatformCanvas(0, 0, false)),
+      canvas_(canvas_owner_.get()) {}
 
-Canvas::Canvas(sk_sp<SkCanvas> canvas, float image_scale)
-    : image_scale_(image_scale), canvas_(std::move(canvas)) {
+Canvas::Canvas(SkCanvas* canvas, float image_scale)
+    : image_scale_(image_scale), canvas_(canvas) {
   DCHECK(canvas_);
 }
 
@@ -59,9 +61,10 @@ void Canvas::RecreateBackingCanvas(const Size& size,
                                    bool is_opaque) {
   image_scale_ = image_scale;
   Size pixel_size = ScaleToFlooredSize(size, image_scale);
-  canvas_ = sk_sp<SkCanvas>(skia::CreatePlatformCanvas(pixel_size.width(),
-                                                       pixel_size.height(),
-                                                       is_opaque));
+  canvas_owner_ = skia::CreatePlatformCanvas(pixel_size.width(),
+                                             pixel_size.height(), is_opaque);
+  canvas_ = canvas_owner_.get();
+
   SkScalar scale_scalar = SkFloatToScalar(image_scale);
   canvas_->scale(scale_scalar, scale_scalar);
 }
diff --git a/ui/gfx/canvas.h b/ui/gfx/canvas.h
index ec85eb537468..521a1567f4a9 100644
--- a/ui/gfx/canvas.h
+++ b/ui/gfx/canvas.h
@@ -89,7 +89,9 @@ class GFX_EXPORT Canvas {
   // Creates a Canvas backed by an |sk_canvas| with |image_scale_|.
   // |sk_canvas| is assumed to be already scaled based on |image_scale|
   // so no additional scaling is applied.
-  Canvas(sk_sp<SkCanvas> sk_canvas, float image_scale);
+  // Note: the caller must ensure that sk_canvas outlives this object, or until
+  // RecreateBackingCanvas is called.
+  Canvas(SkCanvas* sk_canvas, float image_scale);
 
   virtual ~Canvas();
 
@@ -481,7 +483,7 @@ class GFX_EXPORT Canvas {
                        const Rect& display_rect,
                        int flags);
 
-  SkCanvas* sk_canvas() { return canvas_.get(); }
+  SkCanvas* sk_canvas() { return canvas_; }
   float image_scale() const { return image_scale_; }
 
  private:
@@ -509,7 +511,12 @@ class GFX_EXPORT Canvas {
   // Canvas::Scale() does not affect |image_scale_|.
   float image_scale_;
 
-  sk_sp<SkCanvas> canvas_;
+  // canvas_ is our active canvas object. Sometimes we are also the owner,
+  // in which case canvas_owner_ will be set. Other times we are just
+  // borrowing someone else's canvas, in which case canvas_ will point there
+  // but canvas_owner_ will be null.
+  std::unique_ptr<SkCanvas> canvas_owner_;
+  SkCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(Canvas);
 };
diff --git a/ui/gfx/render_text_unittest.cc b/ui/gfx/render_text_unittest.cc
index 5091fcacd3d8..c51ef30315f6 100644
--- a/ui/gfx/render_text_unittest.cc
+++ b/ui/gfx/render_text_unittest.cc
@@ -3645,7 +3645,7 @@ TEST_P(RenderTextTest, TextDoesntClip) {
 
   sk_sp<SkSurface> surface =
       SkSurface::MakeRasterN32Premul(kCanvasSize.width(), kCanvasSize.height());
-  Canvas canvas(sk_ref_sp(surface->getCanvas()), 1.0f);
+  Canvas canvas(surface->getCanvas(), 1.0f);
   RenderText* render_text = GetRenderText();
   render_text->SetHorizontalAlignment(ALIGN_LEFT);
   render_text->SetColor(SK_ColorBLACK);
@@ -3738,7 +3738,7 @@ TEST_P(RenderTextTest, TextDoesClip) {
 
   sk_sp<SkSurface> surface =
       SkSurface::MakeRasterN32Premul(kCanvasSize.width(), kCanvasSize.height());
-  Canvas canvas(sk_ref_sp(surface->getCanvas()), 1.0f);
+  Canvas canvas(surface->getCanvas(), 1.0f);
   RenderText* render_text = GetRenderText();
   render_text->SetHorizontalAlignment(ALIGN_LEFT);
   render_text->SetColor(SK_ColorBLACK);
diff --git a/ui/surface/transport_dib.h b/ui/surface/transport_dib.h
index a14be68fcbb5..3217b5ff8a66 100644
--- a/ui/surface/transport_dib.h
+++ b/ui/surface/transport_dib.h
@@ -17,6 +17,8 @@
 #include <windows.h>
 #endif
 
+#include <memory>
+
 class SkCanvas;
 
 // -----------------------------------------------------------------------------
@@ -71,7 +73,7 @@ class SURFACE_EXPORT TransportDIB {
   //
   // Will return NULL on allocation failure. This could be because the image
   // is too large to map into the current process' address space.
-  SkCanvas* GetPlatformCanvas(int w, int h, bool opaque);
+  std::unique_ptr<SkCanvas> GetPlatformCanvas(int w, int h, bool opaque);
 
   // Map the DIB into the current process if it is not already. This is used to
   // map a DIB that has already been created. Returns true if the DIB is mapped.
diff --git a/ui/surface/transport_dib_posix.cc b/ui/surface/transport_dib_posix.cc
index da370c96698e..8beba1f7e5cf 100644
--- a/ui/surface/transport_dib_posix.cc
+++ b/ui/surface/transport_dib_posix.cc
@@ -58,7 +58,9 @@ bool TransportDIB::is_valid_handle(Handle dib) {
   return base::SharedMemory::IsHandleValid(dib);
 }
 
-SkCanvas* TransportDIB::GetPlatformCanvas(int w, int h, bool opaque) {
+std::unique_ptr<SkCanvas> TransportDIB::GetPlatformCanvas(int w,
+                                                          int h,
+                                                          bool opaque) {
   if ((!memory() && !Map()) || !VerifyCanvasSize(w, h))
     return NULL;
   return skia::CreatePlatformCanvas(w, h, opaque,
diff --git a/ui/surface/transport_dib_win.cc b/ui/surface/transport_dib_win.cc
index 190065b9ded3..61f5a1b24295 100644
--- a/ui/surface/transport_dib_win.cc
+++ b/ui/surface/transport_dib_win.cc
@@ -58,8 +58,9 @@ bool TransportDIB::is_valid_handle(Handle dib) {
   return dib.IsValid();
 }
 
-SkCanvas* TransportDIB::GetPlatformCanvas(int w, int h,
-                                                      bool opaque) {
+std::unique_ptr<SkCanvas> TransportDIB::GetPlatformCanvas(int w,
+                                                          int h,
+                                                          bool opaque) {
   // This DIB already mapped the file into this process, but PlatformCanvas
   // will map it again.
   DCHECK(!memory()) << "Mapped file twice in the same process.";
@@ -67,7 +68,7 @@ SkCanvas* TransportDIB::GetPlatformCanvas(int w, int h,
   // We can't check the canvas size before mapping, but it's safe because
   // Windows will fail to map the section if the dimensions of the canvas
   // are too large.
-  SkCanvas* canvas = skia::CreatePlatformCanvas(
+  std::unique_ptr<SkCanvas> canvas = skia::CreatePlatformCanvas(
       w, h, opaque, shared_memory_.handle().GetHandle(),
       skia::RETURN_NULL_ON_FAILURE);
 
diff --git a/ui/views/border_unittest.cc b/ui/views/border_unittest.cc
index c9b5b6c033f3..ab428df65e68 100644
--- a/ui/views/border_unittest.cc
+++ b/ui/views/border_unittest.cc
@@ -132,7 +132,7 @@ class BorderTest : public ViewsTestBase {
     view_->SetSize(gfx::Size(100, 50));
     // The canvas should be much bigger than the view.
     sk_canvas_.reset(new MockCanvas(1000, 500));
-    canvas_.reset(new gfx::Canvas(sk_canvas_, 1.0f));
+    canvas_.reset(new gfx::Canvas(sk_canvas_.get(), 1.0f));
   }
 
   void TearDown() override {
@@ -145,7 +145,7 @@ class BorderTest : public ViewsTestBase {
 
  protected:
   std::unique_ptr<views::View> view_;
-  sk_sp<MockCanvas> sk_canvas_;
+  std::unique_ptr<MockCanvas> sk_canvas_;
   std::unique_ptr<gfx::Canvas> canvas_;
 };