Switch SkSpecialImage & SkSpecialSurface classes over to smart pointers

tests/ImageFilterCacheTest.cpp

  /*
   * Copyright 2016 Google Inc.
   *
   * Use of this source code is governed by a BSD-style license that can be
   * found in the LICENSE file.
   */
 
 #include "Test.h"
 
 #include "SkBitmap.h"
 #include "SkImage.h"
 #include "SkImageFilter.h"
 #include "SkImageFilterCacheKey.h"
 #include "SkMatrix.h"
 #include "SkSpecialImage.h"
 
 static const int kSmallerSize = 10;
 static const int kPad = 3;
 static const int kFullSize = kSmallerSize + 2 * kPad;
 
 static SkBitmap create_bm() {
     SkBitmap bm;
     bm.allocN32Pixels(kFullSize, kFullSize, true);
     bm.eraseColor(SK_ColorTRANSPARENT);
     return bm;
 }
 
 // Ensure the cache can return a cached image
 static void test_find_existing(skiatest::Reporter* reporter,
-                               SkSpecialImage* image,
-                               SkSpecialImage* subset) {
+                               const sk_sp<SkSpecialImage>& image,
+                               const sk_sp<SkSpecialImage>& subset) {
     static const size_t kCacheSize = 1000000;
     SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kCacheSize));
 
     SkIRect clip = SkIRect::MakeWH(100, 100);
     SkImageFilter::Cache::Key key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key2(0, SkMatrix::I(), clip, subset->uniqueID(), subset->subset());
 
     SkIPoint offset = SkIPoint::Make(3, 4);
-    cache->set(key1, image, offset);
+    cache->set(key1, image.get(), offset);
 
     SkIPoint foundOffset;
 
     SkSpecialImage* foundImage = cache->get(key1, &foundOffset);
     REPORTER_ASSERT(reporter, foundImage);
     REPORTER_ASSERT(reporter, offset == foundOffset);
 
     REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
 }
 
 // If either id is different or the clip or the matrix are different the
 // cached image won't be found. Even if it is caching the same bitmap.
 static void test_dont_find_if_diff_key(skiatest::Reporter* reporter,
-                                       SkSpecialImage* image,
-                                       SkSpecialImage* subset) {
+                                       const sk_sp<SkSpecialImage>& image,
+                                       const sk_sp<SkSpecialImage>& subset) {
     static const size_t kCacheSize = 1000000;
     SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kCacheSize));
 
     SkIRect clip1 = SkIRect::MakeWH(100, 100);
     SkIRect clip2 = SkIRect::MakeWH(200, 200);
     SkImageFilter::Cache::Key key0(0, SkMatrix::I(), clip1, image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key1(1, SkMatrix::I(), clip1, image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key2(0, SkMatrix::MakeTrans(5, 5), clip1,
                                    image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key3(0, SkMatrix::I(), clip2, image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key4(0, SkMatrix::I(), clip1, subset->uniqueID(), subset->subset());
 
     SkIPoint offset = SkIPoint::Make(3, 4);
-    cache->set(key0, image, offset);
+    cache->set(key0, image.get(), offset);
 
     SkIPoint foundOffset;
     REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
     REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
     REPORTER_ASSERT(reporter, !cache->get(key3, &foundOffset));
     REPORTER_ASSERT(reporter, !cache->get(key4, &foundOffset));
 }
 
 // Test purging when the max cache size is exceeded
-static void test_internal_purge(skiatest::Reporter* reporter, SkSpecialImage* image) {
+static void test_internal_purge(skiatest::Reporter* reporter, const sk_sp<SkSpecialImage>& image) {
     SkASSERT(image->getSize());
     const size_t kCacheSize = image->getSize() + 10;
     SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kCacheSize));
 
     SkIRect clip = SkIRect::MakeWH(100, 100);
     SkImageFilter::Cache::Key key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key2(1, SkMatrix::I(), clip, image->uniqueID(), image->subset());
 
     SkIPoint offset = SkIPoint::Make(3, 4);
-    cache->set(key1, image, offset);
+    cache->set(key1, image.get(), offset);
 
     SkIPoint foundOffset;
 
     REPORTER_ASSERT(reporter, cache->get(key1, &foundOffset));
 
     // This should knock the first one out of the cache
-    cache->set(key2, image, offset);
+    cache->set(key2, image.get(), offset);
 
     REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
     REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
 }
 
 // Exercise the purgeByKeys and purge methods
 static void test_explicit_purging(skiatest::Reporter* reporter,
-                                  SkSpecialImage* image,
-                                  SkSpecialImage* subset) {
+                                  const sk_sp<SkSpecialImage>& image,
+                                  const sk_sp<SkSpecialImage>& subset) {
     static const size_t kCacheSize = 1000000;
     SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kCacheSize));
 
     SkIRect clip = SkIRect::MakeWH(100, 100);
     SkImageFilter::Cache::Key key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
     SkImageFilter::Cache::Key key2(1, SkMatrix::I(), clip, subset->uniqueID(), image->subset());
 
     SkIPoint offset = SkIPoint::Make(3, 4);
-    cache->set(key1, image, offset);
-    cache->set(key2, image, offset);
+    cache->set(key1, image.get(), offset);
+    cache->set(key2, image.get(), offset);
 
     SkIPoint foundOffset;
 
     REPORTER_ASSERT(reporter, cache->get(key1, &foundOffset));
     REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
 
     cache->purgeByKeys(&key1, 1);
 
     REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
     REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
 
     cache->purge();
 
     REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
     REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
 }
 
 DEF_TEST(ImageFilterCache_RasterBacked, reporter) {
     SkBitmap srcBM = create_bm();
 
     const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
 
-    SkAutoTUnref<SkSpecialImage> fullImg(SkSpecialImage::NewFromRaster(nullptr, full, srcBM));
+    sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeFromRaster(nullptr, full, srcBM));
 
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
-    SkAutoTUnref<SkSpecialImage> subsetImg(SkSpecialImage::NewFromRaster(nullptr, subset, srcBM));
+    sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeFromRaster(nullptr, subset, srcBM));
 
     test_find_existing(reporter, fullImg, subsetImg);
     test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
     test_internal_purge(reporter, fullImg);
     test_explicit_purging(reporter, fullImg, subsetImg);
 }
 
 
 // Shared test code for both the raster and gpu-backed image cases
-static void test_image_backed(skiatest::Reporter* reporter, SkImage* srcImage) {
+static void test_image_backed(skiatest::Reporter* reporter, const sk_sp<SkImage>& srcImage) {
     const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
 
-    SkAutoTUnref<SkSpecialImage> fullImg(SkSpecialImage::NewFromImage(nullptr, full, srcImage));
+    sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeFromImage(nullptr, full, srcImage));
 
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
-    SkAutoTUnref<SkSpecialImage> subsetImg(SkSpecialImage::NewFromImage(nullptr,
-                                                                        subset,
-                                                                        srcImage));
+    sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeFromImage(nullptr, subset, srcImage));
 
     test_find_existing(reporter, fullImg, subsetImg);
     test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
     test_internal_purge(reporter, fullImg);
     test_explicit_purging(reporter, fullImg, subsetImg);
 }
 
 DEF_TEST(ImageFilterCache_ImageBackedRaster, reporter) {
     SkBitmap srcBM = create_bm();
 
     sk_sp<SkImage> srcImage(SkImage::MakeFromBitmap(srcBM));
 
-    test_image_backed(reporter, srcImage.get());
+    test_image_backed(reporter, srcImage);
 }
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 
 static GrTexture* create_texture(GrContext* context) {
     SkBitmap srcBM = create_bm();
 
     GrSurfaceDesc desc;
     desc.fConfig = kSkia8888_GrPixelConfig;
@@ skipping 15 matching lines @@
     backendDesc.fFlags = kNone_GrBackendTextureFlag;
     backendDesc.fWidth = kFullSize;
     backendDesc.fHeight = kFullSize;
     backendDesc.fSampleCnt = 0;
     backendDesc.fTextureHandle = srcTexture->getTextureHandle();
     sk_sp<SkImage> srcImage(SkImage::MakeFromTexture(context, backendDesc, kPremul_SkAlphaType));
     if (!srcImage) {
         return;
     }
 
-    test_image_backed(reporter, srcImage.get());
+    test_image_backed(reporter, srcImage);
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_GPUBacked, reporter, context) {
 
     SkAutoTUnref<GrTexture> srcTexture(create_texture(context));
     if (!srcTexture) {
         return;
     }
 
     const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
 
-    SkAutoTUnref<SkSpecialImage> fullImg(SkSpecialImage::NewFromGpu(
-                                                                nullptr, full,
+    sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeFromGpu(nullptr, full,
+                                                              kNeedNewImageUniqueID_SpecialImage,
+                                                              srcTexture));
+
+    const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
+
+    sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeFromGpu(nullptr, subset,
                                                                 kNeedNewImageUniqueID_SpecialImage,
                                                                 srcTexture));
 
-    const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
-
-    SkAutoTUnref<SkSpecialImage> subsetImg(SkSpecialImage::NewFromGpu(
-                                                                nullptr, subset,
-                                                                kNeedNewImageUniqueID_SpecialImage,
-                                                                srcTexture));
-
     test_find_existing(reporter, fullImg, subsetImg);
     test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
     test_internal_purge(reporter, fullImg);
     test_explicit_purging(reporter, fullImg, subsetImg);
 }
 #endif