Expand pixelref to return SkImageInfo and rowbytes

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 100 matching lines @@
     SkBitmapFactory::Target target;
     target.fAddr = bm->getPixels();
     target.fRowBytes = bm->rowBytes();
     *rowBytes = target.fRowBytes;
     if (!decodeProc(data->data(), data->size(), info, &target)) {
         return NULL;
     }
     return target.fAddr;
 }
 
-void* SkLazyPixelRef::lockScaledImageCachePixels() {
+void* SkLazyPixelRef::lockScaledImageCachePixels(SkImageInfo* info,
+                                                 size_t* rowBytes) {
     SkASSERT(!fErrorInDecoding);
     SkASSERT(NULL == fImageCache);
     SkBitmap bitmap;
-    const SkImageInfo* info = this->getCachedInfo();
-    if (info == NULL) {
+    const SkImageInfo* cachedInfo = this->getCachedInfo();
+    if (cachedInfo == NULL) {
         return NULL;
     }
+    *info = *cachedInfo;
+
     // If this is the first time though, this is guaranteed to fail.
     // Maybe we should have a flag that says "don't even bother looking"
     fScaledCacheId = SkScaledImageCache::FindAndLock(this->getGenerationID(),
                                                      info->fWidth,
                                                      info->fHeight,
                                                      &bitmap);
     if (fScaledCacheId != NULL) {
         SkAutoLockPixels autoLockPixels(bitmap);
         void* pixels = bitmap.getPixels();
         SkASSERT(NULL != pixels);
         // At this point, the autoLockPixels will unlockPixels()
         // to remove bitmap's lock on the pixels.  We will then
         // destroy bitmap.  The *only* guarantee that this pointer
         // remains valid is the guarantee made by
         // SkScaledImageCache that it will not destroy the *other*
         // bitmap (SkScaledImageCache::Rec.fBitmap) that holds a
         // reference to the concrete PixelRef while this record is
         // locked.
+        *rowBytes = bitmap.rowBytes();
         return pixels;

[scroggo, 2013/11/19 18:17:09]

I thought we had merged these two return cases (since the comments and return,
and now rowbytes, are the same)?

[reed1, 2013/11/20 20:56:56]

sgtm

     } else {
         // Cache has been purged, must re-decode.
         void* pixels = decode_into_bitmap(const_cast<SkImageInfo*>(info),
                                           fDecodeProc, &fRowBytes, fData,
                                           &bitmap);
         if (NULL == pixels) {
             fErrorInDecoding = true;
             return NULL;
         }
         fScaledCacheId = SkScaledImageCache::AddAndLock(this->getGenerationID(),
                                                         info->fWidth,
                                                         info->fHeight,
                                                         bitmap);
         SkASSERT(fScaledCacheId != NULL);
+        *rowBytes = bitmap.rowBytes();
         return pixels;
     }
 }
 
-void* SkLazyPixelRef::onLockPixels(SkColorTable**) {
+void* SkLazyPixelRef::onLockPixels(SkImageInfo* info, size_t* rowBytes,
+                                   SkColorTable**) {
     if (fErrorInDecoding) {
         return NULL;
     }
     if (NULL == fImageCache) {
-        return this->lockScaledImageCachePixels();
+        return this->lockScaledImageCachePixels(info, rowBytes);
     } else {
-        return this->lockImageCachePixels();
+        return this->lockImageCachePixels(info, rowBytes);
     }
 }
 
-void* SkLazyPixelRef::lockImageCachePixels() {
+void* SkLazyPixelRef::lockImageCachePixels(SkImageInfo* info, size_t* rowBytes) {
     SkASSERT(fImageCache != NULL);
     SkASSERT(!fErrorInDecoding);
     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) {
@@ skipping 114 matching lines @@
 
     target.fAddr = tmp.getPixels();
     fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
     if (fErrorInDecoding) {
         return false;
     }
 
     *bitmap = tmp;
     return true;
 }