diff --git a/include/utils/SkDeferredCanvas.h b/include/utils/SkDeferredCanvas.h
index 60f709c..bef26c0 100644
--- a/include/utils/SkDeferredCanvas.h
+++ b/include/utils/SkDeferredCanvas.h
@@ -54,6 +54,16 @@
     virtual SkDevice* setDevice(SkDevice* device);
 
     /**
+     *  Specify the surface to be used by this canvas. Calling setSurface will
+     *  release the previously set surface or device. Takes a reference on the
+     *  surface.
+     *
+     *  @param surface The surface that the canvas will raw into
+     *  @return The surface argument, for convenience.
+     */
+    SkSurface* setSurface(SkSurface* surface);
+
+    /**
      *  Specify a NotificationClient to be used by this canvas. Calling
      *  setNotificationClient will release the previously set
      *  NotificationClient, if any. SkDeferredCanvas does not take ownership
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index f2aae06..b396a08 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -148,6 +148,7 @@
     SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
     SkDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();}
     SkImage* newImageSnapshot();
+    void setSurface(SkSurface* surface);
     bool isFreshFrame();
     bool hasPendingCommands();
     size_t storageAllocatedForRecording() const;
@@ -261,6 +262,7 @@
                immediateDevice->getDeviceProperties()) {
     fSurface = NULL;
     fImmediateCanvas = SkNEW_ARGS(SkCanvas, (immediateDevice));
+    fPipeController.setPlaybackCanvas(fImmediateCanvas);
     this->init();
 }
 
@@ -272,13 +274,18 @@
                surface->getCanvas()->getDevice()->getDeviceProperties()) {
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
-    fImmediateCanvas = surface->getCanvas();
-    SkSafeRef(fImmediateCanvas);
-    fSurface = surface;
-    SkSafeRef(fSurface);
+    fImmediateCanvas = NULL;
+    fSurface = NULL;
+    this->setSurface(surface);
     this->init();
 }
 
+void DeferredDevice::setSurface(SkSurface* surface) {
+    SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas());
+    SkRefCnt_SafeAssign(fSurface, surface);
+    fPipeController.setPlaybackCanvas(fImmediateCanvas);
+}
+
 void DeferredDevice::init() {
     fRecordingCanvas = NULL;
     fFreshFrame = true;
@@ -287,7 +294,6 @@
     fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
-    fPipeController.setPlaybackCanvas(fImmediateCanvas);
     this->beginRecording();
 }
 
@@ -620,6 +626,19 @@
     return device;
 }
 
+SkSurface* SkDeferredCanvas::setSurface(SkSurface* surface) {
+    DeferredDevice* deferredDevice = this->getDeferredDevice();
+    if (NULL != deferredDevice) {
+        // By swapping the surface into the existing device, we preserve
+        // all pending commands, which can help to seamlessly recover from
+        // a lost accelerated graphics context.
+        deferredDevice->setSurface(surface);
+    } else {
+        this->INHERITED::setDevice(SkNEW_ARGS(DeferredDevice, (surface)))->unref();
+    }
+    return surface;
+}
+
 SkDeferredCanvas::NotificationClient* SkDeferredCanvas::setNotificationClient(
     NotificationClient* notificationClient) {
 
diff --git a/tests/DeferredCanvasTest.cpp b/tests/DeferredCanvasTest.cpp
index 3def190..762c916 100644
--- a/tests/DeferredCanvasTest.cpp
+++ b/tests/DeferredCanvasTest.cpp
@@ -548,6 +548,51 @@
     REPORTER_ASSERT(reporter, pixels4 == pixels5);
 }
 
+static void TestDeferredCanvasSetSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
+    SkImage::Info imageSpec = {
+        10,  // width
+        10,  // height
+        SkImage::kPMColor_ColorType,
+        SkImage::kPremul_AlphaType
+    };
+    SkSurface* surface;
+    SkSurface* alternateSurface;
+    bool useGpu = NULL != factory;
+#if SK_SUPPORT_GPU
+    if (useGpu) {
+        GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+        surface = SkSurface::NewRenderTarget(context, imageSpec);
+        alternateSurface = SkSurface::NewRenderTarget(context, imageSpec);
+    } else {
+        surface = SkSurface::NewRaster(imageSpec);
+        alternateSurface = SkSurface::NewRaster(imageSpec);
+    }
+#else
+    SkASSERT(!useGpu);
+    surface = SkSurface::NewRaster(imageSpec);
+    alternateSurface = SkSurface::NewRaster(imageSpec);
+#endif
+    SkASSERT(NULL != surface);
+    SkASSERT(NULL != alternateSurface);
+    SkAutoTUnref<SkSurface> aur1(surface);
+    SkAutoTUnref<SkSurface> aur2(alternateSurface);
+    PixelPtr pixels1 = getSurfacePixelPtr(surface, useGpu);
+    PixelPtr pixels2 = getSurfacePixelPtr(alternateSurface, useGpu);
+    SkDeferredCanvas canvas(surface);
+    SkAutoTUnref<SkImage> image1(canvas.newImageSnapshot());
+    canvas.setSurface(alternateSurface);
+    SkAutoTUnref<SkImage> image2(canvas.newImageSnapshot());
+    REPORTER_ASSERT(reporter, image1->uniqueID() != image2->uniqueID());
+    // Verify that none of the above operations triggered a surface copy on write.
+    REPORTER_ASSERT(reporter, getSurfacePixelPtr(surface, useGpu) == pixels1);
+    REPORTER_ASSERT(reporter, getSurfacePixelPtr(alternateSurface, useGpu) == pixels2);
+    // Verify that a flushed draw command will trigger a copy on write on alternateSurface.
+    canvas.clear(SK_ColorWHITE);
+    canvas.flush();
+    REPORTER_ASSERT(reporter, getSurfacePixelPtr(surface, useGpu) == pixels1);
+    REPORTER_ASSERT(reporter, getSurfacePixelPtr(alternateSurface, useGpu) != pixels2);
+}
+
 static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
     SkBitmap store;
     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
@@ -581,8 +626,10 @@
     TestDeferredCanvasBitmapSizeThreshold(reporter);
     TestDeferredCanvasCreateCompatibleDevice(reporter);
     TestDeferredCanvasSurface(reporter, NULL);
+    TestDeferredCanvasSetSurface(reporter, NULL);
     if (NULL != factory) {
         TestDeferredCanvasSurface(reporter, factory);
+        TestDeferredCanvasSetSurface(reporter, factory);
     }
 }