Implement SkBaseDevice snapshot support

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
@@ skipping 431 matching lines @@
                                  GrContext* context) {
     SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
     SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
     GrTexture* texture = image->getTexture();
     if (surfaceType == kGpu_SurfaceType || surfaceType == kGpuScratch_SurfaceType) {
         REPORTER_ASSERT(reporter, texture);
         REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
     } else {
         REPORTER_ASSERT(reporter, NULL == texture);
     }
-    surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
+    surface->getCanvas()->discard();
     REPORTER_ASSERT(reporter, image->getTexture() == texture);
 }
 
 #include "GrGpuResourcePriv.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
 SkSurface::Budgeted is_budgeted(SkSurface* surf) {
-    return ((SkSurface_Gpu*)surf)->getDevice()->accessRenderTarget()->resourcePriv().isBudgeted() ?
-        SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
+    return static_cast<SkSurface_Gpu*>(surf)->isBackendBudgeted() ? SkSurface::kYes_Budgeted
+                                                                  : SkSurface::kNo_Budgeted;
 }
 
 SkSurface::Budgeted is_budgeted(SkImage* image) {
     return ((SkImage_Gpu*)image)->getTexture()->resourcePriv().isBudgeted() ?
         SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
 }
 
 static void test_surface_budget(skiatest::Reporter* reporter, GrContext* context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
     for (int i = 0; i < 2; ++i) {
@@ skipping 19 matching lines @@
             // decision.
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
             REPORTER_ASSERT(reporter, ibudgeted == is_budgeted(image));
         }
     }
 }
 
 #endif
 
 static void TestSurfaceNoCanvas(skiatest::Reporter* reporter,
-                                          SurfaceType surfaceType,
-                                          GrContext* context,
-                                          SkSurface::ContentChangeMode mode) {
+                                SurfaceType surfaceType,
+                                GrContext* context) {
     // Verifies the robustness of SkSurface for handling use cases where calls
     // are made before a canvas is created.
     {
         // Test passes by not asserting
         SkSurface* surface = createSurface(surfaceType, context);
         SkAutoTUnref<SkSurface> aur_surface(surface);
-        surface->notifyContentWillChange(mode);
         SkDEBUGCODE(surface->validate();)
     }
     {
         SkSurface* surface = createSurface(surfaceType, context);
         SkAutoTUnref<SkSurface> aur_surface(surface);
         SkImage* image1 = surface->newImageSnapshot();
         SkAutoTUnref<SkImage> aur_image1(image1);
         SkDEBUGCODE(image1->validate();)
         SkDEBUGCODE(surface->validate();)
-        surface->notifyContentWillChange(mode);
-        SkDEBUGCODE(image1->validate();)
-        SkDEBUGCODE(surface->validate();)
         SkImage* image2 = surface->newImageSnapshot();
         SkAutoTUnref<SkImage> aur_image2(image2);
         SkDEBUGCODE(image2->validate();)
         SkDEBUGCODE(surface->validate();)
-        REPORTER_ASSERT(reporter, image1 != image2);
+        REPORTER_ASSERT(reporter, image1 == image2);
     }
-
 }
 
 DEF_GPUTEST(Surface, reporter, factory) {
     test_image(reporter);
 
     TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, NULL);
     TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL);
-    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode);
-    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode);
+    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL);
 
     test_empty_image(reporter);
     test_empty_surface(reporter, NULL);
 
     test_imagepeek(reporter, factory);
     test_canvaspeek(reporter, factory);
 
 #if SK_SUPPORT_GPU
     TestGetTexture(reporter, kRaster_SurfaceType, NULL);
     if (factory) {
         for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
             GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
             if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
                 continue;
             }
             GrContext* context = factory->get(glCtxType);
             if (context) {
                 Test_crbug263329(reporter, kGpu_SurfaceType, context);
                 Test_crbug263329(reporter, kGpuScratch_SurfaceType, context);
                 TestSurfaceCopyOnWrite(reporter, kGpu_SurfaceType, context);
                 TestSurfaceCopyOnWrite(reporter, kGpuScratch_SurfaceType, context);
                 TestSurfaceWritableAfterSnapshotRelease(reporter, kGpu_SurfaceType, context);
                 TestSurfaceWritableAfterSnapshotRelease(reporter, kGpuScratch_SurfaceType, context);
-                TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode);
-                TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode);
-                TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
-                TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
+                TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context);
+                TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context);
                 TestGetTexture(reporter, kGpu_SurfaceType, context);
                 TestGetTexture(reporter, kGpuScratch_SurfaceType, context);
                 test_empty_surface(reporter, context);
                 test_surface_budget(reporter, context);
             }
         }
     }
 #endif
 }