Adding a new SkSurface factory for generating surfaces from the scratch texture pool.

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"
 #include "SkRRect.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #else
 class GrContextFactory;
 class GrContext;
 #endif
 
 enum SurfaceType {
     kRaster_SurfaceType,
     kRasterDirect_SurfaceType,
     kGpu_SurfaceType,
+    kGpuScratch_SurfaceType,
     kPicture_SurfaceType
 };
 
 static const int gSurfaceSize = 10;
 static SkPMColor gSurfaceStorage[gSurfaceSize * gSurfaceSize];
 
 static SkSurface* createSurface(SurfaceType surfaceType, GrContext* context,
                                 SkImageInfo* requestedInfo = NULL) {
     static const SkImageInfo info = SkImageInfo::MakeN32Premul(gSurfaceSize,
                                                                gSurfaceSize);
 
     if (requestedInfo) {
         *requestedInfo = info;
     }
 
     switch (surfaceType) {
         case kRaster_SurfaceType:
             return SkSurface::NewRaster(info);
         case kRasterDirect_SurfaceType:
             return SkSurface::NewRasterDirect(info, gSurfaceStorage,
                                               info.minRowBytes());
         case kGpu_SurfaceType:
 #if SK_SUPPORT_GPU
             return context ? SkSurface::NewRenderTarget(context, info) : NULL;
 #endif
             break;
+        case kGpuScratch_SurfaceType:
+#if SK_SUPPORT_GPU
+            return context ? SkSurface::NewScratchRenderTarget(context, info) : NULL;
+#endif
+            break;
         case kPicture_SurfaceType:
             return SkSurface::NewPicture(info.fWidth, info.fHeight);
     }
     return NULL;
 }
 
 enum ImageType {
     kRasterCopy_ImageType,
     kRasterData_ImageType,
     kGpu_ImageType,
@@ skipping 53 matching lines @@
     return NULL;
 }
 
 static void test_imagepeek(skiatest::Reporter* reporter) {
     static const struct {
         ImageType   fType;
         bool        fPeekShouldSucceed;
     } gRec[] = {
         { kRasterCopy_ImageType,    true    },
         { kRasterData_ImageType,    true    },
-        { kGpu_ImageType,           false    },
+        { kGpu_ImageType,           false   },
         { kPicture_ImageType,       false   },
         { kCodec_ImageType,         false   },
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         SkImageInfo info;
         size_t rowBytes;
@@ skipping 20 matching lines @@
 static void test_canvaspeek(skiatest::Reporter* reporter,
                             GrContextFactory* factory) {
     static const struct {
         SurfaceType fType;
         bool        fPeekShouldSucceed;
     } gRec[] = {
         { kRaster_SurfaceType,          true    },
         { kRasterDirect_SurfaceType,    true    },
 #if SK_SUPPORT_GPU
         { kGpu_SurfaceType,             false   },
+        { kGpuScratch_SurfaceType,      false   },
 #endif
         { kPicture_SurfaceType,         false   },
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
     GrContext* context = NULL;
 #if SK_SUPPORT_GPU
     context = factory->get(GrContextFactory::kNative_GLContextType);
@@ skipping 121 matching lines @@
     // The test verifies that the surface remains writable (usable) after
     // acquiring and releasing a snapshot without triggering a copy on write.
     SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(1);
     surface->newImageSnapshot()->unref();  // Create and destroy SkImage
     canvas->clear(2);  // Must not assert internally
 }
 
 #if SK_SUPPORT_GPU
+static void TestSurfaceInCache(skiatest::Reporter* reporter,
+                               SurfaceType surfaceType,
+                               GrContext* context) {
+    context->freeGpuResources();
+    REPORTER_ASSERT(reporter, 0 == context->getGpuTextureCacheResourceCount());
+    SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
+    // Note: the stencil buffer is always cached, so kGpu_SurfaceType uses
+    // one cached resource, and kGpuScratch_SurfaceType uses two.
+    int expectedCachedResources = surfaceType == kGpuScratch_SurfaceType ? 2 : 1;
+    REPORTER_ASSERT(reporter, expectedCachedResources == context->getGpuTextureCacheResourceCount());
+
+    // Verify that all the cached resources are locked in cache.
+    context->freeGpuResources(); 
+    REPORTER_ASSERT(reporter, expectedCachedResources == context->getGpuTextureCacheResourceCount());
+
+    // Verify that all the cached resources are unlocked upon surface release
+    surface.reset(0);
+    context->freeGpuResources();
+    REPORTER_ASSERT(reporter, 0 == context->getGpuTextureCacheResourceCount()); 
+}
+
 static void Test_crbug263329(skiatest::Reporter* reporter,
+                             SurfaceType surfaceType,
                              GrContext* context) {
     // This is a regression test for crbug.com/263329
     // Bug was caused by onCopyOnWrite releasing the old surface texture
     // back to the scratch texture pool even though the texture is used
     // by and active SkImage_Gpu.
-    SkAutoTUnref<SkSurface> surface1(createSurface(kGpu_SurfaceType, context));
-    SkAutoTUnref<SkSurface> surface2(createSurface(kGpu_SurfaceType, context));
+    SkAutoTUnref<SkSurface> surface1(createSurface(surfaceType, context));
+    SkAutoTUnref<SkSurface> surface2(createSurface(surfaceType, context));
     SkCanvas* canvas1 = surface1->getCanvas();
     SkCanvas* canvas2 = surface2->getCanvas();
     canvas1->clear(1);
     SkAutoTUnref<SkImage> image1(surface1->newImageSnapshot());
     // Trigger copy on write, new backing is a scratch texture
     canvas1->clear(2);
     SkAutoTUnref<SkImage> image2(surface1->newImageSnapshot());
     // Trigger copy on write, old backing should not be returned to scratch
     // pool because it is held by image2
     canvas1->clear(3);
@@ skipping 12 matching lines @@
     REPORTER_ASSERT(reporter, image3->getTexture() != image1->getTexture());
     REPORTER_ASSERT(reporter, image2->getTexture() != image1->getTexture());
 }
 
 static void TestGetTexture(skiatest::Reporter* reporter,
                                  SurfaceType surfaceType,
                                  GrContext* context) {
     SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
     SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
     GrTexture* texture = image->getTexture();
-    if (surfaceType == kGpu_SurfaceType) {
+    if (surfaceType == kGpu_SurfaceType || surfaceType == kGpuScratch_SurfaceType) {
         REPORTER_ASSERT(reporter, NULL != texture);
         REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
     } else {
         REPORTER_ASSERT(reporter, NULL == texture);
     }
     surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
     REPORTER_ASSERT(reporter, image->getTexture() == texture);
 }
 #endif
 
@@ skipping 41 matching lines @@
 
     test_imagepeek(reporter);
     test_canvaspeek(reporter, factory);
 
 #if SK_SUPPORT_GPU
     TestGetTexture(reporter, kRaster_SurfaceType, NULL);
     TestGetTexture(reporter, kPicture_SurfaceType, NULL);
     if (NULL != factory) {
         GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
         if (NULL != context) {
-            Test_crbug263329(reporter, context);
+            TestSurfaceInCache(reporter, kGpu_SurfaceType, context);
+            TestSurfaceInCache(reporter, kGpuScratch_SurfaceType, 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);
             TestGetTexture(reporter, kGpu_SurfaceType, context);
+            TestGetTexture(reporter, kGpuScratch_SurfaceType, context);
         }
     }
 #endif
 }