Purge cached resources on SkImage destruction.

tests/SkResourceCacheTest.cpp

 /*
  * Copyright 2014 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 "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkGraphics.h"
+#include "SkPicture.h"
+#include "SkPictureRecorder.h"
 #include "SkResourceCache.h"
 #include "SkSurface.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
 static void make_bitmap(SkBitmap* bitmap, const SkImageInfo& info, SkBitmap::Allocator* allocator) {
     if (allocator) {
         bitmap->setInfo(info);
         allocator->allocPixelRef(bitmap, 0);
     } else {
@@ skipping 189 matching lines @@
     cachedBitmap.unlockPixels();
 
     // We can add the bitmap back to the cache and find it again.
     REPORTER_ASSERT(reporter, SkBitmapCache::Add(cachedBitmap.pixelRef(), rect, cachedBitmap, cache));
     REPORTER_ASSERT(reporter, SkBitmapCache::Find(cachedBitmap.getGenerationID(), rect, &bm, cache));
 
     test_mipmapcache(reporter, cache);
     test_bitmap_notify(reporter, cache);
     test_mipmap_notify(reporter, cache);
 }
+
+static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& transform,

[reed1, 2015/09/18 14:32:53]

How about a block-comment here or on the main test function, describing the
architecture (briefly) and why we want to exercise different parts. e.g.
(generated images have caches, HQ-scaled images have caches, etc.)

[f(malita), 2015/09/18 15:00:40]

Done.

+                                 SkImage* (*buildImage)()) {
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
+    SkCanvas* canvas = surface->getCanvas();
+
+    // SkBitmapCache is global, so other threads could be evicting our bitmaps.  Loop a few times
+    // to mitigate this risk.

[tomhudson, 2015/09/18 13:30:54]

Not sure how this is safe from flake?

[f(malita), 2015/09/18 13:44:24]

Note that we don't assert image pixels are cached, but only that they're no
longer cached after image destruction.

So flakes would err on the side of passing (the danger is for some other thread
to evict our data instead of the SkImage destructor).

Not sure how to improve this given multithreaded DM + global cache, beyond "the
risk is low, let's repeat a few time to increase our chances of detecting
breakage".  Maybe add a DEF_SERIAL_TEST DM option?

[mtklein, 2015/09/18 13:56:15]

DM has a way to group tasks that cannot run concurrently together into an
enclave.  The enclave itself runs in parallel with other enclaves and with
thread-safe tasks (sort of little enclaves-of-1), but the tasks inside it run
serially.  This is how we do GPU testing, and how we used to do PDF testing back
when it wasn't thread safe.

If we can identify all the tasks (unit tests, GMs, skps, etc) that might
interfere here, we can put them all in an enclave together.  But if that's a
significant chunk of everything, it's probably better to do nothing instead,
rather than serialize DM.

Another approach is to have the bots run DM twice, once with --match
NotThreadSafe, the other time with --match ~NotThreadSafe, and just name
non-thread-safe tests something with "NotThreadSafe" in it.

Another approach is to add test-only canvas APIs to plumb down a separate
resource cache to use and make this thread safe.

+    const unsigned kRepeatCount = 42;
+    for (unsigned i = 0; i < kRepeatCount; ++i) {
+        SkAutoCanvasRestore acr(canvas, true);
+
+        SkAutoTUnref<SkImage> image(buildImage());
+
+        // always use high quality to ensure caching when scaled
+        SkPaint paint;
+        paint.setFilterQuality(kHigh_SkFilterQuality);
+
+        // draw the image (with a transform, to tickle different code paths) to ensure
+        // any associated resources get cached
+        canvas->concat(transform);
+        canvas->drawImage(image, 0, 0, &paint);
+
+        auto imageId = image->uniqueID();
+
+        // delete the image
+        image.reset(nullptr);
+
+        // all resources should have been purged
+        SkBitmap result;
+        REPORTER_ASSERT(reporter, !SkBitmapCache::Find(imageId, &result));
+    }
+}
+
+DEF_TEST(BitmapCache_discarded_image, reporter) {
+    const SkMatrix xforms[] = {
+        SkMatrix::MakeScale(1, 1),
+        SkMatrix::MakeScale(1.7f, 0.5f),
+    };
+
+    for (size_t i = 0; i < SK_ARRAY_COUNT(xforms); ++i) {
+        test_discarded_image(reporter, xforms[i], []() {
+            SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
+            surface->getCanvas()->clear(SK_ColorCYAN);
+            return surface->newImageSnapshot();
+        });
+
+        test_discarded_image(reporter, xforms[i], []() {
+            SkPictureRecorder recorder;
+            SkCanvas* canvas = recorder.beginRecording(10, 10);
+            canvas->clear(SK_ColorCYAN);
+            SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+            return SkImage::NewFromPicture(picture, SkISize::Make(10, 10), nullptr, nullptr);
+        });
+    }
+}