Modify SkLazyPixelRef to use SkImageGenerator.

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 "SkImageCache.h"
 #include "SkImagePriv.h"
 #include "SkLazyPixelRef.h"
+#include "SkMallocPixelRef.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 {
+typedef SkBitmapFactory::DecodeProc DecodeProc;
+
+class FlexibleGenerator : public SkImageGenerator {

[reed1, 2013/11/25 18:06:56]

Not sure why this is named Flexible. Can you add a comment-block above the
class?

+public:
+    FlexibleGenerator(SkData* data,
+                      SkBitmapFactory::DecodeProc proc);
+    virtual ~FlexibleGenerator();
+    virtual SkData* refEncodedData() SK_OVERRIDE;
+    virtual bool getInfo(SkImageInfo* info) SK_OVERRIDE;
+    virtual bool getPixels(const SkImageInfo& info,
+                           void* pixels,
+                           size_t rowBytes) SK_OVERRIDE;
+private:
+    SkData*     fData;
+    DecodeProc  fDecodeProc;
+    SkImageInfo fInfo;
+    bool        fError;
+};
+FlexibleGenerator::FlexibleGenerator(SkData* data, DecodeProc proc)
+    : fData(data)
+    , fDecodeProc(proc)
+    , fError(false) {
+    SkASSERT(fDecodeProc != NULL);
+    SkASSERT(fData != NULL);
+    fData->ref();
+    fError = !fDecodeProc(fData->data(), fData->size(), &fInfo, NULL);
+}
+
+FlexibleGenerator::~FlexibleGenerator() {
+    fData->unref();
+}
+
+SkData* FlexibleGenerator::refEncodedData() {
+    fData->ref();
+    return fData;
+}
+
+bool FlexibleGenerator::getInfo(SkImageInfo* info) {
+    if (fError)
+        return false;
+    SkASSERT(info != NULL);
+    *info = fInfo;
+    return true;
+}
+
+bool FlexibleGenerator::getPixels(const SkImageInfo& info,
+                                               void* pixels,
+                                               size_t rowBytes) {
+    if (fError)
+        return false;
+    SkASSERT(pixels != NULL);
+    SkBitmapFactory::Target target = {pixels, rowBytes};
+    SkImageInfo tmpInfo = info;
+    return fDecodeProc(fData->data(), fData->size(), &tmpInfo, &target);
+}
+}  // namespace
+
 bool SkBitmapFactory::installPixelRef(SkData* data, SkBitmap* dst) {
     if (NULL == data || 0 == data->size() || dst == NULL) {
         return false;
     }
-
-    SkImageInfo info;
-    if (!fDecodeProc(data->data(), data->size(), &info, NULL)) {
-        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);
+    FlexibleGenerator* gen = SkNEW_ARGS(FlexibleGenerator,
+                                        (data, fDecodeProc));
 
     // fImageCache and fCacheSelector are mutually exclusive.
     SkASSERT(NULL == fImageCache || NULL == fCacheSelector);
-
-    SkImageCache* cache = NULL == fCacheSelector ? fImageCache : fCacheSelector->selectCache(info);
+    SkImageCache* cache = fImageCache;
+    if ((cache == NULL) && (NULL != fCacheSelector)) {
+        SkImageInfo info;
+        if (!gen->getInfo(&info)) {
+            SkDELETE(gen);
+            return false;
+        }
+        cache = fCacheSelector->selectCache(info);
+    }
 
     if (cache != NULL) {
-        // Now set a new LazyPixelRef on dst.
-        SkAutoTUnref<SkLazyPixelRef> lazyRef(SkNEW_ARGS(SkLazyPixelRef,
-                                                        (data, fDecodeProc, cache)));
-        dst->setPixelRef(lazyRef);
-        return true;
+        return SkLazyPixelRef::Install(gen, cache, dst);
     } else {
-        dst->allocPixels();
-        target.fAddr = dst->getPixels();
-        return fDecodeProc(data->data(), data->size(), &info, &target);
+        return SkMallocPixelRef::Install(gen, dst);
     }
 }