SkDiscardableMemory::Factory class

src/lazy/SkBitmapFactory.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapFactory.h"
 
 #include "SkBitmap.h"
 #include "SkData.h"
+#include "SkDiscardablePixelRef.h"
 #include "SkImageCache.h"
+#include "SkDecodingImageGenerator.h"
 #include "SkImagePriv.h"
-#include "SkLazyPixelRef.h"
 
 SK_DEFINE_INST_COUNT(SkBitmapFactory::CacheSelector)
 
 SkBitmapFactory::SkBitmapFactory(SkBitmapFactory::DecodeProc proc)
     : fDecodeProc(proc)
     , fImageCache(NULL)
     , fCacheSelector(NULL) {
     SkASSERT(fDecodeProc != NULL);
 }
 
@@ skipping 11 matching lines @@
 }
 
 void SkBitmapFactory::setCacheSelector(CacheSelector* selector) {
     SkRefCnt_SafeAssign(fCacheSelector, selector);
     if (selector != NULL) {
         SkSafeUnref(fImageCache);
         fImageCache = NULL;
     }
 }
 
+namespace {
+class FlexibleImageGenerator : public SkImageGenerator {
+public:
+    FlexibleImageGenerator(SkBitmapFactory::DecodeProc proc,
+                           SkData* data)
+        : fProc(proc), fData(data) {
+        SkASSERT(fData);
+        SkASSERT(fProc);
+        fData->ref();
+    }
+    ~FlexibleImageGenerator() {
+        fData->unref();
+    }
+    SkData* refEncodedData() {
+        fData->ref();
+        return fData;
+    }
+    bool getInfo(SkImageInfo* info) {
+        SkASSERT(info != NULL);
+        return fProc(fData->data(), fData->size(), info, NULL);
+    }
+    bool getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes) {
+        SkASSERT(pixels != NULL);
+        SkBitmapFactory::Target target = {pixels, rowBytes};
+        SkImageInfo tmpInfo = info;
+        return fProc(fData->data(), fData->size(), &tmpInfo, &target);
+    }
+
+private:
+    SkBitmapFactory::DecodeProc fProc;
+    SkData*                     fData;
+};
+}  // namespace
+
 bool SkBitmapFactory::installPixelRef(SkData* data, SkBitmap* dst) {
     if (NULL == data || 0 == data->size() || dst == NULL) {
         return false;
     }
 
+    SkAutoTDelete<SkImageGenerator> gen(SkNEW_ARGS(FlexibleImageGenerator,
+                                                   (fDecodeProc, data)));
     SkImageInfo info;
-    if (!fDecodeProc(data->data(), data->size(), &info, NULL)) {
+    if (!gen->getInfo(&info)) {
         return false;
     }
 
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
-
-    Target target;
-    // FIMXE: There will be a problem if this rowbytes is calculated differently from
-    // in SkLazyPixelRef.
-    target.fRowBytes = SkImageMinRowBytes(info);
-    dst->setConfig(config, info.fWidth, info.fHeight, target.fRowBytes, info.fAlphaType);
-
     // fImageCache and fCacheSelector are mutually exclusive.
     SkASSERT(NULL == fImageCache || NULL == fCacheSelector);
 
     SkImageCache* cache = NULL == fCacheSelector ? fImageCache : fCacheSelector->selectCache(info);
 
+    // TODO(halcanary): the SkBitmapFactory::CacheSelector needs a way
+    // to specify that SkDiscardableMemory should be created via
+    // SkDiscardableMemory::Create().  Currently, if the cache
+    // selector reutuns NULL, that is taken as an instruction to use

[scroggo, 2013/12/02 19:00:09]

returns*

+    // normal malloc()ed pixels.
+
     if (cache != NULL) {
-        // Now set a new LazyPixelRef on dst.
-        SkAutoTUnref<SkLazyPixelRef> lazyRef(SkNEW_ARGS(SkLazyPixelRef,
-                                                        (data, fDecodeProc, cache)));
-        dst->setPixelRef(lazyRef);
+        return SkDiscardablePixelRef::Install(gen.detach(), dst, cache);
+    } else {
+        SkBitmap tmp;
+        if (!tmp.setConfig(info, 0)) {
+            return false;
+        }
+        tmp.allocPixels();
+        if (!gen->getPixels(info, tmp.getPixels(), tmp.rowBytes())) {
+            return false;
+        }
+        dst->swap(tmp);
         return true;
-    } else {
-        dst->allocPixels();
-        target.fAddr = dst->getPixels();
-        return fDecodeProc(data->data(), data->size(), &info, &target);
     }
 }