Revert "PixelRef now returns (nearly) everything that is currently in SkBitmap. The goal is to refactor bitmap later to remove redundancy, and more interestingly, remove the chance for a disconnect between the actual (pixelref) rowbytes and config, and the one claimed by the bitmap."""""

This reverts commit d08eca87a0bef10112a211de540f89656a80b86a.

BUG=

Review URL: https://codereview.chromium.org/108303003

git-svn-id: http://skia.googlecode.com/svn/trunk@12623 2bbb7eff-a529-9590-31e7-b0007b416f81

4 files changed, 36 insertions, 49 deletions

diff --git a/src/lazy/SkCachingPixelRef.cpp b/src/lazy/SkCachingPixelRef.cpp
index fba9845563..667a94931b 100644
--- a/src/lazy/SkCachingPixelRef.cpp
+++ b/src/lazy/SkCachingPixelRef.cpp
@@ -8,6 +8,7 @@
 #include "SkCachingPixelRef.h"
 #include "SkScaledImageCache.h"
 
+
 bool SkCachingPixelRef::Install(SkImageGenerator* generator,
                                 SkBitmap* dst) {
     SkImageInfo info;
@@ -30,10 +31,10 @@ bool SkCachingPixelRef::Install(SkImageGenerator* generator,
 SkCachingPixelRef::SkCachingPixelRef(SkImageGenerator* generator,
                                      const SkImageInfo& info,
                                      size_t rowBytes)
-    : INHERITED(info)
-    , fImageGenerator(generator)
+    : fImageGenerator(generator)
     , fErrorInDecoding(false)
     , fScaledCacheId(NULL)
+    , fInfo(info)
     , fRowBytes(rowBytes) {
     SkASSERT(fImageGenerator != NULL);
 }
@@ -43,32 +44,31 @@ SkCachingPixelRef::~SkCachingPixelRef() {
     // Assert always unlock before unref.
 }
 
-bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) {
+void* SkCachingPixelRef::onLockPixels(SkColorTable** colorTable) {
+    (void)colorTable;
     if (fErrorInDecoding) {
-        return false;  // don't try again.
+        return NULL;  // don't try again.
     }
-    
-    const SkImageInfo& info = this->info();
     SkBitmap bitmap;
     SkASSERT(NULL == fScaledCacheId);
     fScaledCacheId = SkScaledImageCache::FindAndLock(this->getGenerationID(),
-                                                     info.fWidth,
-                                                     info.fHeight,
+                                                     fInfo.fWidth,
+                                                     fInfo.fHeight,
                                                      &bitmap);
     if (NULL == fScaledCacheId) {
         // Cache has been purged, must re-decode.
-        if ((!bitmap.setConfig(info, fRowBytes)) || !bitmap.allocPixels()) {
+        if ((!bitmap.setConfig(fInfo, fRowBytes)) || !bitmap.allocPixels()) {
             fErrorInDecoding = true;
-            return false;
+            return NULL;
         }
         SkAutoLockPixels autoLockPixels(bitmap);
-        if (!fImageGenerator->getPixels(info, bitmap.getPixels(), fRowBytes)) {
+        if (!fImageGenerator->getPixels(fInfo, bitmap.getPixels(), fRowBytes)) {
             fErrorInDecoding = true;
-            return false;
+            return NULL;
         }
         fScaledCacheId = SkScaledImageCache::AddAndLock(this->getGenerationID(),
-                                                        info.fWidth,
-                                                        info.fHeight,
+                                                        fInfo.fWidth,
+                                                        fInfo.fHeight,
                                                         bitmap);
         SkASSERT(fScaledCacheId != NULL);
     }
@@ -78,7 +78,6 @@ bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) {
     SkAutoLockPixels autoLockPixels(bitmap);
     void* pixels = bitmap.getPixels();
     SkASSERT(pixels != NULL);
-    
     // 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
@@ -87,10 +86,7 @@ bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) {
     // bitmap (SkScaledImageCache::Rec.fBitmap) that holds a
     // reference to the concrete PixelRef while this record is
     // locked.
-    rec->fPixels = pixels;
-    rec->fColorTable = NULL;
-    rec->fRowBytes = bitmap.rowBytes();
-    return true;
+    return pixels;
 }
 
 void SkCachingPixelRef::onUnlockPixels() {
diff --git a/src/lazy/SkCachingPixelRef.h b/src/lazy/SkCachingPixelRef.h
index 75710d8bde..4a0387ddf8 100644
--- a/src/lazy/SkCachingPixelRef.h
+++ b/src/lazy/SkCachingPixelRef.h
@@ -40,7 +40,7 @@ public:
 
 protected:
     virtual ~SkCachingPixelRef();
-    virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE;
+    virtual void* onLockPixels(SkColorTable** colorTable) SK_OVERRIDE;
     virtual void onUnlockPixels() SK_OVERRIDE;
     virtual bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; }
 
@@ -58,12 +58,12 @@ private:
     SkImageGenerator* const fImageGenerator;
     bool                    fErrorInDecoding;
     void*                   fScaledCacheId;
+    const SkImageInfo       fInfo;
     const size_t            fRowBytes;
 
     SkCachingPixelRef(SkImageGenerator* imageGenerator,
                       const SkImageInfo& info,
                       size_t rowBytes);
-
     typedef SkPixelRef INHERITED;
 };
 
diff --git a/src/lazy/SkDiscardablePixelRef.cpp b/src/lazy/SkDiscardablePixelRef.cpp
index eb35d0fcc4..6a9507c8c7 100644
--- a/src/lazy/SkDiscardablePixelRef.cpp
+++ b/src/lazy/SkDiscardablePixelRef.cpp
@@ -11,15 +11,17 @@
 
 SkDiscardablePixelRef::SkDiscardablePixelRef(SkImageGenerator* generator,
                                              const SkImageInfo& info,
+                                             size_t size,
                                              size_t rowBytes,
                                              SkDiscardableMemory::Factory* fact)
-    : INHERITED(info)
-    , fGenerator(generator)
+    : fGenerator(generator)
     , fDMFactory(fact)
+    , fInfo(info)
+    , fSize(size)
     , fRowBytes(rowBytes)
-    , fDiscardableMemory(NULL)
-{
+    , fDiscardableMemory(NULL) {
     SkASSERT(fGenerator != NULL);
+    SkASSERT(fSize > 0);
     SkASSERT(fRowBytes > 0);
     // The SkImageGenerator contract requires fGenerator to always
     // decode the same image on each call to getPixels().
@@ -33,39 +35,28 @@ SkDiscardablePixelRef::~SkDiscardablePixelRef() {
     SkDELETE(fGenerator);
 }
 
-bool SkDiscardablePixelRef::onNewLockPixels(LockRec* rec) {
+void* SkDiscardablePixelRef::onLockPixels(SkColorTable**) {
     if (fDiscardableMemory != NULL) {
         if (fDiscardableMemory->lock()) {
-            rec->fPixels = fDiscardableMemory->data();
-            rec->fColorTable = NULL;
-            rec->fRowBytes = fRowBytes;
-            return true;
+            return fDiscardableMemory->data();
         }
         SkDELETE(fDiscardableMemory);
         fDiscardableMemory = NULL;
     }
-    
-    const size_t size = this->info().getSafeSize(fRowBytes);
     if (fDMFactory != NULL) {
-        fDiscardableMemory = fDMFactory->create(size);
+        fDiscardableMemory = fDMFactory->create(fSize);
     } else {
-        fDiscardableMemory = SkDiscardableMemory::Create(size);
+        fDiscardableMemory = SkDiscardableMemory::Create(fSize);
     }
     if (NULL == fDiscardableMemory) {
-        return false;  // Memory allocation failed.
+        return NULL;  // Memory allocation failed.
     }
-
     void* pixels = fDiscardableMemory->data();
-    if (!fGenerator->getPixels(this->info(), pixels, fRowBytes)) {
-        return false;  // TODO(halcanary) Find out correct thing to do.
+    if (!fGenerator->getPixels(fInfo, pixels, fRowBytes)) {
+        return NULL;  // TODO(halcanary) Find out correct thing to do.
     }
-
-    rec->fPixels = pixels;
-    rec->fColorTable = NULL;
-    rec->fRowBytes = fRowBytes;
-    return true;
+    return pixels;
 }
-
 void SkDiscardablePixelRef::onUnlockPixels() {
     if (fDiscardableMemory != NULL) {
         fDiscardableMemory->unlock();
@@ -90,6 +81,7 @@ bool SkInstallDiscardablePixelRef(SkImageGenerator* generator,
     }
     SkAutoTUnref<SkDiscardablePixelRef> ref(SkNEW_ARGS(SkDiscardablePixelRef,
                                                    (generator, info,
+                                                    dst->getSize(),
                                                     dst->rowBytes(),
                                                     factory)));
     dst->setPixelRef(ref);
diff --git a/src/lazy/SkDiscardablePixelRef.h b/src/lazy/SkDiscardablePixelRef.h
index 0a727b6367..44c6df9637 100644
--- a/src/lazy/SkDiscardablePixelRef.h
+++ b/src/lazy/SkDiscardablePixelRef.h
@@ -19,8 +19,7 @@ public:
 
 protected:
     ~SkDiscardablePixelRef();
-
-    virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE;
+    virtual void* onLockPixels(SkColorTable**) SK_OVERRIDE;
     virtual void onUnlockPixels() SK_OVERRIDE;
     virtual bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; }
 
@@ -31,6 +30,8 @@ protected:
 private:
     SkImageGenerator* const fGenerator;
     SkDiscardableMemory::Factory* const fDMFactory;
+    const SkImageInfo fInfo;
+    const size_t fSize;  // size of memory to be allocated
     const size_t fRowBytes;
     // These const members should not change over the life of the
     // PixelRef, since the SkBitmap doesn't expect them to change.
@@ -40,14 +41,12 @@ private:
     /* Takes ownership of SkImageGenerator. */
     SkDiscardablePixelRef(SkImageGenerator* generator,
                           const SkImageInfo& info,
+                          size_t size,
                           size_t rowBytes,
                           SkDiscardableMemory::Factory* factory);
-
     friend bool SkInstallDiscardablePixelRef(SkImageGenerator*,
                                              SkBitmap*,
                                              SkDiscardableMemory::Factory*);
-
     typedef SkPixelRef INHERITED;
 };
-
 #endif  // SkDiscardablePixelRef_DEFINED