Break up SkLazyPixelRef functionally into class hierarchy.

tests/CachedDecodingPixelRefTest.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 "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 #include "SkImagePriv.h"
+#include "SkLazyCachingPixelRef.h"
 #include "SkLazyPixelRef.h"
 #include "SkScaledImageCache.h"
 #include "SkStream.h"
+
 #include "Test.h"
+#include "TestClassDef.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 /**
  * Fill this bitmap with some color.
  */
 static void make_test_image(SkBitmap* bm) {
     static const int W = 50, H = 50;
     static const SkBitmap::Config config = SkBitmap::kARGB_8888_Config;
     bm->setConfig(config, W, H);
@@ skipping 57 matching lines @@
     if ((!(b1.getPixels())) || (!(b2.getPixels()))) {
         return;
     }
     if ((b1.width() != b2.width()) ||
         (b1.height() != b2.height())) {
         return;
     }
     if (!pixelPerfect) {
         return;
     }
+
     int pixelErrors = 0;
     for (int y = 0; y < b2.height(); ++y) {
         for (int x = 0; x < b2.width(); ++x) {
             if (b1.getColor(x, y) != b2.getColor(x, y)) {
                 ++pixelErrors;
             }
         }
     }
     REPORTER_ASSERT(reporter, 0 == pixelErrors);
 }
 
+
+typedef void(*CompareEncodedToOriginal)(skiatest::Reporter* reporter,
+                                        SkData* encoded,
+                                        const SkBitmap& original,
+                                        bool pixelPerfect);
 /**
- *  This checks to see that a SkLazyPixelRef works as advertized.
- */
-#include "TestClassDef.h"
-DEF_TEST(CachedDecodingPixelRefTest, reporter) {
+   this function tests three differently encoded images against the
+   origianl bitmap  */
+void testThreeEncodings(skiatest::Reporter* reporter,

[scroggo, 2013/11/01 15:48:00]

This function should be static.

Also, static functions should have underscore_names.

[hal.canary, 2013/11/01 16:31:09]

Done.

+                        CompareEncodedToOriginal comp) {
     SkBitmap original;
     make_test_image(&original);
-    const size_t bitmapSize = original.getSize();
-    const size_t oldByteLimit = SkScaledImageCache::GetByteLimit();
-    REPORTER_ASSERT(reporter, (!(original.empty())) && (!(original.isNull())));
-
+    REPORTER_ASSERT(reporter, !original.empty());
+    REPORTER_ASSERT(reporter, !original.isNull());
+    if (original.empty() || original.isNull()) {
+        return;
+    }
     static const SkImageEncoder::Type types[] = {
         SkImageEncoder::kPNG_Type,
         SkImageEncoder::kJPEG_Type,
         SkImageEncoder::kWEBP_Type
     };
-
     for (size_t i = 0; i < SK_ARRAY_COUNT(types); i++) {
         SkImageEncoder::Type type = types[i];
         SkAutoDataUnref encoded(create_data_from_bitmap(original, type));
         REPORTER_ASSERT(reporter, encoded.get() != NULL);
-        if (NULL == encoded.get()) {
-            continue;
+        if (NULL != encoded.get()) {
+            bool comparePixels = (SkImageEncoder::kPNG_Type == type);
+            comp(reporter, encoded, original, comparePixels);
         }
-        SkBitmap lazy;
-        static const SkBitmapFactory::DecodeProc decoder =
-            &(SkImageDecoder::DecodeMemoryToTarget);
-        bool success = simple_bitmap_factory(decoder, encoded.get(), &lazy);
-
-        REPORTER_ASSERT(reporter, success);
-
-        size_t bytesUsed = SkScaledImageCache::GetBytesUsed();
-
-        if (oldByteLimit < bitmapSize) {
-            SkScaledImageCache::SetByteLimit(bitmapSize + oldByteLimit);
-        }
-        void* lazyPixels = NULL;
-
-        // Since this is lazy, it shouldn't have fPixels yet!
-        REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
-        {
-            SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
-            lazyPixels = lazy.getPixels();
-            REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
-            // first time we lock pixels, we should get bump in the size
-            // of the cache by exactly bitmapSize.
-            REPORTER_ASSERT(reporter, bytesUsed + bitmapSize
-                            == SkScaledImageCache::GetBytesUsed());
-            bytesUsed = SkScaledImageCache::GetBytesUsed();
-        }
-        // pixels should be gone!
-        REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
-        {
-            SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
-            REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
-
-            // verify that the same pixels are used this time.
-            REPORTER_ASSERT(reporter, lazy.getPixels() == lazyPixels);
-        }
-
-        bool comparePixels = (SkImageEncoder::kPNG_Type == type);
-        // Only PNG is pixel-perfect.
-        compare_bitmaps(reporter, original, lazy, comparePixels);
-
-        // force the cache to clear by making it too small.
-        SkScaledImageCache::SetByteLimit(bitmapSize / 2);
-        compare_bitmaps(reporter, original, lazy, comparePixels);
-
-        // I'm pretty sure that the logic of the cache should mean
-        // that it will clear to zero, regardless of where it started.
-        REPORTER_ASSERT(reporter, SkScaledImageCache::GetBytesUsed() == 0);
-        // TODO(someone) - write a custom allocator that can verify
-        // that the memory where those pixels were cached really did
-        // get freed.
-
-        ////////////////////////////////////////////////////////////////////////
-        //  The following commented-out code happens to work on my
-        //  machine, and indicates to me that the SkLazyPixelRef is
-        //  behaving as designed.  But I don't know an easy way to
-        //  guarantee that a second allocation of the same size will
-        //  give a different address.
-        ////////////////////////////////////////////////////////////////////////
-        // {
-        //     // confuse the heap allocation system
-        //     SkAutoMalloc autoMalloc(bitmapSize);
-        //     REPORTER_ASSERT(reporter, autoMalloc.get() == lazyPixels);
-        //     {
-        //         SkAutoLockPixels autoLockPixels(lazy);
-        //         // verify that *different* pixels are used this time.
-        //         REPORTER_ASSERT(reporter, lazy.getPixels() != lazyPixels);
-        //         compare_bitmaps(reporter, original, lazy, comparePixels);
-        //     }
-        // }
-
-        // restore cache size
-        SkScaledImageCache::SetByteLimit(oldByteLimit);
     }
 }
+
+/**
+ *  This checks to see that a SkLazyPixelRef works as advertised.
+ */
+void compareWithSkLazyPixelRef(skiatest::Reporter* reporter,

[scroggo, 2013/11/01 15:48:00]

ditto

[hal.canary, 2013/11/01 16:31:09]

Done.

+                               SkData* encoded,
+                               const SkBitmap& original,
+                               bool comparePixels) {
+    SkBitmap lazy;
+    static const SkBitmapFactory::DecodeProc decoder =
+        &(SkImageDecoder::DecodeMemoryToTarget);
+    bool success = simple_bitmap_factory(decoder, encoded, &lazy);
+    REPORTER_ASSERT(reporter, success);
+
+    REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+    {
+        SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
+        REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+    }
+    // pixels should be gone!
+    REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+    {
+        SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
+        REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+    }
+    compare_bitmaps(reporter, original, lazy, comparePixels);
+}
+DEF_TEST(CachedDecodingPixelRefTest, reporter) {
+    testThreeEncodings(reporter, compareWithSkLazyPixelRef);
+}
+
+
+
+/**
+ *  This checks to see that a SkLazyCachedPixelRef works as advertised.
+ */
+
+void compareWithLazyCachedPixelRef(skiatest::Reporter* reporter,

[scroggo, 2013/11/01 15:48:00]

ditto

[hal.canary, 2013/11/01 16:31:09]

Done.

+                                   SkData* encoded,
+                                   const SkBitmap& original,
+                                   bool comparePixels) {
+    const size_t bitmapSize = original.getSize();
+    // By using a non-global cache, our unit tests won't collide with
+    // other unit tests.  Unit tests can be run in separate threads.
+    // TODO(halcanary): Find a way to robustly test the global
+    // instance of SkScaledImageCache.
+    SkScaledImageCache cache(2000000, NULL);
+    const size_t oldByteLimit = cache.getByteLimit();
+    SkBitmap lazy;
+    static const SkBitmapFactory::DecodeProc decoder =
+        &(SkImageDecoder::DecodeMemoryToTarget);
+
+    bool success = SkLazyCachingPixelRef::Install(decoder, encoded,
+                                                      &lazy, &cache);
+    REPORTER_ASSERT(reporter, success);
+
+    size_t bytesUsed = cache.getBytesUsed();
+
+    if (oldByteLimit < bitmapSize) {
+        cache.setByteLimit(bitmapSize + oldByteLimit);
+    }
+    void* lazyPixels = NULL;
+
+    // Since this is lazy, it shouldn't have fPixels yet!
+    REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+    {
+        SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
+        lazyPixels = lazy.getPixels();
+        REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+        // first time we lock pixels, we should get bump in the size
+        // of the cache by exactly bitmapSize.
+        REPORTER_ASSERT(reporter, bytesUsed + bitmapSize
+                        == cache.getBytesUsed());
+        bytesUsed = cache.getBytesUsed();
+    }
+    // pixels should be gone!
+    REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+    {
+        SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
+        REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+
+        // verify that the same pixels are used this time.
+        REPORTER_ASSERT(reporter, lazy.getPixels() == lazyPixels);
+    }
+
+    // Only PNG is pixel-perfect.
+    compare_bitmaps(reporter, original, lazy, comparePixels);
+
+    // force the cache to clear by making it too small.
+    cache.setByteLimit(bitmapSize / 2);
+
+    compare_bitmaps(reporter, original, lazy, comparePixels);
+
+    // I'm pretty sure that the logic of the cache should mean
+    // that it will clear to zero, regardless of where it started.
+    REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+    REPORTER_ASSERT(reporter, cache.getBytesUsed() == 0);
+    // TODO(someone) - write a custom allocator that can verify
+    // that the memory where those pixels were cached really did
+    // get freed.
+
+    ////////////////////////////////////////////////////////////////////////
+    //  The following commented-out code happens to work on my
+    //  machine, and indicates to me that the SkLazyPixelRef is
+    //  behaving as designed.  But I don't know an easy way to
+    //  guarantee that a second allocation of the same size will
+    //  give a different address.
+    ////////////////////////////////////////////////////////////////////////
+    // {
+    //     // confuse the heap allocation system
+    //     SkAutoMalloc autoMalloc(bitmapSize);
+    //     REPORTER_ASSERT(reporter, autoMalloc.get() == lazyPixels);
+    //     {
+    //         SkAutoLockPixels autoLockPixels(lazy);
+    //         // verify that *different* pixels are used this time.
+    //         REPORTER_ASSERT(reporter, lazy.getPixels() != lazyPixels);
+    //         compare_bitmaps(reporter, original, lazy, comparePixels);
+    //     }
+    // }
+}
+DEF_TEST(LazyCachedPixelRefTest, reporter) {
+    testThreeEncodings(reporter, compareWithLazyCachedPixelRef);
+}
+