Modify SkLazyPixelRef to use SkImageGenerator.

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 "SkDecodingImageGenerator.h"
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 #include "SkImagePriv.h"
 #include "SkLazyCachingPixelRef.h"
 #include "SkLazyPixelRef.h"
 #include "SkScaledImageCache.h"
 #include "SkStream.h"
+#include "SkLruImageCache.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) {
@@ skipping 23 matching lines @@
     }
     return NULL;
 }
 
 /**
  *  A simplified version of SkBitmapFactory
  */
 static bool simple_bitmap_factory(SkBitmapFactory::DecodeProc proc,
                                   SkData* data,
                                   SkBitmap* dst) {
-    SkImageInfo info;
-    if (!proc(data->data(), data->size(), &info, NULL)) {
-        return false;
-    }
-    dst->setConfig(SkImageInfoToBitmapConfig(info), info.fWidth,
-                    info.fHeight, 0, info.fAlphaType);
-    SkAutoTUnref<SkLazyPixelRef> ref(SkNEW_ARGS(SkLazyPixelRef,
-                                                (data, proc, NULL)));
-    dst->setPixelRef(ref);
-    return true;
+    SkBitmapFactory fact(proc);
+    size_t budget = 1000000;
+    SkAutoTUnref<SkImageCache> cache(SkNEW_ARGS(SkLruImageCache, (budget)));
+    fact.setImageCache(cache.get());
+    return fact.installPixelRef(data, dst);
 }
 
 static void compare_bitmaps(skiatest::Reporter* reporter,
                             const SkBitmap& b1, const SkBitmap& b2,
                             bool pixelPerfect = true) {
     REPORTER_ASSERT(reporter, b1.empty() == b2.empty());
     REPORTER_ASSERT(reporter, b1.width() == b2.width());
     REPORTER_ASSERT(reporter, b1.height() == b2.height());
     REPORTER_ASSERT(reporter, b1.isNull() == b2.isNull());
     SkAutoLockPixels autoLockPixels1(b1);
@@ skipping 115 matching lines @@
     {
         SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
         REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
     }
     compare_bitmaps(reporter, original, lazy, comparePixels);
 }
 DEF_TEST(LazyCachedPixelRef, reporter) {
     test_three_encodings(reporter, compare_with_skLazyCachedPixelRef);
 }
 
+namespace {
 class TestPixelRef : public SkCachingPixelRef {
 public:
-    TestPixelRef(int x) : fX(x) { }
+    explicit TestPixelRef(int x) : fX(x) { }
     virtual ~TestPixelRef() { }
     static bool Install(SkBitmap* destination, int x) {
         SkAutoTUnref<TestPixelRef> ref(SkNEW_ARGS(TestPixelRef, (x)));
         return ref->configure(destination) && destination->setPixelRef(ref);
     }
     SK_DECLARE_UNFLATTENABLE_OBJECT()
+
 protected:
     virtual bool onDecodeInfo(SkImageInfo* info) SK_OVERRIDE {
         if (fX == 0) {
             return false;
         }
         SkASSERT(info);
         info->fWidth = 10;
         info->fHeight = 10;
         info->fColorType = kRGBA_8888_SkColorType;
         info->fAlphaType = kOpaque_SkAlphaType;
         return true;
     }
     virtual bool onDecodePixels(const SkImageInfo& info,
                                 void* pixels,
                                 size_t rowBytes) SK_OVERRIDE {
         return false;
     }
+
 private:
     int fX;  // controls where the failure happens
     typedef SkCachingPixelRef INHERITED;
 };
+}  // namespace
 
 DEF_TEST(CachingPixelRef, reporter) {
     SkBitmap lazy;
     // test the error handling
     REPORTER_ASSERT(reporter, !TestPixelRef::Install(&lazy, 0));
     // onDecodeInfo should succeed, allowing installation
     REPORTER_ASSERT(reporter, TestPixelRef::Install(&lazy, 1));
     SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
     // onDecodePixels should fail, so getting pixels will fail.
     REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
 }
 
 static void compare_with_SkDecodingImageGenerator(skiatest::Reporter* reporter,
                                                   SkData* encoded,
                                                   const SkBitmap& original,
                                                   bool comparePixels) {
-
     SkBitmap lazy;
     bool success = SkDecodingImageGenerator::Install(encoded, &lazy);
     REPORTER_ASSERT(reporter, success);
     if (!success) {
         return;
     }
 
     REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
     {
         SkAutoLockPixels autoLockPixels(lazy);  // now pixels are good.
         REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
         if (NULL == lazy.getPixels()) {
             return;
         }
     }
     // 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(DecodingImageGenerator, reporter) {
     test_three_encodings(reporter, compare_with_SkDecodingImageGenerator);
 }