Implement SkBaseDevice snapshot support

tests/DeferredCanvasTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "../src/image/SkImagePriv.h"
 #include "../src/image/SkSurface_Base.h"
 #include "SkBitmap.h"
@@ skipping 30 matching lines @@
     SkPMColor pixel = 0;
     SkBitmap bitmap;
     bitmap.installPixels(SkImageInfo::MakeN32Premul(1, 1), &pixel, 4);
     SkCanvas canvas(bitmap);
 
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     surface->draw(&canvas, -SkIntToScalar(x), -SkIntToScalar(y), &paint);
     return pixel;
 }
+class MockSurface;
+class MockDevice : public SkBitmapDevice {
+public:
+    MockDevice(MockSurface* surface, const SkBitmap& bm) : SkBitmapDevice(bm), fSurface(surface) {
+    }
+    void discard() SK_OVERRIDE;
+  private:
+    MockSurface* fSurface;
+    typedef SkBitmapDevice INHERITED;
+};
 
 class MockSurface : public SkSurface_Base {
 public:
     MockSurface(int width, int height) : SkSurface_Base(width, height, NULL) {
         clearCounts();
-        fBitmap.allocN32Pixels(width, height);
+
+        SkBitmap bitmap;
+        bitmap.allocN32Pixels(width, height);
+        fDevice.reset(SkNEW_ARGS(MockDevice, (this, bitmap)));
+        fDeviceGenerationID = fDevice->accessBitmap(false).getGenerationID();
+        fGenerationID = this->newGenerationID();
     }
 
     SkCanvas* onNewCanvas() SK_OVERRIDE {
-        return SkNEW_ARGS(SkCanvas, (fBitmap));
+        return SkNEW_ARGS(SkCanvas, (fDevice));
     }
 
     SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
         return NULL;
     }
 
     SkImage* onNewImageSnapshot(Budgeted) SK_OVERRIDE {
-        return SkNewImageFromBitmap(fBitmap, &this->props());
+        return fDevice->newImageSnapshot();
     }
 
-    void onCopyOnWrite(ContentChangeMode mode) SK_OVERRIDE {
-        if (mode == SkSurface::kDiscard_ContentChangeMode) {
-            fCOWDiscardCount++;
-        } else {
-            fCOWRetainCount++;
+    uint32_t generationID() SK_OVERRIDE {
+        uint32_t deviceGenerationID = fDevice->accessBitmap(false).getGenerationID();
+        if (fDeviceGenerationID != deviceGenerationID) {
+            fDeviceGenerationID = deviceGenerationID;
+            fGenerationID = this->newGenerationID();
         }
+        return fGenerationID;
     }
 
-    void onDiscard() SK_OVERRIDE {
+    void incDiscardCount() {
         fDiscardCount++;
     }
 
     void clearCounts() {
-        fCOWDiscardCount = 0;
-        fCOWRetainCount = 0;
         fDiscardCount = 0;
     }
 
-    int fCOWDiscardCount;
-    int fCOWRetainCount;
+    SkAutoTUnref<MockDevice> fDevice;
+    uint32_t fDeviceGenerationID;
+    uint32_t fGenerationID;
+
     int fDiscardCount;
-    SkBitmap fBitmap;
 };
 
+void MockDevice::discard() {
+    if (fSurface) {
+        fSurface->incDiscardCount();
+    }
+    this->INHERITED::discard();
+}
+
 static void TestDeferredCanvasWritePixelsToSurface(skiatest::Reporter* reporter) {
     SkAutoTUnref<MockSurface> surface(SkNEW_ARGS(MockSurface, (10, 10)));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     SkBitmap srcBitmap;
     srcBitmap.allocPixels(SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType));
     srcBitmap.eraseColor(SK_ColorGREEN);
     // Tests below depend on this bitmap being recognized as opaque
 
-    // Preliminary sanity check: no copy on write if no active snapshot
-    // Discard notification happens on SkSurface::onDiscard, since no
-    // active snapshot.
+
+    // Case 0: SkBaseDevice::discard is called even when clear is the first command.
+    // The call is made only after flush.
+    uint32_t surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->clear(SK_ColorWHITE);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
-    // Case 1: Discard notification happens upon flushing
+    // Case 1: SkBaseDevice::discard is called upon flushing
     // with an Image attached.
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image1(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->clear(SK_ColorWHITE);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 1 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
     // Case 2: Opaque writePixels
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image2(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
     // Case 3: writePixels that partially covers the canvas
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image3(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
     // Case 4: unpremultiplied opaque writePixels that entirely
     // covers the canvas
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image4(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->writePixels(srcBitmap, 0, 0);
-    REPORTER_ASSERT(reporter, 1 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
     // Case 5: unpremultiplied opaque writePixels that partially
-    // covers the canvas
+    // covers the canvas. The surface changes immediately.
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image5(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->writePixels(srcBitmap, 5, 0);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 1 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
     // Case 6: unpremultiplied opaque writePixels that entirely
-    // covers the canvas, preceded by clear
+    // covers the canvas, preceded by clear.
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image6(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->clear(SK_ColorWHITE);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->writePixels(srcBitmap, 0, 0);
-    REPORTER_ASSERT(reporter, 1 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
     // Case 7: unpremultiplied opaque writePixels that partially
     // covers the canvas, preceeded by a clear
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image7(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->clear(SK_ColorWHITE);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->writePixels(srcBitmap, 5, 0);
-    REPORTER_ASSERT(reporter, 1 == surface->fCOWDiscardCount); // because of the clear
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount); // because of the clear
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
     // Case 8: unpremultiplied opaque writePixels that partially
     // covers the canvas, preceeded by a drawREct that partially
     // covers the canvas
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkAutoTUnref<SkImage> image8(canvas->newImageSnapshot());
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     SkPaint paint;
     canvas->drawRect(SkRect::MakeLTRB(0, 0, 5, 5), paint);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->writePixels(srcBitmap, 5, 0);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 1 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID != surface->generationID());
 
+    surfaceID = surface->generationID();
     surface->clearCounts();
     canvas->flush();
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWDiscardCount);
-    REPORTER_ASSERT(reporter, 0 == surface->fCOWRetainCount);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
+    REPORTER_ASSERT(reporter, surfaceID == surface->generationID());
 }
 
 static void TestDeferredCanvasFlush(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     canvas->clear(0x00000000);
 
     // verify that clear was deferred
     REPORTER_ASSERT(reporter, 0xFFFFFFFF == read_pixel(surface, 0, 0));
@@ skipping 151 matching lines @@
     {
         SkPaint paint;
         paint.setStyle(SkPaint::kFill_Style);
         paint.setAlpha(100);
         paint.setXfermodeMode(SkXfermode::kSrc_Mode);
         canvas->drawRect(fullRect, paint);
         REPORTER_ASSERT(reporter, canvas->isFreshFrame());
     }
 }
 
-class MockDevice : public SkBitmapDevice {
-public:
-    MockDevice(const SkBitmap& bm) : SkBitmapDevice(bm) {
-        fDrawBitmapCallCount = 0;
-    }
-    virtual void drawBitmap(const SkDraw&, const SkBitmap&,
-                            const SkMatrix&, const SkPaint&) SK_OVERRIDE {
-        fDrawBitmapCallCount++;
-    }
-
-    int fDrawBitmapCallCount;
-};
-
 class NotificationCounter : public SkDeferredCanvas::NotificationClient {
 public:
     NotificationCounter() {
         fPrepareForDrawCount = fStorageAllocatedChangedCount =
             fFlushedDrawCommandsCount = fSkippedPendingDrawCommandsCount = 0;
     }
 
     void prepareForDraw() SK_OVERRIDE {
         fPrepareForDrawCount++;
     }
@@ skipping 216 matching lines @@
     // 1 over : should still store the image
     {
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
         canvas->setBitmapSizeThreshold(40001);
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
         REPORTER_ASSERT(reporter, newBytesAllocated > 0);
     }
 }
 
-
-typedef const void* PixelPtr;
-// Returns an opaque pointer which, either points to a GrTexture or RAM pixel
-// buffer. Used to test pointer equality do determine whether a surface points
-// to the same pixel data storage as before.
-static PixelPtr get_surface_ptr(SkSurface* surface, bool useGpu) {
-#if SK_SUPPORT_GPU
-    if (useGpu) {
-        return surface->getCanvas()->internal_private_accessTopLayerRenderTarget()->asTexture();
-    } else
-#endif
-    {
-        return surface->peekPixels(NULL, NULL);
-    }
-}
-
 static void TestDeferredCanvasSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkImageInfo imageSpec = SkImageInfo::MakeN32Premul(10, 10);
     bool useGpu = SkToBool(factory);
     int cnt;
 #if SK_SUPPORT_GPU
     if (useGpu) {
         cnt = GrContextFactory::kGLContextTypeCnt;
     } else {
         cnt = 1;
     }
@@ skipping 20 matching lines @@
 #endif
         {
            surface = SkSurface::NewRaster(imageSpec);
         }
         SkASSERT(surface);
         SkAutoTUnref<SkSurface> aur(surface);
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface));
 
         SkImage* image1 = canvas->newImageSnapshot();
         SkAutoTUnref<SkImage> aur_i1(image1);
-        PixelPtr pixels1 = get_surface_ptr(surface, useGpu);
-        // The following clear would normally trigger a copy on write, but
+        // The following clear would normally trigger a surface modification, but
         // it won't because rendering is deferred.
         canvas->clear(SK_ColorBLACK);
+        uint32_t genid1 = surface->generationID();
         // Obtaining a snapshot directly from the surface (as opposed to the
         // SkDeferredCanvas) will not trigger a flush of deferred draw operations
         // and will therefore return the same image as the previous snapshot.
         SkImage* image2 = surface->newImageSnapshot();
         SkAutoTUnref<SkImage> aur_i2(image2);
         // Images identical because of deferral
         REPORTER_ASSERT(reporter, image1->uniqueID() == image2->uniqueID());
+        uint32_t genid2 = surface->generationID();
         // Now we obtain a snpshot via the deferred canvas, which triggers a flush.
         // Because there is a pending clear, this will generate a different image.
         SkImage* image3 = canvas->newImageSnapshot();
         SkAutoTUnref<SkImage> aur_i3(image3);
         REPORTER_ASSERT(reporter, image1->uniqueID() != image3->uniqueID());
-        // Verify that backing store is now a different buffer because of copy on
-        // write
-        PixelPtr pixels2 = get_surface_ptr(surface, useGpu);
-        REPORTER_ASSERT(reporter, pixels1 != pixels2);
-        // Verify copy-on write with a draw operation that gets deferred by
+        // Verify that backing store is now a different buffer because of changed
+        // surface generation id.
+        uint32_t genid3 = surface->generationID();
+        REPORTER_ASSERT(reporter, genid1 == genid2);
+        REPORTER_ASSERT(reporter, genid1 != genid3);
+        // Verify surface modification with a draw operation that gets deferred by
         // the in order draw buffer.
         SkPaint paint;
         canvas->drawPaint(paint);
         SkImage* image4 = canvas->newImageSnapshot();  // implicit flush
         SkAutoTUnref<SkImage> aur_i4(image4);
-        REPORTER_ASSERT(reporter, image4->uniqueID() != image3->uniqueID());
-        PixelPtr pixels3 = get_surface_ptr(surface, useGpu);
-        REPORTER_ASSERT(reporter, pixels2 != pixels3);
-        // Verify that a direct canvas flush with a pending draw does not trigger
-        // a copy on write when the surface is not sharing its buffer with an
-        // SkImage.
-        canvas->clear(SK_ColorWHITE);
-        canvas->flush();
-        PixelPtr pixels4 = get_surface_ptr(surface, useGpu);
-        canvas->drawPaint(paint);
-        canvas->flush();
-        PixelPtr pixels5 = get_surface_ptr(surface, useGpu);
-        REPORTER_ASSERT(reporter, pixels4 == pixels5);
+        REPORTER_ASSERT(reporter, image3->uniqueID() != image4->uniqueID());
+        uint32_t genid4 = surface->generationID();
+        REPORTER_ASSERT(reporter, genid3 != genid4);
     }
 }
 
 static void TestDeferredCanvasSetSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkImageInfo imageSpec = SkImageInfo::MakeN32Premul(10, 10);
     SkSurface* surface;
     SkSurface* alternateSurface;
     bool useGpu = SkToBool(factory);
     int cnt;
 #if SK_SUPPORT_GPU
@@ skipping 25 matching lines @@
         } else
 #endif
         {
             surface = SkSurface::NewRaster(imageSpec);
             alternateSurface = SkSurface::NewRaster(imageSpec);
         }
         SkASSERT(surface);
         SkASSERT(alternateSurface);
         SkAutoTUnref<SkSurface> aur1(surface);
         SkAutoTUnref<SkSurface> aur2(alternateSurface);
-        PixelPtr pixels1 = get_surface_ptr(surface, useGpu);
-        PixelPtr pixels2 = get_surface_ptr(alternateSurface, useGpu);
+        uint32_t genid1 = surface->generationID();
+        uint32_t genid2 = alternateSurface->generationID();
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(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, get_surface_ptr(surface, useGpu) == pixels1);
-        REPORTER_ASSERT(reporter, get_surface_ptr(alternateSurface, useGpu) == pixels2);
-        // Verify that a flushed draw command will trigger a copy on write on alternateSurface.
+        // Verify that none of the above operations triggered a surface modification.
+        REPORTER_ASSERT(reporter, surface->generationID() == genid1);
+        REPORTER_ASSERT(reporter, alternateSurface->generationID() == genid2);
+        // Verify that a flushed draw command will trigger a modification on alternateSurface.
         canvas->clear(SK_ColorWHITE);
         canvas->flush();
-        REPORTER_ASSERT(reporter, get_surface_ptr(surface, useGpu) == pixels1);
-        REPORTER_ASSERT(reporter, get_surface_ptr(alternateSurface, useGpu) != pixels2);
+        REPORTER_ASSERT(reporter, surface->generationID() == genid1);
+        REPORTER_ASSERT(reporter, alternateSurface->generationID() != genid2);
     }
 }
 
 static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
@@ skipping 79 matching lines @@
     TestDeferredCanvasSurface(reporter, NULL);
     TestDeferredCanvasSetSurface(reporter, NULL);
 }
 
 DEF_GPUTEST(DeferredCanvas_GPU, reporter, factory) {
     if (factory != NULL) {
         TestDeferredCanvasSurface(reporter, factory);
         TestDeferredCanvasSetSurface(reporter, factory);
     }
 }