Revert "Revert "cache SkImage::Info calculation in lazypixelref""

src/lazy/SkLazyPixelRef.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 "Sk64.h"
 #include "SkLazyPixelRef.h"
 #include "SkColorTable.h"
@@ skipping 19 matching lines @@
     if (NULL == data) {
         fData = SkData::NewEmpty();
         fErrorInDecoding = true;
     } else {
         fData = data;
         fData->ref();
         fErrorInDecoding = data->size() == 0;
     }
     SkASSERT(cache != NULL);
     cache->ref();
+
+    // mark as uninitialized -- all fields are -1
+    memset(&fLazilyCachedInfo, 0xFF, sizeof(fLazilyCachedInfo));
+        
     // Since this pixel ref bases its data on encoded data, it should never change.
     this->setImmutable();
 }
 
 SkLazyPixelRef::~SkLazyPixelRef() {
     SkASSERT(fData != NULL);
     fData->unref();
     SkASSERT(fImageCache);
     if (fCacheId != SkImageCache::UNINITIALIZED_ID) {
         fImageCache->throwAwayCache(fCacheId);
     }
     fImageCache->unref();
 }
 
 static size_t ComputeMinRowBytesAndSize(const SkImage::Info& info, size_t* rowBytes) {
     *rowBytes = SkImageMinRowBytes(info);
 
     Sk64 safeSize;
     safeSize.setZero();
     if (info.fHeight > 0) {
         safeSize.setMul(info.fHeight, SkToS32(*rowBytes));
     }
     SkASSERT(!safeSize.isNeg());
     return safeSize.is32() ? safeSize.get32() : 0;
 }
 
+const SkImage::Info* SkLazyPixelRef::getCachedInfo() {
+    if (fLazilyCachedInfo.fWidth < 0) {
+        SkImage::Info info;
+        fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, NULL);
+        if (fErrorInDecoding) {
+            return NULL;
+        }
+        fLazilyCachedInfo = info;
+    }
+    return &fLazilyCachedInfo;
+}
+
 void* SkLazyPixelRef::onLockPixels(SkColorTable**) {
     if (fErrorInDecoding) {
         return NULL;
     }
     SkBitmapFactory::Target target;
     // Check to see if the pixels still exist in the cache.
     if (SkImageCache::UNINITIALIZED_ID == fCacheId) {
         target.fAddr = NULL;
     } else {
         SkImageCache::DataStatus status;
         target.fAddr = fImageCache->pinCache(fCacheId, &status);
         if (target.fAddr == NULL) {
             fCacheId = SkImageCache::UNINITIALIZED_ID;
         } else {
             if (SkImageCache::kRetained_DataStatus == status) {
 #if LAZY_CACHE_STATS
                 sk_atomic_inc(&gCacheHits);
 #endif
                 return target.fAddr;
             }
             SkASSERT(SkImageCache::kUninitialized_DataStatus == status);
         }
         // Cache miss. Either pinCache returned NULL or it returned a memory address without the old
         // data
 #if LAZY_CACHE_STATS
         sk_atomic_inc(&gCacheMisses);
 #endif
     }
-    SkImage::Info info;
+
     SkASSERT(fData != NULL && fData->size() > 0);
     if (NULL == target.fAddr) {
-        // Determine the size of the image in order to determine how much memory to allocate.
-        // FIXME: As an optimization, only do this part once.
-        fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, NULL);
-        if (fErrorInDecoding) {
-            // We can only reach here if fCacheId was already set to UNINITIALIZED_ID, or if
-            // pinCache returned NULL, in which case it was reset to UNINITIALIZED_ID.
+        const SkImage::Info* info = this->getCachedInfo();
+        if (NULL == info) {
             SkASSERT(SkImageCache::UNINITIALIZED_ID == fCacheId);
             return NULL;
         }
-
-        size_t bytes = ComputeMinRowBytesAndSize(info, &target.fRowBytes);
+        size_t bytes = ComputeMinRowBytesAndSize(*info, &target.fRowBytes);
         target.fAddr = fImageCache->allocAndPinCache(bytes, &fCacheId);
         if (NULL == target.fAddr) {
             // Space could not be allocated.
             // Just like the last assert, fCacheId must be UNINITIALIZED_ID.
             SkASSERT(SkImageCache::UNINITIALIZED_ID == fCacheId);
             return NULL;
         }
     } else {
         // pinCache returned purged memory to which target.fAddr already points. Set
         // target.fRowBytes properly.
         target.fRowBytes = fRowBytes;
         // Assume that the size is correct, since it was determined by this same function
         // previously.
     }
     SkASSERT(target.fAddr != NULL);
     SkASSERT(SkImageCache::UNINITIALIZED_ID != fCacheId);
-    fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
+    fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), NULL, &target);
     if (fErrorInDecoding) {
         fImageCache->throwAwayCache(fCacheId);
         fCacheId = SkImageCache::UNINITIALIZED_ID;
         return NULL;
     }
     // Upon success, store fRowBytes so it can be used in case pinCache later returns purged memory.
     fRowBytes = target.fRowBytes;
     return target.fAddr;
 }
 
@@ skipping 53 matching lines @@
 
     target.fAddr = tmp.getPixels();
     fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
     if (fErrorInDecoding) {
         return false;
     }
 
     *bitmap = tmp;
     return true;
 }