Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2012 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifdef SK_DEBUG
      9 
     10 #include "SkBitmap.h"
     11 #include "SkBitmapFactory.h"
     12 #include "SkCanvas.h"
     13 #include "SkColor.h"
     14 #include "SkData.h"
     15 #include "SkImageDecoder.h"
     16 #include "SkImageEncoder.h"
     17 #include "SkLazyPixelRef.h"
     18 #include "SkLruImageCache.h"
     19 #include "SkPaint.h"
     20 #include "SkPurgeableImageCache.h"
     21 #include "SkStream.h"
     22 #include "SkTemplates.h"
     23 #include "Test.h"
     24 
     25 static SkBitmap* create_bitmap() {
     26     SkBitmap* bm = SkNEW(SkBitmap);
     27     // Use a large bitmap.
     28     const int W = 1000, H = 1000;
     29     bm->setConfig(SkBitmap::kARGB_8888_Config, W, H);
     30     bm->allocPixels();
     31     bm->eraseColor(SK_ColorBLACK);
     32     SkCanvas canvas(*bm);
     33     SkPaint paint;
     34     paint.setColor(SK_ColorBLUE);
     35     canvas.drawRectCoords(0, 0, SkIntToScalar(W/2), SkIntToScalar(H/2), paint);
     36     return bm;
     37 }
     38 
     39 static SkData* create_data_from_bitmap(const SkBitmap& bm) {
     40     SkDynamicMemoryWStream stream;
     41     if (SkImageEncoder::EncodeStream(&stream, bm, SkImageEncoder::kPNG_Type, 100)) {
     42         return stream.copyToData();
     43     }
     44     return NULL;
     45 }
     46 
     47 static void assert_bounds_equal(skiatest::Reporter* reporter, const SkBitmap& bm1,
     48                                 const SkBitmap& bm2) {
     49     REPORTER_ASSERT(reporter, bm1.width() == bm2.width());
     50     REPORTER_ASSERT(reporter, bm1.height() == bm2.height());
     51 }
     52 
     53 static void test_cache(skiatest::Reporter* reporter, SkImageCache* cache) {
     54     // Test the cache directly:
     55     cache->purgeAllUnpinnedCaches();
     56     intptr_t ID = SkImageCache::UNINITIALIZED_ID;
     57     const size_t size = 1000;
     58     char buffer[size];
     59     sk_bzero((void*) buffer, size);
     60     void* memory = cache->allocAndPinCache(size, &ID);
     61     if (memory != NULL) {
     62         memcpy(memory, (void*)buffer, size);
     63         REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID) == SkImageCache::kPinned_MemoryStatus);
     64         cache->releaseCache(ID);
     65         REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID) != SkImageCache::kPinned_MemoryStatus);
     66         SkImageCache::DataStatus dataStatus;
     67         memory = cache->pinCache(ID, &dataStatus);
     68         if (memory != NULL) {
     69             REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID)
     70                                       == SkImageCache::kPinned_MemoryStatus);
     71             if (SkImageCache::kRetained_DataStatus == dataStatus) {
     72                 REPORTER_ASSERT(reporter, !memcmp(memory, (void*) buffer, size));
     73             }
     74             cache->releaseCache(ID);
     75             REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID)
     76                                       != SkImageCache::kPinned_MemoryStatus);
     77             cache->purgeAllUnpinnedCaches();
     78             REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID)
     79                                       != SkImageCache::kPinned_MemoryStatus);
     80             memory = cache->pinCache(ID, &dataStatus);
     81             if (memory != NULL) {
     82                 // The memory block may or may not have survived the purging (at the
     83                 // memory manager's whim) so we cannot check dataStatus here.
     84                 cache->releaseCache(ID);
     85                 REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID)
     86                                           != SkImageCache::kPinned_MemoryStatus);
     87                 cache->throwAwayCache(ID);
     88                 REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID)
     89                                           == SkImageCache::kFreed_MemoryStatus);
     90             } else {
     91                 REPORTER_ASSERT(reporter, cache->getMemoryStatus(ID)
     92                                           == SkImageCache::kFreed_MemoryStatus);
     93             }
     94         }
     95     }
     96 }
     97 
     98 static void test_factory(skiatest::Reporter* reporter, SkImageCache* cache, SkData* encodedData,
     99                        const SkBitmap& origBitmap) {
    100     SkBitmapFactory factory(&SkImageDecoder::DecodeMemoryToTarget);
    101     factory.setImageCache(cache);
    102     SkAutoTDelete<SkBitmap> bitmapFromFactory(SkNEW(SkBitmap));
    103     bool success = factory.installPixelRef(encodedData, bitmapFromFactory.get());
    104     // This assumes that if the encoder worked, the decoder should also work, so the above call
    105     // should not fail.
    106     REPORTER_ASSERT(reporter, success);
    107     assert_bounds_equal(reporter, origBitmap, *bitmapFromFactory.get());
    108 
    109     SkPixelRef* pixelRef = bitmapFromFactory->pixelRef();
    110     REPORTER_ASSERT(reporter, pixelRef != NULL);
    111     if (NULL == cache) {
    112         // This assumes that installPixelRef called lockPixels.
    113         REPORTER_ASSERT(reporter, bitmapFromFactory->readyToDraw());
    114     } else {
    115         // Lazy decoding
    116         REPORTER_ASSERT(reporter, !bitmapFromFactory->readyToDraw());
    117         SkLazyPixelRef* lazyRef = static_cast<SkLazyPixelRef*>(pixelRef);
    118         intptr_t cacheID = lazyRef->getCacheId();
    119         REPORTER_ASSERT(reporter, cache->getMemoryStatus(cacheID)
    120                                   != SkImageCache::kPinned_MemoryStatus);
    121         {
    122             SkAutoLockPixels alp(*bitmapFromFactory.get());
    123             REPORTER_ASSERT(reporter, bitmapFromFactory->readyToDraw());
    124             cacheID = lazyRef->getCacheId();
    125             REPORTER_ASSERT(reporter, cache->getMemoryStatus(cacheID)
    126                                       == SkImageCache::kPinned_MemoryStatus);
    127         }
    128         REPORTER_ASSERT(reporter, !bitmapFromFactory->readyToDraw());
    129         REPORTER_ASSERT(reporter, cache->getMemoryStatus(cacheID)
    130                                   != SkImageCache::kPinned_MemoryStatus);
    131         bitmapFromFactory.free();
    132         REPORTER_ASSERT(reporter, cache->getMemoryStatus(cacheID)
    133                                   == SkImageCache::kFreed_MemoryStatus);
    134     }
    135 }
    136 
    137 class ImageCacheHolder : public SkNoncopyable {
    138 
    139 public:
    140     ~ImageCacheHolder() {
    141         fCaches.safeUnrefAll();
    142     }
    143 
    144     void addImageCache(SkImageCache* cache) {
    145         SkSafeRef(cache);
    146         *fCaches.append() = cache;
    147     }
    148 
    149     int count() const { return fCaches.count(); }
    150 
    151     SkImageCache* getAt(int i) {
    152         if (i < 0 || i > fCaches.count()) {
    153             return NULL;
    154         }
    155         return fCaches.getAt(i);
    156     }
    157 
    158 private:
    159     SkTDArray<SkImageCache*> fCaches;
    160 };
    161 
    162 static void TestBitmapFactory(skiatest::Reporter* reporter) {
    163     SkAutoTDelete<SkBitmap> bitmap(create_bitmap());
    164     SkASSERT(bitmap.get() != NULL);
    165 
    166     SkAutoDataUnref encodedBitmap(create_data_from_bitmap(*bitmap.get()));
    167     bool encodeSucceeded = encodedBitmap.get() != NULL;
    168     SkASSERT(encodeSucceeded);
    169 
    170     ImageCacheHolder cacheHolder;
    171 
    172     SkAutoTUnref<SkLruImageCache> lruCache(SkNEW_ARGS(SkLruImageCache, (1024 * 1024)));
    173     cacheHolder.addImageCache(lruCache);
    174 
    175     cacheHolder.addImageCache(NULL);
    176 
    177     SkImageCache* purgeableCache = SkPurgeableImageCache::Create();
    178     if (purgeableCache != NULL) {
    179         cacheHolder.addImageCache(purgeableCache);
    180         purgeableCache->unref();
    181     }
    182 
    183     for (int i = 0; i < cacheHolder.count(); i++) {
    184         SkImageCache* cache = cacheHolder.getAt(i);
    185         if (cache != NULL) {
    186             test_cache(reporter, cache);
    187         }
    188         if (encodeSucceeded) {
    189             test_factory(reporter, cache, encodedBitmap, *bitmap.get());
    190         }
    191     }
    192 }
    193 
    194 #include "TestClassDef.h"
    195 DEFINE_TESTCLASS("BitmapFactory", TestBitmapFactoryClass, TestBitmapFactory)
    196 
    197 #endif // SK_DEBUG
    198