add callbacks to Images that wrap client-provided content

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 "SkDevice.h"
@@ skipping 47 matching lines @@
             return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, NULL);
         case kGpuScratch_SurfaceType:
             return SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info, 0, NULL);
     }
     return NULL;
 }
 
 enum ImageType {
     kRasterCopy_ImageType,
     kRasterData_ImageType,
+    kRasterProc_ImageType,
     kGpu_ImageType,
     kCodec_ImageType,
 };
 
 #include "SkImageGenerator.h"
 
 class EmptyGenerator : public SkImageGenerator {
 public:
     EmptyGenerator() : SkImageGenerator(SkImageInfo::MakeN32Premul(0, 0)) {}
 };
 
 static void test_empty_image(skiatest::Reporter* reporter) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     
     REPORTER_ASSERT(reporter, NULL == SkImage::NewRasterCopy(info, NULL, 0));
     REPORTER_ASSERT(reporter, NULL == SkImage::NewRasterData(info, NULL, 0));
+    REPORTER_ASSERT(reporter, NULL == SkImage::NewFromRaster(info, NULL, 0, NULL, NULL));
     REPORTER_ASSERT(reporter, NULL == SkImage::NewFromGenerator(SkNEW(EmptyGenerator)));
 }
 
 static void test_empty_surface(skiatest::Reporter* reporter, GrContext* ctx) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     
     REPORTER_ASSERT(reporter, NULL == SkSurface::NewRaster(info));
     REPORTER_ASSERT(reporter, NULL == SkSurface::NewRasterDirect(info, NULL, 0));
     if (ctx) {
         REPORTER_ASSERT(reporter, NULL ==
@@ skipping 103 matching lines @@
     SkData* data = SkData::NewUninitialized(size);
 
     REPORTER_ASSERT(reporter, data->unique());
     SkImage* image = SkImage::NewRasterData(info, data, rowBytes);
     REPORTER_ASSERT(reporter, !data->unique());
     image->unref();
     REPORTER_ASSERT(reporter, data->unique());
     data->unref();
 }
 
-static SkImage* createImage(ImageType imageType, GrContext* context, SkColor color) {
+// Want to ensure that our Release is called when the owning image is destroyed
+struct ReleaseDataContext {
+    skiatest::Reporter* fReporter;
+    SkData*             fData;
+
+    static void Release(const void* pixels, void* context) {
+        ReleaseDataContext* state = (ReleaseDataContext*)context;
+        REPORTER_ASSERT(state->fReporter, state->fData);
+        state->fData->unref();
+        state->fData = NULL;
+    }
+};
+
+static SkImage* createImage(ImageType imageType, GrContext* context, SkColor color,
+                            ReleaseDataContext* releaseContext) {
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
     const SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
     const size_t rowBytes = info.minRowBytes();
     const size_t size = rowBytes * info.height();
 
     SkAutoTUnref<SkData> data(SkData::NewUninitialized(size));
     void* addr = data->writable_data();
     sk_memset32((SkPMColor*)addr, pmcolor, SkToInt(size >> 2));
 
     switch (imageType) {
         case kRasterCopy_ImageType:
             return SkImage::NewRasterCopy(info, addr, rowBytes);
         case kRasterData_ImageType:
             return SkImage::NewRasterData(info, data, rowBytes);
+        case kRasterProc_ImageType:
+            SkASSERT(releaseContext);
+            releaseContext->fData = SkRef(data.get());
+            return SkImage::NewFromRaster(info, addr, rowBytes,
+                                          ReleaseDataContext::Release, releaseContext);
         case kGpu_ImageType: {
             SkAutoTUnref<SkSurface> surf(
                 SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0));
             surf->getCanvas()->clear(color);
             return surf->newImageSnapshot();
         }
         case kCodec_ImageType: {
             SkBitmap bitmap;
             bitmap.installPixels(info, addr, rowBytes);
             SkAutoTUnref<SkData> src(
@@ skipping 63 matching lines @@
 }
 
 static void test_imagepeek(skiatest::Reporter* reporter, GrContextFactory* factory) {
     static const struct {
         ImageType   fType;
         bool        fPeekShouldSucceed;
         const char* fName;
     } gRec[] = {
         { kRasterCopy_ImageType,    true,       "RasterCopy"    },
         { kRasterData_ImageType,    true,       "RasterData"    },
+        { kRasterProc_ImageType,    true,       "RasterProc"    },
         { kGpu_ImageType,           false,      "Gpu"           },
         { kCodec_ImageType,         false,      "Codec"         },
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
     GrContext* ctx = NULL;
 #if SK_SUPPORT_GPU
     ctx = factory->get(GrContextFactory::kNative_GLContextType);
     if (NULL == ctx) {
         return;
     }
 #endif
 
+    ReleaseDataContext releaseCtx;
+    releaseCtx.fReporter = reporter;
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         SkImageInfo info;
         size_t rowBytes;
 
-        SkAutoTUnref<SkImage> image(createImage(gRec[i].fType, ctx, color));
+        releaseCtx.fData = NULL;
+        SkAutoTUnref<SkImage> image(createImage(gRec[i].fType, ctx, color, &releaseCtx));
         if (!image.get()) {
             SkDebugf("failed to createImage[%d] %s\n", i, gRec[i].fName);
             continue;   // gpu may not be enabled
         }
+        if (kRasterProc_ImageType == gRec[i].fType) {
+            REPORTER_ASSERT(reporter, NULL != releaseCtx.fData);  // we are tracking the data
+        } else {
+            REPORTER_ASSERT(reporter, NULL == releaseCtx.fData);  // we ignored the context
+        }
+
         const void* addr = image->peekPixels(&info, &rowBytes);
         bool success = SkToBool(addr);
         REPORTER_ASSERT(reporter, gRec[i].fPeekShouldSucceed == success);
         if (success) {
             REPORTER_ASSERT(reporter, 10 == info.width());
             REPORTER_ASSERT(reporter, 10 == info.height());
             REPORTER_ASSERT(reporter, kN32_SkColorType == info.colorType());
             REPORTER_ASSERT(reporter, kPremul_SkAlphaType == info.alphaType() ||
                             kOpaque_SkAlphaType == info.alphaType());
             REPORTER_ASSERT(reporter, info.minRowBytes() <= rowBytes);
             REPORTER_ASSERT(reporter, pmcolor == *(const SkPMColor*)addr);
         }
 
         test_image_readpixels(reporter, image, pmcolor);
     }
+    REPORTER_ASSERT(reporter, NULL == releaseCtx.fData);  // we released the data
 }
 
 static void test_canvaspeek(skiatest::Reporter* reporter,
                             GrContextFactory* factory) {
     static const struct {
         SurfaceType fType;
         bool        fPeekShouldSucceed;
     } gRec[] = {
         { kRaster_SurfaceType,          true    },
         { kRasterDirect_SurfaceType,    true    },
@@ skipping 378 matching lines @@
                 test_empty_surface(reporter, context);
                 test_surface_budget(reporter, context);
                 test_wrapped_texture_surface(reporter, context);
             }
         }
     }
 #endif
 }
 
 #if SK_SUPPORT_GPU
-static SkImage* make_desc_image(GrContext* ctx, int w, int h, GrBackendObject texID, bool doCopy) {
+
+struct ReleaseTextureContext {
+    ReleaseTextureContext(skiatest::Reporter* reporter) {
+        fReporter = reporter;
+        fIsReleased = false;
+    }
+
+    skiatest::Reporter* fReporter;
+    bool                fIsReleased;
+
+    void doRelease() {
+        REPORTER_ASSERT(fReporter, false == fIsReleased);
+        fIsReleased = true;
+    }
+
+    static void ReleaseProc(void* context) {
+        ((ReleaseTextureContext*)context)->doRelease();
+    }
+};
+
+static SkImage* make_desc_image(GrContext* ctx, int w, int h, GrBackendObject texID,
+                                ReleaseTextureContext* releaseContext) {
     GrBackendTextureDesc desc;
     desc.fConfig = kSkia8888_GrPixelConfig;
     // need to be a rendertarget for now...
     desc.fFlags = kRenderTarget_GrBackendTextureFlag;
     desc.fWidth = w;
     desc.fHeight = h;
     desc.fSampleCnt = 0;
     desc.fTextureHandle = texID;
-    return doCopy ? SkImage::NewFromTextureCopy(ctx, desc) : SkImage::NewFromTexture(ctx, desc);
+    return releaseContext
+                ? SkImage::NewFromTexture(ctx, desc, kPremul_SkAlphaType,
+                                          ReleaseTextureContext::ReleaseProc, releaseContext)
+                : SkImage::NewFromTextureCopy(ctx, desc, kPremul_SkAlphaType);
 }
 
 static void test_image_color(skiatest::Reporter* reporter, SkImage* image, SkPMColor expected) {
     const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
     SkPMColor pixel;
     REPORTER_ASSERT(reporter, image->readPixels(info, &pixel, sizeof(pixel), 0, 0));
     REPORTER_ASSERT(reporter, pixel == expected);
 }
 
 DEF_GPUTEST(SkImage_NewFromTexture, reporter, factory) {
@@ skipping 16 matching lines @@
     desc.fWidth = w;
     desc.fHeight = h;
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fSampleCnt = 0;
     
     SkAutoTUnref<GrTexture> tex(provider->createTexture(desc, false, storage, w * 4));
     if (!tex) {
         REPORTER_ASSERT(reporter, false);
         return;
     }
-    
+
     GrBackendObject srcTex = tex->getTextureHandle();
-    SkAutoTUnref<SkImage> refImg(make_desc_image(ctx, w, h, srcTex, false));
-    SkAutoTUnref<SkImage> cpyImg(make_desc_image(ctx, w, h, srcTex, true));
+    ReleaseTextureContext releaseCtx(reporter);
+
+    SkAutoTUnref<SkImage> refImg(make_desc_image(ctx, w, h, srcTex, &releaseCtx));
+    SkAutoTUnref<SkImage> cpyImg(make_desc_image(ctx, w, h, srcTex, NULL));
 
     test_image_color(reporter, refImg, expected0);
     test_image_color(reporter, cpyImg, expected0);
 
     // Now lets jam new colors into our "external" texture, and see if the images notice
     const SkPMColor expected1 = SkPreMultiplyColor(SK_ColorBLUE);
     sk_memset32(storage, expected1, w * h);
     tex->writePixels(0, 0, w, h, kSkia8888_GrPixelConfig, storage, GrContext::kFlushWrites_PixelOp);
 
     // We expect the ref'd image to see the new color, but cpy'd one should still see the old color
     test_image_color(reporter, refImg, expected1);
     test_image_color(reporter, cpyImg, expected0);
+
+    // Now exercise the release proc
+    REPORTER_ASSERT(reporter, !releaseCtx.fIsReleased);
+    refImg.reset(NULL); // force a release of the image
+    REPORTER_ASSERT(reporter, releaseCtx.fIsReleased);
 }
 #endif